Input:
private NodeGroupCreate convertNodeGroups(ClusterEntity clusterEntity, NodeGroupEntity ngEntity, String clusterName) {
    Gson gson = new Gson();
    List<String> groupRoles = gson.fromJson(ngEntity.getRoles(), List.class);
    String distro = clusterEntity.getDistro();
    NodeGroupCreate group = new NodeGroupCreate();
    group.setName(ngEntity.getName());
    EnumSet<HadoopRole> enumRoles = null;
    if (clusterEntity.getAppManager() == null) {
        enumRoles = getEnumRoles(groupRoles, distro);
        if (enumRoles.isEmpty()) {
            throw ClusterConfigException.NO_HADOOP_ROLE_SPECIFIED(ngEntity.getName());
        }
        GroupType groupType = GroupType.fromHadoopRole(enumRoles);
        AuAssert.check(groupType != null);
        group.setGroupType(groupType);
    }
    group.setRoles(groupRoles);
    int cpu = ngEntity.getCpuNum();
    if (cpu > 0) {
        group.setCpuNum(cpu);
    }
    int memory = ngEntity.getMemorySize();
    if (memory > 0) {
        group.setMemCapacityMB(memory);
    }
    Float swapRatio = ngEntity.getSwapRatio();
    if (swapRatio != null && swapRatio > 0) {
        group.setSwapRatio(swapRatio);
    }
    if (ngEntity.getNodeType() != null) {
        group.setInstanceType(ngEntity.getNodeType());
    }
    group.setInstanceNum(ngEntity.getDefineInstanceNum());
    Integer instancePerHost = ngEntity.getInstancePerHost();
    Set<NodeGroupAssociation> associonEntities = ngEntity.getGroupAssociations();
    String ngRacks = ngEntity.getGroupRacks();
    if (instancePerHost == null && (associonEntities == null || associonEntities.isEmpty()) && ngRacks == null) {
        group.setPlacementPolicies(null);
    } else {
        PlacementPolicy policies = new PlacementPolicy();
        policies.setInstancePerHost(instancePerHost);
        if (ngRacks != null) {
            policies.setGroupRacks((GroupRacks) new Gson().fromJson(ngRacks, GroupRacks.class));
        }
        if (associonEntities != null) {
            List<GroupAssociation> associons = new ArrayList<GroupAssociation>(associonEntities.size());
            for (NodeGroupAssociation ae : associonEntities) {
                GroupAssociation a = new GroupAssociation();
                a.setReference(ae.getReferencedGroup());
                a.setType(ae.getAssociationType());
                associons.add(a);
            }
            policies.setGroupAssociations(associons);
        }
        group.setPlacementPolicies(policies);
    }
    String rps = ngEntity.getVcRpNames();
    if (rps != null && rps.length() > 0) {
        logger.debug("String_Node_Str" + ngEntity.getName());
        String[] rpNames = gson.fromJson(rps, String[].class);
        List<VcCluster> vcClusters = rpMgr.getVcResourcePoolByNameList(rpNames);
        group.setVcClusters(vcClusters);
        group.setRpNames(Arrays.asList(rpNames));
    }
    expandGroupStorage(ngEntity, group, enumRoles);
    group.setHaFlag(ngEntity.getHaFlag());
    if (ngEntity.getHadoopConfig() != null) {
        Map<String, Object> hadoopConfig = (new Gson()).fromJson(ngEntity.getHadoopConfig(), Map.class);
        group.setConfiguration(hadoopConfig);
    }
    group.setVmFolderPath(ngEntity.getVmFolderPath());
    return group;
}

Output:
     EnumSet<HadoopRole> enumRoles = null;
-    if (clusterEntity.getAppManager() == null) {
+    if (clusterEntity.getAppManager() == null || Constants.IRONFAN.equalsIgnoreCase(clusterEntity.getAppManager())) {
         enumRoles = getEnumRoles(groupRoles, distro);


Input:
public String getDefaultSpecVersion() {
    return new String("String_Node_Str");
}

Output:
 public String getDefaultSpecVersion() {
-    return new String("String_Node_Str");
+    return "String_Node_Str";
 }


Input:
private double asRelativeValue(final InformationLoss<?> infoLoss) {
    if (result == null)
        return 0;
    return infoLoss.relativeTo(result.getLattice().getLowestScore(), result.getLattice().getHighestScore()) * 100d;
}

Output:
 private double asRelativeValue(final InformationLoss<?> infoLoss) {
-    if (result == null)
+    if (result == null || model == null)
         return 0;


Input:
public Response getProgramInsertions(long uuid) throws Exception {
    ArtifactReadable programArt = atsServer.getArtifactByUuid(uuid);
    if (programArt == null) {
        throw new OseeCoreException("String_Node_Str");
    }
    if (!programArt.getArtifactType().equals(AtsArtifactTypes.Program)) {
        throw new OseeCoreException("String_Node_Str");
    }
    ResultSet<ArtifactReadable> results = programArt.getRelated(AtsRelationTypes.ProgramToInsertion_Insertion);
    List<IAtsConfigObject> insertions = new LinkedList<IAtsConfigObject>();
    for (ArtifactReadable insertion : results) {
        insertions.add(atsServer.getConfigItemFactory().getInsertion(insertion));
    }
    GenericEntity<List<IAtsConfigObject>> entity = new GenericEntity<List<IAtsConfigObject>>(insertions) {
    };
    return Response.ok(entity).build();
}

Output:
     }
-    if (!programArt.getArtifactType().equals(AtsArtifactTypes.Program)) {
+    if (!programArt.isOfType(AtsArtifactTypes.Program)) {
         throw new OseeCoreException("String_Node_Str");


Input:
public static MultipleAlignmentJmol display(MultipleAlignment multAln) throws StructureException, StructureAlignmentException, IOException {
    int size = multAln.size();
    if (multAln.getAtomArrays() == null)
        multAln.getEnsemble().updateAtomArrays();
    for (int i = 0; i < size; i++) {
        if (multAln.getAtomArrays().get(i).length < 1)
            throw new StructureException("String_Node_Str" + multAln.getAtomArrays().get(i).length);
    }
    try {
        List<Atom[]> rotatedAtoms = new ArrayList<Atom[]>();
        for (int i = 0; i < size; i++) {
            Structure displayS = multAln.getAtomArrays().get(i)[0].getGroup().getChain().getParent().clone();
            Atom[] rotCA = StructureTools.getRepresentativeAtomArray(displayS);
            Calc.rotate(rotCA[0].getGroup().getChain().getParent(), multAln.getPose().getRotation().get(i));
            Calc.shift(rotCA[0].getGroup().getChain().getParent(), multAln.getPose().getTranslation().get(i));
            rotatedAtoms.add(rotCA);
        }
        MultipleAlignmentJmol jmol = new MultipleAlignmentJmol(multAln, rotatedAtoms);
        jmol.setTitle(jmol.getStructure().getPDBHeader().getTitle());
        return jmol;
    } catch (StructureAlignmentException e) {
        e.printStackTrace();
        System.err.println("String_Node_Str");
        MultipleAlignmentJmol jmol = new MultipleAlignmentJmol(multAln, multAln.getAtomArrays());
        jmol.setTitle(jmol.getStructure().getPDBHeader().getTitle());
        return jmol;
    }
}

Output:
     int size = multAln.size();
-    if (multAln.getAtomArrays() == null)
-        multAln.getEnsemble().updateAtomArrays();
+    List<Atom[]> atomArrays = multAln.getEnsemble().getAtomArrays();
     for (int i = 0; i < size; i++) {


Input:
public float getPlayerRelativeBlockHardness(EntityPlayer player, World world, int x, int y, int z) {
    final TileEntity tile = world.getTileEntity(x, y, z);
    if ((((TileMoarP) tile).canPlayerAccess(player) || isOpBreakable(player))) {
        return blockHardness;
    }
    return -1.0f;
}

Output:
     final TileEntity tile = world.getTileEntity(x, y, z);
-    if ((((TileMoarP) tile).canPlayerAccess(player) || isOpBreakable(player))) {
+    if (tile == null || (((TileMoarP) tile).canPlayerAccess(player) || isOpBreakable(player))) {
         return blockHardness;


Input:
public int partition(Token[] tokens, int size, int n) {
    if (tokens.length > n) {
        return midPointSelect(tokens, 0, size - 1, n);
    } else {
        int r = -1;
        float lowestScore = Float.MAX_VALUE;
        for (int i = 0; i < tokens.length; i++) {
            Token current = tokens[i];
            float currentScore = current.getScore();
            if (currentScore <= lowestScore) {
                lowestScore = currentScore;
                r = i;
            }
        }
        int last = size - 1;
        if (last >= 0) {
            Token lastToken = tokens[last];
            setToken(tokens, last, tokens[r]);
            setToken(tokens, r, lastToken);
        }
        return last;
    }
}

Output:
     if (tokens.length > n) {
-        return midPointSelect(tokens, 0, size - 1, n);
+        return midPointSelect(tokens, 0, size - 1, n, 0);
     } else {


Input:
public void loadFromNBT(NBTTagCompound par1) {
    dataLoaded = false;
    NBTTagList first = par1.getTagList("String_Node_Str");
    todo.clear();
    for (int i = 0; i < first.tagCount(); i++) {
        NBTTagCompound nbt = (NBTTagCompound) first.tagAt(i);
        todo.put(nbt.getString("String_Node_Str"), new BlockPositionList(nbt));
    }
    NBTTagList second = par1.getTagList("String_Node_Str");
    replace.clear();
    for (int i = 0; i < second.tagCount(); i++) {
        NBTTagCompound nbt = (NBTTagCompound) second.tagAt(i);
        replace.put(nbt.getString("String_Node_Str"), new BlockPositionList(nbt));
    }
    dataLoaded = true;
}

Output:
 public void loadFromNBT(NBTTagCompound par1) {
-    dataLoaded = false;
+    dataLoaded = DataType.Loading;
     NBTTagList first = par1.getTagList("String_Node_Str");


Input:
public void widgetSelected(SelectionEvent e) {
    if (messageManager == null || messageManager.getMessages().size() < 1) {
        MessageDialog.openWarning(getShell(), "String_Node_Str", "String_Node_Str");
        return;
    }
    UnboundedFifoBuffer messages = messageManager.getMessages();
    Iterator iterator = messages.iterator();
    StringBuilder content = new StringBuilder();
    while (iterator.hasNext()) {
        ReportMessage message = (ReportMessage) iterator.next();
        content.append(message.getContent());
    }
    String[] msg = content.toString().split("String_Node_Str");
    if (!msg[msg.length - 1].startsWith("String_Node_Str")) {
        MessageDialog.openWarning(getShell(), "String_Node_Str", "String_Node_Str");
        return;
    }
    FileDialog dialog = new FileDialog(getShell(), SWT.SAVE);
    dialog.setFilterPath("String_Node_Str");
    String fileName = dialog.open();
    if (fileName != null) {
        FileWriter writer = null;
        try {
            writer = new FileWriter(fileName);
            writer.write(content.toString());
        } catch (IOException e1) {
            e1.printStackTrace();
        } finally {
            try {
                if (writer != null) {
                    writer.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
}

Output:
     }
-    String[] msg = content.toString().split("String_Node_Str");
-    if (!msg[msg.length - 1].startsWith("String_Node_Str")) {
+    if (isMonitoring) {
         MessageDialog.openWarning(getShell(), "String_Node_Str", "String_Node_Str");


Input:
public void doRun() throws Exception {
    ContiguousBlock cb = new ContiguousBlock();
    synchronized (FreeformTrackListTableModel.this) {
        for (Track t : trax) {
            int idx = doAdd(t);
            if (idx >= 0)
                cb.add(idx);
        }
    }
    if (fireUpdate) {
        int[] block;
        while ((block = cb.getNextBlock()) != null) {
            fireTableRowsInserted(block[0], block[1]);
        }
    }
}

Output:
 public void doRun() throws Exception {
-    ContiguousBlock cb = new ContiguousBlock();
+    ContiguousBlockList cb = new ContiguousBlockList();
     synchronized (FreeformTrackListTableModel.this) {


Input:
public Builder setUserLocation(double lat, double lon) {
    mBuilder.appendQueryParameter("String_Node_Str", String.valueOf(lat));
    mBuilder.appendQueryParameter("String_Node_Str", String.valueOf(lon));
    return this;
}

Output:
 public Builder setUserLocation(double lat, double lon) {
-    mBuilder.appendQueryParameter("String_Node_Str", String.valueOf(lat));
-    mBuilder.appendQueryParameter("String_Node_Str", String.valueOf(lon));
+    mPostData.appendQueryParameter("String_Node_Str", String.valueOf(lat));
+    mPostData.appendQueryParameter("String_Node_Str", String.valueOf(lon));
     return this;


Input:
public <IdType> List<IdType> persistArrayDeprecate(Class<?> modelClass, JSONArray jsonArray) throws JSONException {
    try {
        mDatabase.beginTransaction();
        List<IdType> id_list = persistArrayOfObjects(modelClass, jsonArray);
        mDatabase.setTransactionSuccessful();
        return id_list;
    } catch (JSONException e) {
        throw e;
    } finally {
        if (mDatabase.inTransaction()) {
            mDatabase.endTransaction();
        }
    }
}

Output:
     } finally {
-        if (mDatabase.inTransaction()) {
-            mDatabase.endTransaction();
-        }
+        endTransaction();
     }


Input:
public boolean isPersistent() {
    return !(msnGroup instanceof VolatileGroup);
}

Output:
 public boolean isPersistent() {
-    return !(msnGroup instanceof VolatileGroup);
+    return isPersistent;
 }


Input:
private void save() {
    LibHover.saveLibraries();
}

Output:
 private void save() {
-    LibHover.saveLibraries();
+    if (stateLocation == null)
+        stateLocation = this.getStateLocation();
+    if (preferenceStore == null)
+        preferenceStore = this.getPreferenceStore();
+    LibHover.saveLibraries(stateLocation, preferenceStore);
 }


Input:
public void postAlloc(ObjectReference ref, ObjectReference typeRef, int bytes, int allocator) throws InlinePragma {
    if (allocator == MS.ALLOC_DEFAULT)
        MS.msSpace.initializeHeader(ref);
    else
        super.postAlloc(ref, typeRef, bytes, allocator);
}

Output:
     if (allocator == MS.ALLOC_DEFAULT)
-        MS.msSpace.initializeHeader(ref);
+        MS.msSpace.postAlloc(ref);
     else


Input:
public Object getValue(Injector injector) {
    if (null == provider) {
        synchronized (this) {
            if (null == provider) {
                provider = isProvider ? injector.getProvider(getBindingForType(getProvidedType(type))) : injector.getProvider(getPrimaryBindingKey());
            }
        }
    }
    return provider.get();
}

Output:
     }
-    return provider.get();
+    return isProvider ? provider : provider.get();
 }


Input:
public boolean replace(K key, V value, ExpiryPolicy expiryPolicy) {
    final long start = System.nanoTime();
    final Future<Boolean> f = replaceInternal(key, null, value, expiryPolicy, false, true, false);
    try {
        boolean replaced = f.get();
        if (statisticsEnabled) {
            handleStatisticsOnReplace(false, start, replaced);
        }
        return replaced;
    } catch (Throwable e) {
        throw ExceptionUtil.rethrowAllowedTypeFirst(e, CacheException.class);
    }
}

Output:
     } catch (Throwable e) {
-        throw ExceptionUtil.rethrowAllowedTypeFirst(e, CacheException.class);
+        throw rethrowAllowedTypeFirst(e, CacheException.class);
     }


Input:
protected Hashtable buildFieldTypes() {
    Hashtable fieldTypeMapping;
    fieldTypeMapping = new Hashtable();
    fieldTypeMapping.put(Boolean.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(Integer.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(Long.class, new FieldTypeDefinition("String_Node_Str", 19));
    fieldTypeMapping.put(Float.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(Double.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(Short.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(Byte.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(java.math.BigInteger.class, new FieldTypeDefinition("String_Node_Str", 32));
    fieldTypeMapping.put(java.math.BigDecimal.class, new FieldTypeDefinition("String_Node_Str", 32).setLimits(32, -19, 19));
    fieldTypeMapping.put(Number.class, new FieldTypeDefinition("String_Node_Str", 32).setLimits(32, -19, 19));
    fieldTypeMapping.put(String.class, new FieldTypeDefinition("String_Node_Str", 255));
    fieldTypeMapping.put(Character.class, new FieldTypeDefinition("String_Node_Str", 1));
    fieldTypeMapping.put(Byte[].class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(Character[].class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(byte[].class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(char[].class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(java.sql.Blob.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(java.sql.Clob.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(java.sql.Date.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(java.sql.Time.class, new FieldTypeDefinition("String_Node_Str", false));
    fieldTypeMapping.put(java.sql.Timestamp.class, new FieldTypeDefinition("String_Node_Str", false));
    return fieldTypeMapping;
}

Output:
     fieldTypeMapping.put(Number.class, new FieldTypeDefinition("String_Node_Str", 32).setLimits(32, -19, 19));
-    fieldTypeMapping.put(String.class, new FieldTypeDefinition("String_Node_Str", 255));
+    fieldTypeMapping.put(String.class, new FieldTypeDefinition("String_Node_Str", DEFAULT_VARCHAR_SIZE));
     fieldTypeMapping.put(Character.class, new FieldTypeDefinition("String_Node_Str", 1));


Input:
public Class<?>[] getInterfaces() {
    ReflectionData<T> rd = reflectionData();
    if (rd == null) {
        return getInterfaces0();
    } else {
        Class<?>[] interfaces = rd.interfaces;
        if (interfaces == null) {
            interfaces = getInterfaces0();
            rd.interfaces = interfaces;
        }
        return interfaces.clone();
    }
}

Output:
         }
-        return interfaces.clone();
+        return cloneArray ? interfaces.clone() : interfaces;
     }


Input:
public void completeCall(Object returnObject) {
    assert (_sourceAddress != null);
    assert (_targetAddress != null);
    RpcCallResponsePdu pdu = new RpcCallResponsePdu();
    pdu.setCommand(_requestPdu.getCommand());
    pdu.setRequestTag(_requestPdu.getRequestTag());
    pdu.setRequestStartTick(_requestPdu.getRequestStartTick());
    pdu.setRequestStartTick(RpcCallResponsePdu.RESULT_SUCCESSFUL);
    if (returnObject != null) {
        assert (_rpcProvider.getMessageSerializer() != null);
        pdu.setSerializedResult(_rpcProvider.getMessageSerializer().serializeTo(returnObject.getClass(), returnObject));
    }
    _rpcProvider.sendRpcPdu(_targetAddress, _sourceAddress, _rpcProvider.getMessageSerializer().serializeTo(RpcCallResponsePdu.class, pdu));
}

Output:
     }
-    _rpcProvider.sendRpcPdu(_targetAddress, _sourceAddress, _rpcProvider.getMessageSerializer().serializeTo(RpcCallResponsePdu.class, pdu));
+    _rpcProvider.sendRpcPdu(_sourceAddress, _targetAddress, _rpcProvider.getMessageSerializer().serializeTo(RpcCallResponsePdu.class, pdu));
 }


Input:
public E take(final long waitMillis) {
    try {
        lock.lockInterruptibly();
        added.await(waitMillis, TimeUnit.MILLISECONDS);
        return take();
    } catch (final InterruptedException e) {
        LOG.error(e.getMessage(), e);
    } finally {
        lock.unlock();
    }
    return null;
}

Output:
         lock.lockInterruptibly();
-        added.await(waitMillis, TimeUnit.MILLISECONDS);
+        if (waitMillis < 0)
+            added.await();
+        else
+            added.await(waitMillis, TimeUnit.MILLISECONDS);
         return take();


Input:
public boolean onItemClick(int position) {
    if (contactItems.size() > position) {
        UserItem userItem = contactItems.get(position);
        RetrofitBucket retrofitBucket = ApiHelper.getRetrofitBucketForCreateRoom(userEntity.getBaseUrl(), "String_Node_Str", userItem.getModel().getUserId());
        ncApi.createRoom(ApiHelper.getCredentials(userEntity.getUsername(), userEntity.getToken()), retrofitBucket.getUrl(), retrofitBucket.getQueryMap()).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<RoomOverall>() {

            public void onSubscribe(Disposable d) {
            }
            public void onNext(RoomOverall roomOverall) {
                overridePushHandler(new NoOpControllerChangeHandler());
                overridePopHandler(new NoOpControllerChangeHandler());
                Intent callIntent = new Intent(getActivity(), CallActivity.class);
                BundleBuilder bundleBuilder = new BundleBuilder(new Bundle());
                bundleBuilder.putString("String_Node_Str", roomOverall.getOcs().getData().getToken());
                bundleBuilder.putParcelable("String_Node_Str", Parcels.wrap(userEntity));
                callIntent.putExtras(bundleBuilder.build());
                startActivity(callIntent);
            }
            public void onError(Throwable e) {
            }
            public void onComplete() {
            }
        });
    }
    return true;
}

Output:
 public boolean onItemClick(int position) {
-    if (contactItems.size() > position) {
-        UserItem userItem = contactItems.get(position);
-        RetrofitBucket retrofitBucket = ApiHelper.getRetrofitBucketForCreateRoom(userEntity.getBaseUrl(), "String_Node_Str", userItem.getModel().getUserId());
-        ncApi.createRoom(ApiHelper.getCredentials(userEntity.getUsername(), userEntity.getToken()), retrofitBucket.getUrl(), retrofitBucket.getQueryMap()).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<RoomOverall>() {
+    UserItem userItem = adapter.getItem(position);
+    RetrofitBucket retrofitBucket = ApiHelper.getRetrofitBucketForCreateRoom(userEntity.getBaseUrl(), "String_Node_Str", userItem.getModel().getUserId());
+    ncApi.createRoom(ApiHelper.getCredentials(userEntity.getUsername(), userEntity.getToken()), retrofitBucket.getUrl(), retrofitBucket.getQueryMap()).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<RoomOverall>() {


Input:
private final void checkLandmarks(ShortPoint2D startPos) {
    short startX = startPos.getX();
    short startY = startPos.getY();
    if (grid.isBlocked(startX, startY))
        return;
    short startPartition = grid.getPartitionAt(startPos.getX(), startPos.getY());
    for (EDirection currDir : EDirection.values) {
        short currX = (short) (startX + currDir.gridDeltaX);
        short currY = (short) (startY + currDir.gridDeltaY);
        if (grid.isBlocked(currX, currY)) {
            if (needsRelabel(currX, currY, startPartition)) {
                System.out.println("String_Node_Str" + currX + "String_Node_Str" + currY + "String_Node_Str" + startPartition);
                relabel(grid.getBlockedPartition(startX, startY), currX, currY, startPartition);
            }
        }
    }
}

Output:
 private final void checkLandmarks(ShortPoint2D startPos) {
-    short startX = startPos.getX();
-    short startY = startPos.getY();
+    final short startX = startPos.getX();
+    final short startY = startPos.getY();
     if (grid.isBlocked(startX, startY))


Input:
public void testAddLockAndWriteColumnToGet() throws IOException {
    byte[][] families = new byte[][] { FAMILY, FAMILY, ANOTHER_FAMILY };
    byte[][] qualifiers = new byte[][] { QUALIFIER, ANOTHER_FAMILY, QUALIFIER };
    Get userGet = new Get(ROW);
    for (int i = 0; i < families.length; ++i) {
        userGet.addColumn(families[i], qualifiers[i]);
    }
    Get internalGet = new Get(userGet.getRow());
    ThemisCpUtil.addLockAndWriteColumnToGet(userGet, internalGet, PREWRITE_TS);
    Assert.assertEquals(3, internalGet.getFamilyMap().size());
    Assert.assertEquals(4, internalGet.getFamilyMap().get(FAMILY).size());
    Assert.assertEquals(2, internalGet.getFamilyMap().get(ANOTHER_FAMILY).size());
    Assert.assertEquals(3, internalGet.getFamilyMap().get(ColumnUtil.LOCK_FAMILY_NAME).size());
    for (int i = 0; i < families.length; ++i) {
        checkReadWithLockAndWriteColumns(internalGet.getFamilyMap(), new ColumnCoordinate(families[i], qualifiers[i]));
    }
    Assert.assertEquals(PREWRITE_TS, internalGet.getTimeRange().getMax());
    Assert.assertEquals(1, internalGet.getMaxVersions());
    userGet = new Get(ROW);
    userGet.addFamily(FAMILY);
    internalGet = new Get(userGet.getRow());
    ThemisCpUtil.addLockAndWriteColumnToGet(userGet, internalGet, PREWRITE_TS);
    checkAddLockAndDataFamily(internalGet, ColumnUtil.LOCK_FAMILY_NAME, FAMILY);
    Assert.assertTrue(internalGet.getFilter() instanceof ExcludeDataColumnFilter);
    userGet = new Get(ROW);
    userGet.addFamily(FAMILY);
    userGet.addColumn(ANOTHER_FAMILY, ANOTHER_QUALIFIER);
    internalGet = new Get(userGet.getRow());
    ThemisCpUtil.addLockAndWriteColumnToGet(userGet, internalGet, PREWRITE_TS);
    checkAddLockAndDataFamily(internalGet, ColumnUtil.LOCK_FAMILY_NAME, FAMILY);
    checkReadWithWriteColumns(internalGet.getFamilyMap(), new ColumnCoordinate(ANOTHER_FAMILY, ANOTHER_QUALIFIER));
}

Output:
     userGet = new Get(ROW);
-    userGet.addFamily(FAMILY);
-    userGet.addColumn(ANOTHER_FAMILY, ANOTHER_QUALIFIER);
+    userGet.addFamily(ANOTHER_FAMILY);
+    userGet.addColumn(FAMILY, ANOTHER_QUALIFIER);
     internalGet = new Get(userGet.getRow());


Input:
static int wtf(int logId, String tag, String msg, Throwable tr) {
    TerribleFailure what = new TerribleFailure(msg, tr);
    int bytes = println_native(logId, ASSERT, tag, msg + '\n' + getStackTraceString(tr));
    sWtfHandler.onTerribleFailure(tag, what);
    return bytes;
}

Output:
     TerribleFailure what = new TerribleFailure(msg, tr);
-    int bytes = println_native(logId, ASSERT, tag, msg + '\n' + getStackTraceString(tr));
+    int bytes = println_native(logId, ASSERT, tag, msg + '\n' + getStackTraceString(localStack ? what : tr));
     sWtfHandler.onTerribleFailure(tag, what);


Input:
protected void populateItem(final ListItem<SchemaMappingTO> item) {
    final SchemaMappingTO mappingTO = item.getModelObject();
    item.add(new AjaxDecoratedCheckbox("String_Node_Str", new Model(Boolean.FALSE)) {
        private static final long serialVersionUID = 7170946748485726506L;
        protected void onUpdate(final AjaxRequestTarget target) {
            int index = -1;
            for (int i = 0; i < resourceTO.getMappings().size() && index == -1; i++) {
                if (mappingTO.equals(resourceTO.getMappings().get(i))) {
                    index = i;
                }
            }
            if (index != -1) {
                resourceTO.getMappings().remove(index);
                item.getParent().removeAll();
                target.addComponent(mappingContainer);
            }
        }
        protected IAjaxCallDecorator getAjaxCallDecorator() {
            return new AjaxPreprocessingCallDecorator(super.getAjaxCallDecorator()) {
                private static final long serialVersionUID = -7927968187160354605L;
                public CharSequence preDecorateScript(final CharSequence script) {
                    return "String_Node_Str" + getString("String_Node_Str") + "String_Node_Str" + "String_Node_Str" + script + "String_Node_Str" + "String_Node_Str";
                }
            };
        }
    });
    final DropDownChoice<String> schemaAttrChoice = new DropDownChoice<String>("String_Node_Str", new PropertyModel<String>(mappingTO, "String_Node_Str"), (IModel) null);
    schemaAttrChoice.add(new AjaxFormComponentUpdatingBehavior("String_Node_Str") {
        private static final long serialVersionUID = -1107858522700306810L;
        protected void onUpdate(AjaxRequestTarget art) {
            mappingTO.setSourceAttrName(schemaAttrChoice.getModelObject());
        }
    });
    schemaAttrChoice.setOutputMarkupId(true);
    if (mappingTO.getSourceMappingType() == null) {
        schemaAttrChoice.setChoices(Collections.EMPTY_LIST);
    } else {
        switch(mappingTO.getSourceMappingType()) {
            case UserSchema:
                schemaAttrChoice.setChoices(uSchemaAttrNames);
                break;
            case UserDerivedSchema:
                schemaAttrChoice.setChoices(uDerSchemaAttrNames);
                break;
            case UserVirtualSchema:
                schemaAttrChoice.setChoices(uVirSchemaAttrNames);
                break;
            case SyncopeUserId:
                schemaAttrChoice.setEnabled(false);
                schemaAttrChoice.setRequired(false);
                schemaAttrChoice.setChoices(Collections.EMPTY_LIST);
                mappingTO.setSourceAttrName("String_Node_Str");
                break;
            case Password:
                schemaAttrChoice.setEnabled(false);
                schemaAttrChoice.setRequired(false);
                schemaAttrChoice.setChoices(Collections.EMPTY_LIST);
                mappingTO.setSourceAttrName("String_Node_Str");
                break;
            default:
                schemaAttrChoice.setChoices(Collections.EMPTY_LIST);
        }
    }
    item.add(schemaAttrChoice);
    item.add(new SourceMappingTypesDropDownChoice("String_Node_Str", new PropertyModel<SourceMappingType>(mappingTO, "String_Node_Str"), sourceMappingTypes, schemaAttrChoice).setRequired(true).setOutputMarkupId(true));
    final TextField<String> destAttrName = new TextField<String>("String_Node_Str", new PropertyModel(mappingTO, "String_Node_Str"));
    destAttrName.setRequired(true);
    destAttrName.setLabel(new ResourceModel("String_Node_Str"));
    destAttrName.setOutputMarkupId(true);
    destAttrName.add(new AjaxFormComponentUpdatingBehavior("String_Node_Str") {
        private static final long serialVersionUID = -1107858522700306810L;
        protected void onUpdate(AjaxRequestTarget art) {
            mappingTO.setDestAttrName(destAttrName.getModelObject());
        }
    });
    item.add(destAttrName);
    final AutoCompleteTextField<String> mandatoryCondirion = new AutoCompleteTextField<String>("String_Node_Str", new PropertyModel(mappingTO, "String_Node_Str")) {
        private static final long serialVersionUID = -6648767303091874219L;
        protected Iterator getChoices(final String input) {
            List<String> choices;
            if ("String_Node_Str".startsWith(input.toLowerCase())) {
                choices = Collections.singletonList("String_Node_Str");
            } else if ("String_Node_Str".startsWith(input.toLowerCase())) {
                choices = Collections.singletonList("String_Node_Str");
            } else {
                choices = Collections.EMPTY_LIST;
            }
            return choices.iterator();
        }
    };
    mandatoryCondirion.add(new AjaxFormComponentUpdatingBehavior("String_Node_Str") {
        private static final long serialVersionUID = -1107858522700306810L;
        protected void onUpdate(AjaxRequestTarget art) {
            mappingTO.setMandatoryCondition(mandatoryCondirion.getModelObject());
        }
    });
    item.add(mandatoryCondirion);
    final CheckBox accountId = new CheckBox("String_Node_Str", new PropertyModel(mappingTO, "String_Node_Str"));
    accountId.add(new AjaxFormComponentUpdatingBehavior("String_Node_Str") {
        private static final long serialVersionUID = -1107858522700306810L;
        protected void onUpdate(AjaxRequestTarget art) {
            mappingTO.setAccountid(accountId.getModelObject());
        }
    });
    item.add(accountId);
    final CheckBox password = new CheckBox("String_Node_Str", new PropertyModel(mappingTO, "String_Node_Str"));
    password.add(new AjaxFormComponentUpdatingBehavior("String_Node_Str") {
        private static final long serialVersionUID = -1107858522700306810L;
        protected void onUpdate(AjaxRequestTarget art) {
            mappingTO.setPassword(password.getModelObject());
        }
    });
    item.add(password);
}

Output:
     });
-    final DropDownChoice<String> schemaAttrChoice = new DropDownChoice<String>("String_Node_Str", new PropertyModel<String>(mappingTO, "String_Node_Str"), (IModel) null);
-    schemaAttrChoice.add(new AjaxFormComponentUpdatingBehavior("String_Node_Str") {
-        private static final long serialVersionUID = -1107858522700306810L;
-        protected void onUpdate(AjaxRequestTarget art) {
-            mappingTO.setSourceAttrName(schemaAttrChoice.getModelObject());
-        }
-    });
-    schemaAttrChoice.setOutputMarkupId(true);
+    final AjaxDropDownChoicePanel sourceAttrNames = new AjaxDropDownChoicePanel<String>("String_Node_Str", getString("String_Node_Str"), new PropertyModel(mappingTO, "String_Node_Str"), true);
+    sourceAttrNames.setChoices(resourceSchemaNames);
+    sourceAttrNames.setRequired(true);
+    sourceAttrNames.setStyleShet("String_Node_Str");
     if (mappingTO.getSourceMappingType() == null) {


Input:
public List<Object[]> transform(List<Object[]> tuples) {
    FixedArrayList correlationParams = new FixedArrayList(batchSize);
    int tupleOffset = batchSize > 1 ? 1 : 0;
    Iterator<Object[]> tupleListIter = tuples.iterator();
    final String correlationRoot = applyAndGetCorrelationRoot(expectBatchCorrelationValues);
    EntityManager em = criteriaBuilder.getEntityManager();
    if (viewRootJpqlMacro.usesViewRoot()) {
        int totalSize = tuples.size();
        Map<Object, Map<Object, TuplePromise>> viewRoots = new HashMap<Object, Map<Object, TuplePromise>>(totalSize);
        Map<Object, Map<Object, TuplePromise>> correlationValues = new HashMap<Object, Map<Object, TuplePromise>>(totalSize);
        while (tupleListIter.hasNext()) {
            Object[] tuple = tupleListIter.next();
            Object viewRootKey = tuple[0];
            Object correlationValueKey = tuple[startIndex];
            Map<Object, TuplePromise> viewRootCorrelationValues = viewRoots.get(viewRootKey);
            if (viewRootCorrelationValues == null) {
                viewRootCorrelationValues = new HashMap<Object, TuplePromise>();
                viewRoots.put(viewRootKey, viewRootCorrelationValues);
            }
            TuplePromise viewRootPromise = viewRootCorrelationValues.get(correlationValueKey);
            if (viewRootPromise == null) {
                viewRootPromise = new TuplePromise(startIndex);
                viewRootCorrelationValues.put(correlationValueKey, viewRootPromise);
            }
            viewRootPromise.add(tuple);
            Map<Object, TuplePromise> correlationValueViewRoots = correlationValues.get(correlationValueKey);
            if (correlationValueViewRoots == null) {
                correlationValueViewRoots = new HashMap<Object, TuplePromise>();
                correlationValues.put(correlationValueKey, correlationValueViewRoots);
            }
            TuplePromise correlationValuePromise = correlationValueViewRoots.get(viewRootKey);
            if (correlationValuePromise == null) {
                correlationValuePromise = new TuplePromise(startIndex);
                correlationValueViewRoots.put(viewRootKey, correlationValuePromise);
            }
            correlationValuePromise.add(tuple);
        }
        boolean batchCorrelationValues = viewRoots.size() <= correlationValues.size();
        FixedArrayList viewRootIds = new FixedArrayList(batchSize);
        if (batchCorrelationValues) {
            if (batchSize > 1) {
                if (!expectBatchCorrelationValues) {
                    applyAndGetCorrelationRoot(true);
                }
                criteriaBuilder.select(correlationKeyExpression);
            }
            correlator.finish(criteriaBuilder, entityViewConfiguration, tupleOffset, correlationRoot);
            populateParameters(criteriaBuilder);
            query = criteriaBuilder.getQuery();
            for (Map.Entry<Object, Map<Object, TuplePromise>> batchEntry : viewRoots.entrySet()) {
                Map<Object, TuplePromise> batchValues = batchEntry.getValue();
                for (Map.Entry<Object, TuplePromise> batchValueEntry : batchValues.entrySet()) {
                    if (correlationBasisEntity != null) {
                        correlationParams.add(em.getReference(correlationBasisEntity, batchValueEntry.getKey()));
                    } else {
                        correlationParams.add(batchValueEntry.getKey());
                    }
                    if (batchSize == correlationParams.realSize()) {
                        viewRootIds.add(batchEntry.getKey());
                        Object defaultKey;
                        if (correlationBasisEntity != null) {
                            defaultKey = em.getEntityManagerFactory().getPersistenceUnitUtil().getIdentifier(correlationParams.get(0));
                        } else {
                            defaultKey = correlationParams.get(0);
                        }
                        batchLoad(batchValues, correlationParams, viewRootIds, defaultKey, true);
                    }
                }
                if (correlationParams.realSize() > 0) {
                    viewRootIds.add(batchEntry.getKey());
                    batchLoad(batchValues, correlationParams, viewRootIds, null, true);
                }
            }
            fillDefaultValues(viewRoots);
        } else {
            if (batchSize > 1) {
                if (expectBatchCorrelationValues) {
                    applyAndGetCorrelationRoot(false);
                }
                criteriaBuilder.select(correlationKeyExpression);
            }
            correlator.finish(criteriaBuilder, entityViewConfiguration, tupleOffset, correlationRoot);
            populateParameters(criteriaBuilder);
            query = criteriaBuilder.getQuery();
            for (Map.Entry<Object, Map<Object, TuplePromise>> batchEntry : correlationValues.entrySet()) {
                Map<Object, TuplePromise> batchValues = batchEntry.getValue();
                for (Map.Entry<Object, TuplePromise> batchValueEntry : batchValues.entrySet()) {
                    if (viewRootJpqlMacro.usesViewRootEntityParameter()) {
                        viewRootIds.add(em.getReference(viewRootType.getEntityClass(), batchValueEntry.getKey()));
                    } else {
                        viewRootIds.add(batchValueEntry.getKey());
                    }
                    if (batchSize == viewRootIds.realSize()) {
                        if (correlationBasisEntity != null) {
                            correlationParams.add(em.getReference(correlationBasisEntity, batchEntry.getKey()));
                        } else {
                            correlationParams.add(batchEntry.getKey());
                        }
                        Object defaultKey;
                        if (viewRootJpqlMacro.usesViewRootEntityParameter()) {
                            defaultKey = em.getEntityManagerFactory().getPersistenceUnitUtil().getIdentifier(viewRootIds.get(0));
                        } else {
                            defaultKey = viewRootIds.get(0);
                        }
                        batchLoad(batchValues, correlationParams, viewRootIds, defaultKey, false);
                    }
                }
                if (viewRootIds.realSize() > 0) {
                    if (correlationBasisEntity != null) {
                        correlationParams.add(em.getReference(correlationBasisEntity, batchEntry.getKey()));
                    } else {
                        correlationParams.add(batchEntry.getKey());
                    }
                    batchLoad(batchValues, correlationParams, viewRootIds, null, false);
                }
            }
            fillDefaultValues(correlationValues);
        }
    } else {
        if (batchSize > 1) {
            if (!expectBatchCorrelationValues) {
                applyAndGetCorrelationRoot(true);
            }
            criteriaBuilder.select(correlationKeyExpression);
        }
        correlator.finish(criteriaBuilder, entityViewConfiguration, tupleOffset, correlationRoot);
        populateParameters(criteriaBuilder);
        query = criteriaBuilder.getQuery();
        Map<Object, TuplePromise> correlationValues = new HashMap<Object, TuplePromise>(tuples.size());
        while (tupleListIter.hasNext()) {
            Object[] tuple = tupleListIter.next();
            Object correlationValue = tuple[startIndex];
            TuplePromise tupleIndexValue = correlationValues.get(correlationValue);
            if (tupleIndexValue == null) {
                tupleIndexValue = new TuplePromise(startIndex);
                tupleIndexValue.add(tuple);
                correlationValues.put(correlationValue, tupleIndexValue);
                if (correlationBasisEntity != null) {
                    correlationParams.add(em.getReference(correlationBasisEntity, tuple[startIndex]));
                } else {
                    correlationParams.add(tuple[startIndex]);
                }
                if (batchSize == correlationParams.realSize()) {
                    Object defaultKey;
                    if (correlationBasisEntity != null) {
                        defaultKey = em.getEntityManagerFactory().getPersistenceUnitUtil().getIdentifier(correlationParams.get(0));
                    } else {
                        defaultKey = correlationParams.get(0);
                    }
                    batchLoad(correlationValues, correlationParams, null, defaultKey, batchSize > 1);
                }
            } else {
                tupleIndexValue.add(tuple);
            }
        }
        if (correlationParams.realSize() > 0) {
            batchLoad(correlationValues, correlationParams, null, null, batchSize > 1);
        }
        fillDefaultValues(Collections.singletonMap(null, correlationValues));
    }
    return tuples;
}

Output:
                 }
-                criteriaBuilder.select(correlationKeyExpression);
+                criteriaBuilder.select(correlationSelectExpression);
             }


Input:
void destroySession(final HazelcastHttpSession session) {
    log("String_Node_Str" + session.getId());
    mapSessions.remove(session.getId());
    mapOriginalSessions.remove(session.originalSession.getId());
    session.destroy();
    getClusterMap().remove(session.getId());
}

Output:
     session.destroy();
-    getClusterMap().remove(session.getId());
+    final long maxInactive = session.originalSession.getMaxInactiveInterval() * 1000;
+    final long clusterLastAccess = session.timestamp.get();
+    final long now = System.currentTimeMillis();
+    if ((now - clusterLastAccess) >= maxInactive) {
+        log("String_Node_Str" + session.getId() + "String_Node_Str" + maxInactive + "String_Node_Str" + session.originalSession.getLastAccessedTime() + "String_Node_Str" + clusterLastAccess + "String_Node_Str" + now);
+        getClusterMap().remove(session.getId());
+        session.timestamp.destroy();
+    }
 }


Input:
public static synchronized IndexInfo getIndexInfo(File file) throws IndexerException {
    File canonicalFile;
    try {
        canonicalFile = file.getCanonicalFile();
        IndexInfo indexInfo = indexInfos.get(canonicalFile);
        if (indexInfo == null) {
            indexInfo = new IndexInfo(canonicalFile);
            indexInfos.put(canonicalFile, indexInfo);
        }
        s_logger.error("String_Node_Str" + indexInfo + "String_Node_Str" + file.getAbsolutePath());
        return indexInfo;
    } catch (IOException e) {
        throw new IndexerException("String_Node_Str", e);
    }
}

Output:
         }
-        s_logger.error("String_Node_Str" + indexInfo + "String_Node_Str" + file.getAbsolutePath());
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("String_Node_Str" + indexInfo + "String_Node_Str" + file.getAbsolutePath());
+        }
         return indexInfo;


Input:
private void handleDiggerRequest() {
    DiggerRequest request = diggerRequests.peek();
    if (request != null && request.requester.isDiggerRequestActive()) {
        IManageableDigger digger = joblessDiggers.removeObjectNextTo(request.getPos());
        if (digger != null) {
            digger.setDiggerJob(request.requester);
            request.amount--;
            if (request.creationRequested > 0) {
                request.creationRequested--;
            }
        } else {
            if (request.amount > request.creationRequested) {
                if (createNewToolUserIfLimitNotExceeded(EMovableType.DIGGER, request.getPos())) {
                    request.creationRequested++;
                }
            }
        }
        if (request.amount <= 0) {
            diggerRequests.poll();
        }
    }
}

Output:
     DiggerRequest request = diggerRequests.peek();
-    if (request != null && request.requester.isDiggerRequestActive()) {
+    if (request == null) {
+        return;
+    }
+    if (request.requester.isDiggerRequestActive()) {
         IManageableDigger digger = joblessDiggers.removeObjectNextTo(request.getPos());


Input:
static public String getUriWithDocId(RequestContext context, String dbName, String collName, Object id) throws UnsupportedDocumentIdException {
    DOC_ID_TYPE docIdType = URLUtils.checkId(id);
    StringBuilder sb = new StringBuilder();
    sb.append("String_Node_Str").append(dbName).append("String_Node_Str").append(collName).append("String_Node_Str").append(id);
    if (docIdType == DOC_ID_TYPE.STRING_OID && ObjectId.isValid((String) id)) {
        sb.append("String_Node_Str");
    } else if (docIdType != DOC_ID_TYPE.STRING_OID) {
        sb.append("String_Node_Str").append(docIdType.name());
    }
    return context.mapUri(sb.toString().replaceAll("String_Node_Str", "String_Node_Str"));
}

Output:
     }
-    return context.mapUri(sb.toString().replaceAll("String_Node_Str", "String_Node_Str"));
+    return context.mapUri(sb.toString());
 }


Input:
public List<Catalog> fillCatalogs(Connection dbConn, DatabaseMetaData dbJDBCMetadata, IMetadataConnection metaConnection, List<String> catalogFilter) {
    List<Catalog> catalogList = new ArrayList<Catalog>();
    if (dbJDBCMetadata == null) {
        return null;
    }
    if (ConnectionUtils.isPostgresql(dbJDBCMetadata)) {
        return fillPostgresqlCatalogs(metaConnection, dbConn, dbJDBCMetadata, catalogList);
    }
    if (dbConn != null && dbConn.isContextMode()) {
        if (EDatabaseTypeName.MYSQL.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.MSSQL.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.MSSQL05_08.getProduct().equals(((DatabaseConnection) dbConn).getProductId())) {
            IMetadataConnection iMetadataCon = metaConnection;
            if (iMetadataCon == null) {
                iMetadataCon = ConvertionHelper.convert(dbConn);
            }
            if (iMetadataCon != null) {
                String catalogTemp = iMetadataCon.getDatabase();
                if ("String_Node_Str".equals(catalogTemp)) {
                    catalogFilter.clear();
                }
            }
        }
    }
    try {
        if (dbJDBCMetadata.getDatabaseProductName() != null && dbJDBCMetadata.getDatabaseProductName().indexOf(EDatabaseTypeName.ORACLEFORSID.getProduct()) > -1) {
            return catalogList;
        }
        if (ConnectionUtils.isOdbcTeradata(dbJDBCMetadata)) {
            return catalogList;
        }
        ResultSet catalogNames = null;
        if (dbJDBCMetadata instanceof SybaseDatabaseMetaData) {
            catalogNames = ((SybaseDatabaseMetaData) dbJDBCMetadata).getCatalogs(((DatabaseConnection) dbConn).getUsername());
        } else {
            catalogNames = dbJDBCMetadata.getCatalogs();
        }
        List<String> schemaFilterList = new ArrayList<String>();
        if (catalogNames != null) {
            boolean isHive = MetadataConnectionUtils.isHive(dbJDBCMetadata);
            boolean isSybase = MetadataConnectionUtils.isSybase(dbJDBCMetadata);
            while (catalogNames.next()) {
                String catalogName = null;
                try {
                    String temp = null;
                    if (isHive) {
                        temp = MetaDataConstants.TABLE_CAT.name();
                    } else {
                        temp = MetadataConnectionUtils.isOdbcPostgresql(dbJDBCMetadata) ? DatabaseConstant.ODBC_POSTGRESQL_CATALOG_NAME : MetaDataConstants.TABLE_CAT.name();
                    }
                    catalogName = catalogNames.getString(temp);
                    if (!isHive && !MetadataConnectionUtils.isODBCCatalog(catalogName, dbJDBCMetadata)) {
                        continue;
                    }
                } catch (Exception e) {
                    log.warn(e, e);
                    if (dbJDBCMetadata.getDatabaseProductName() != null && dbJDBCMetadata.getDatabaseProductName().toLowerCase().indexOf(DatabaseConstant.POSTGRESQL_PRODUCT_NAME) > -1) {
                        catalogName = "String_Node_Str";
                    }
                }
                if (catalogName != null) {
                    if (!isNullSID(dbConn) && dbConn != null && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.AS400.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_IN_PROGRESS.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_SERVER.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_WEBSERVER.getDisplayName())) {
                        String databaseOnConnWizard = ((DatabaseConnection) dbConn).getSID();
                        postFillCatalog(catalogList, catalogFilter, schemaFilterList, TalendCWMService.getReadableName(dbConn, databaseOnConnWizard), dbConn);
                        break;
                    } else if (isCreateElement(catalogFilter, catalogName)) {
                        postFillCatalog(catalogList, catalogFilter, schemaFilterList, catalogName, dbConn);
                    }
                }
            }
            catalogNames.close();
            if (!isHive) {
                List<Catalog> removeCatalogList = new ArrayList<Catalog>();
                for (Catalog catalog : catalogList) {
                    List<Schema> schemaList = new ArrayList<Schema>();
                    try {
                        schemaList = fillSchemaToCatalog(dbConn, dbJDBCMetadata, catalog, schemaFilterList);
                        if (!schemaList.isEmpty() && schemaList.size() > 0) {
                            CatalogHelper.addSchemas(schemaList, catalog);
                        }
                    } catch (Throwable e) {
                        removeCatalogList.add(catalog);
                    }
                }
                if (isSybase && catalogFilter != null && !catalogFilter.isEmpty() && catalogFilter.size() > 0 && catalogList.isEmpty() && catalogList.size() == 0) {
                    catalogFilter.clear();
                    return fillCatalogs(dbConn, dbJDBCMetadata, catalogFilter);
                }
                catalogList.removeAll(removeCatalogList);
            }
            Set<MetadataTable> tableSet = ConnectionHelper.getTables(dbConn);
            List<Catalog> replaceCatalogs = new ArrayList<Catalog>();
            List<String> catalogName = new ArrayList<String>();
            for (MetadataTable table : tableSet) {
                EObject eContainer = table.eContainer();
                if (eContainer != null) {
                    if (eContainer instanceof Catalog) {
                        Catalog c = (Catalog) eContainer;
                        String name = c.getName();
                        if (!catalogName.contains(name)) {
                            replaceCatalogs.add(c);
                            catalogName.add(name);
                        }
                    } else if (eContainer instanceof Schema) {
                        EObject parent = eContainer.eContainer();
                        if (parent != null && parent instanceof Catalog) {
                            Catalog c = (Catalog) parent;
                            String name = c.getName();
                            if (!catalogName.contains(name)) {
                                List<Schema> filterSchemas = new ArrayList<Schema>();
                                List<String> schemaName = new ArrayList<String>();
                                List<Schema> schemas = CatalogHelper.getSchemas(c);
                                for (Schema schema : schemas) {
                                    if (schemaFilterList != null) {
                                        if (schemaFilterList.contains(schema.getName())) {
                                            filterSchemas.add(schema);
                                            schemaName.add(schema.getName());
                                        } else if (schema.getOwnedElement() != null && !schema.getOwnedElement().isEmpty()) {
                                            filterSchemas.add(schema);
                                            schemaName.add(schema.getName());
                                        }
                                    }
                                }
                                for (Catalog catalog : catalogList) {
                                    if (catalog.getName().equals(name)) {
                                        boolean added = false;
                                        for (Schema schema : CatalogHelper.getSchemas(catalog)) {
                                            if (!schemaName.contains(schema.getName())) {
                                                filterSchemas.add(schema);
                                                added = true;
                                            }
                                        }
                                        if (added) {
                                            break;
                                        }
                                    }
                                }
                                c.getOwnedElement().clear();
                                CatalogHelper.addSchemas(filterSchemas, c);
                                replaceCatalogs.add(c);
                                catalogName.add(name);
                            }
                        }
                    }
                }
            }
            if (this.isLinked() && !catalogList.isEmpty()) {
                ConnectionHelper.addCatalogs(catalogList, dbConn);
            }
            for (Catalog catalog : replaceCatalogs) {
                List<Catalog> list = new ArrayList<Catalog>();
                String name = catalog.getName();
                Catalog c = (Catalog) ConnectionHelper.getPackage(name, dbConn, Catalog.class);
                if (c != null) {
                    list.add(c);
                    ConnectionHelper.removeCatalogs(list, dbConn);
                    ConnectionHelper.addCatalog(catalog, dbConn);
                } else {
                    ConnectionHelper.addCatalog(catalog, dbConn);
                }
            }
        }
    } catch (SQLException e) {
        log.warn("String_Node_Str", e);
    }
    return catalogList;
}

Output:
     if (dbConn != null && dbConn.isContextMode()) {
-        if (EDatabaseTypeName.MYSQL.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.MSSQL.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.MSSQL05_08.getProduct().equals(((DatabaseConnection) dbConn).getProductId())) {
+        if (EDatabaseTypeName.MYSQL.getProduct().equals(dbConn.getProductId()) || EDatabaseTypeName.MSSQL.getProduct().equals(dbConn.getProductId()) || EDatabaseTypeName.MSSQL05_08.getProduct().equals(dbConn.getProductId())) {
             IMetadataConnection iMetadataCon = metaConnection;


Input:
public void setHorizontalGradient(boolean isHorizontalGradient) {
    this.isHorizontalGradient = isHorizontalGradient;
    setDisplayListDirty();
}

Output:
     this.isHorizontalGradient = isHorizontalGradient;
-    setDisplayListDirty();
+    setDisplayListDirty(true);
 }


Input:
public void recurseTerms(final TermVisitor v) {
    v.visit(this);
    if (this instanceof CompoundTerm) {
        for (Term t : ((CompoundTerm) this).term) {
            t.recurseTerms(v);
        }
    }
}

Output:
         for (Term t : ((CompoundTerm) this).term) {
-            t.recurseTerms(v);
+            t.recurseTerms(v, this);
         }


Input:
public void onDamage(EntityDamageEvent event) {
    if (event.getEntity() != npc.getBukkitEntity() || dying)
        return;
    if (this.getHealth() - event.getDamage() > 0)
        return;
    dying = true;
    player = null;
    entityId = npc.getBukkitEntity().getEntityId();
    String deathCause = event.getCause().toString().toLowerCase().replace('_', ' ');
    Map<String, dObject> context = new HashMap<String, dObject>();
    context.put("String_Node_Str", new Element(event.getDamage()));
    context.put("String_Node_Str", new Element(deathCause));
    if (event instanceof EntityDamageByEntityEvent) {
        Entity killerEntity = ((EntityDamageByEntityEvent) event).getDamager();
        context.put("String_Node_Str", new dEntity(killerEntity));
        if (killerEntity instanceof Player)
            player = dPlayer.mirrorBukkitPlayer((Player) killerEntity);
        else if (killerEntity instanceof Projectile) {
            ProjectileSource shooter = ((Projectile) killerEntity).getShooter();
            if (shooter != null && shooter instanceof LivingEntity) {
                context.put("String_Node_Str", new dEntity((LivingEntity) shooter));
                if (shooter instanceof Player)
                    player = dPlayer.mirrorBukkitPlayer((Player) shooter);
                DenizenAPI.getDenizenNPC(npc).action("String_Node_Str" + ((LivingEntity) shooter).getType().toString(), player, context);
            }
        }
        DenizenAPI.getDenizenNPC(npc).action("String_Node_Str", player, context);
        DenizenAPI.getDenizenNPC(npc).action("String_Node_Str" + killerEntity.getType().toString(), player, context);
    } else if (event instanceof EntityDamageByBlockEvent) {
        DenizenAPI.getDenizenNPC(npc).action("String_Node_Str", player, context);
    }
    DenizenAPI.getDenizenNPC(npc).action("String_Node_Str", player, context);
    DenizenAPI.getDenizenNPC(npc).action("String_Node_Str" + deathCause, player, context);
    if (npc.getBukkitEntity() == null)
        return;
    loc = dLocation.valueOf(TagManager.tag(null, DenizenAPI.getDenizenNPC(npc), respawnLocation, false));
    if (loc == null)
        loc = npc.getBukkitEntity().getLocation();
    if (animatedeath) {
        npc.getNavigator().cancelNavigation();
    }
    die();
    if (respawn) {
        Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(DenizenAPI.getCurrentInstance(), new Runnable() {
            public void run() {
                if (CitizensAPI.getNPCRegistry().getById(npc.getId()) == null || npc.isSpawned())
                    return;
                else
                    npc.spawn(loc);
            }
        }, (Duration.valueOf(respawnDelay).getTicks()));
    }
}

Output:
     die();
-    if (respawn) {
+    if (respawn && (Duration.valueOf(respawnDelay).getTicks() > 0)) {
         Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(DenizenAPI.getCurrentInstance(), new Runnable() {


Input:
public void shouldFindLCAWhenIsAFatherOfBothNodes() {
    BinaryNode<Integer> root = new BinaryNode<Integer>(1);
    BinaryNode<Integer> n2 = new BinaryNode<Integer>(2);
    BinaryNode<Integer> n3 = new BinaryNode<Integer>(3);
    BinaryNode<Integer> n4 = new BinaryNode<Integer>(4);
    BinaryNode<Integer> n5 = new BinaryNode<Integer>(5);
    BinaryNode<Integer> n6 = new BinaryNode<Integer>(6);
    root.setLeft(n2);
    root.setRight(n3);
    n2.setLeft(n4);
    n2.setRight(n5);
    n4.setLeft(n6);
    BinaryNode<Integer> result = lca.get(root, n5, n6);
    assertEquals(n4, result);
}

Output:
     n4.setLeft(n6);
-    BinaryNode<Integer> result = lca.get(root, n5, n6);
-    assertEquals(n4, result);
+    BinaryNode result = lca.getRecursive(root, n5, n6);
+    assertEquals(n2, result);
 }


Input:
public Class<? extends Value>[] getPactSchema() {
    Class<? extends Value>[] schema = new Class[this.mapping.size()];
    for (int i = 0; i < this.mapping.size(); i++) {
        schema[i] = JsonNodeWrapper.class;
    }
    return schema;
}

Output:
 public Class<? extends Value>[] getPactSchema() {
-    Class<? extends Value>[] schema = new Class[this.mapping.size()];
-    for (int i = 0; i < this.mapping.size(); i++) {
+    Class<? extends Value>[] schema = new Class[this.mapping.size() + 1];
+    for (int i = 0; i <= this.mapping.size(); i++) {
         schema[i] = JsonNodeWrapper.class;


Input:
public KnowledgeObject<T> setParent(KnowledgeObject<?> obj, int offX, int offY) {
    this.x = obj.x + offX;
    this.y = obj.y + offY;
    this.parent = obj;
    this.parent.children.add(this);
    return this;
}

Output:
 public KnowledgeObject<T> setParent(KnowledgeObject<?> obj, int offX, int offY) {
-    this.x = obj.x + offX;
-    this.y = obj.y + offY;
+    this.x = obj.x + offX * 12;
+    this.y = obj.y + offY * 12;
     this.parent = obj;


Input:
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    switch(requestCode) {
        case EDIT_GARDEN:
            setTitle(garden.getName());
            break;
        case USE_CAMERA:
            if (resultCode == RESULT_OK) {
                System.out.print("String_Node_Str" + imageUri.toString() + "String_Node_Str");
                android.database.Cursor cursor = managedQuery(imageUri, new String[] { MediaStore.Images.Media.DATA }, null, null, null);
                int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
                cursor.moveToFirst();
                System.out.println(cursor.getString(column_index));
                if (data != null && data.getData() != null)
                    imageUri = data.getData();
                System.out.print("String_Node_Str" + imageUri.toString() + "String_Node_Str");
                cursor = managedQuery(imageUri, new String[] { MediaStore.Images.Media.DATA }, null, null, null);
                column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
                cursor.moveToFirst();
                System.out.println(cursor.getString(column_index));
                GardenGnome.addPhoto(garden, new Photo(imageUri));
            }
            break;
        case ADD_PLOT:
            if (data != null) {
                data.putExtra("String_Node_Str", gardenId);
                data.putExtra("String_Node_Str", gardenView.zoomScale);
                float[] values = new float[9], bgvalues = new float[9];
                gardenView.dragMatrix.getValues(values);
                gardenView.bgDragMatrix.getValues(bgvalues);
                data.putExtra("String_Node_Str", values);
                data.putExtra("String_Node_Str", bgvalues);
                startActivityForResult(data, 0);
                overridePendingTransition(0, 0);
            }
            break;
        case EDIT_PLOT:
            gardenView.zoomScale = data.getFloatExtra("String_Node_Str", 1);
            gardenView.dragMatrix.setValues(data.getFloatArrayExtra("String_Node_Str"));
            gardenView.bgDragMatrix.setValues(data.getFloatArrayExtra("String_Node_Str"));
            gardenView.onAnimationEnd();
            if (zoomAutoHidden)
                zoomControls.setVisibility(View.GONE);
            break;
        case VIEW_PLOT:
            if (zoomAutoHidden)
                zoomControls.hide();
            break;
    }
}

Output:
                 data.putExtra("String_Node_Str", bgvalues);
-                startActivityForResult(data, 0);
+                startActivityForResult(data, EDIT_PLOT);
                 overridePendingTransition(0, 0);


Input:
public void stop() {
    destroyBgHandler();
    destroyDriverThread();
    mTaskQueue.clear();
    if (mGoogleApiClient.isConnected() || mGoogleApiClient.isConnecting()) {
        mGoogleApiClient.disconnect();
    }
}

Output:
 public void stop() {
-    destroyBgHandler();
-    destroyDriverThread();
-    mTaskQueue.clear();
-    if (mGoogleApiClient.isConnected() || mGoogleApiClient.isConnecting()) {
-        mGoogleApiClient.disconnect();
+    if (isGooglePlayServicesValid()) {
+        destroyBgHandler();
+        destroyDriverThread();
+        mTaskQueue.clear();
+        if (mGoogleApiClient.isConnected() || mGoogleApiClient.isConnecting()) {
+            mGoogleApiClient.disconnect();
+        }
+    } else {
+        Log.e(TAG, "String_Node_Str");
     }


Input:
public void run() {
    if (logger.isTraceEnabled()) {
        logger.trace(fromID + "String_Node_Str");
    }
    ContactJabberImpl srcContact = ssContactList.findContactById(fromID);
    if (srcContact == null)
        srcContact = createVolatileContact(fromID);
    AuthorizationRequest req = new AuthorizationRequest();
    AuthorizationResponse response = handler.processAuthorisationRequest(req, srcContact);
    Presence.Type responsePresenceType = null;
    if (response != null) {
        if (response.getResponseCode().equals(AuthorizationResponse.ACCEPT)) {
            responsePresenceType = Presence.Type.subscribed;
            if (logger.isInfoEnabled())
                logger.info("String_Node_Str");
        } else if (response.getResponseCode().equals(AuthorizationResponse.REJECT)) {
            responsePresenceType = Presence.Type.unsubscribed;
            if (logger.isInfoEnabled())
                logger.info("String_Node_Str");
        }
    }
    if (responsePresenceType == null)
        return;
    Presence responsePacket = new Presence(responsePresenceType);
    responsePacket.setTo(fromID);
    parentProvider.getConnection().sendPacket(responsePacket);
}

Output:
 public void run() {
-    if (logger.isTraceEnabled()) {
-        logger.trace(fromID + "String_Node_Str");
-    }
-    ContactJabberImpl srcContact = ssContactList.findContactById(fromID);
-    if (srcContact == null)
-        srcContact = createVolatileContact(fromID);
-    AuthorizationRequest req = new AuthorizationRequest();
-    AuthorizationResponse response = handler.processAuthorisationRequest(req, srcContact);
-    Presence.Type responsePresenceType = null;
-    if (response != null) {
-        if (response.getResponseCode().equals(AuthorizationResponse.ACCEPT)) {
-            responsePresenceType = Presence.Type.subscribed;
-            if (logger.isInfoEnabled())
-                logger.info("String_Node_Str");
-        } else if (response.getResponseCode().equals(AuthorizationResponse.REJECT)) {
-            responsePresenceType = Presence.Type.unsubscribed;
-            if (logger.isInfoEnabled())
-                logger.info("String_Node_Str");
-        }
-    }
-    if (responsePresenceType == null)
-        return;
-    Presence responsePacket = new Presence(responsePresenceType);
-    responsePacket.setTo(fromID);
-    parentProvider.getConnection().sendPacket(responsePacket);
+    ssContactList.init();
+    contactChangesListener = new ContactChangesListener();
+    Roster roster = parentProvider.getConnection().getRoster();
+    roster.addRosterListener(contactChangesListener);
+    parentProvider.startJingleNodesDiscovery();
+    parentProvider.getConnection().removePacketListener(this);
 }


Input:
public boolean isType(IType type) {
    if (type == Type.NONE || type == Type.VOID) {
        return true;
    }
    if (this.method == null) {
        return false;
    }
    if (this.type == null) {
        this.type = this.typeArguments != null ? this.method.getType(this.typeArguments) : this.method.getType();
    }
    return Type.isSuperType(type, this.type);
}

Output:
     }
-    if (this.type == null) {
-        this.type = this.typeArguments != null ? this.method.getType(this.typeArguments) : this.method.getType();
-    }
-    return Type.isSuperType(type, this.type);
+    return Type.isSuperType(type, this.getType());
 }


Input:
public synchronized AlarmTableEntry removeOldest() throws AlarmContainerException {
    if (index.size() == 0) {
        throw new AlarmContainerException("String_Node_Str");
    }
    String ID = index.remove(index.size() - 1);
    if (ID == null) {
        throw new IllegalStateException("String_Node_Str");
    }
    AlarmTableEntry ret = entries.remove(ID);
    if (ret == null) {
        throw new IllegalStateException("String_Node_Str");
    }
    indexWithReduction.remove(ID);
    return ret;
}

Output:
     }
-    String ID = index.remove(index.size() - 1);
+    String ID = index.remove(0);
     if (ID == null) {


Input:
public Player getNextAlivePlayerFrom(Player oldPlayer) {
    if (oldPlayer == null)
        return getRandomAlivePlayer();
    boolean found = false;
    for (int i = 0; i < this.players.length; i++) {
        Player player = this.players[i];
        if (player == null) {
            continue;
        }
        if (oldPlayer.getId() == player.getId()) {
            found = true;
        } else if (found) {
            if (player.isAlive()) {
                return player;
            }
        }
    }
    if (!found) {
        return getRandomAlivePlayer();
    }
    return null;
}

Output:
         return getRandomAlivePlayer();
-    boolean found = false;
+    int nextPlayerIndex = (oldPlayer.getId() + 1) % players.length;
     for (int i = 0; i < this.players.length; i++) {


Input:
public void project(List<String> columnNames) {
    this.names.retainAll(columnNames);
    this.nameToExpr.keySet().retainAll(columnNames);
}

Output:
 public void project(List<String> columnNames) {
-    this.names.retainAll(columnNames);
+    this.names = columnNames;
     this.nameToExpr.keySet().retainAll(columnNames);


Input:
public void setup() throws IOException {
    map1 = newSocketShmIntString((byte) 1, 8076, new ClientPort(8077, "String_Node_Str"), new ClientPort(8078, "String_Node_Str"), new ClientPort(8079, "String_Node_Str"));
    map2 = newSocketShmIntString((byte) 2, 8077, new ClientPort(8078, "String_Node_Str"), new ClientPort(8079, "String_Node_Str"));
    map3 = newSocketShmIntString((byte) 3, 8078, new ClientPort(8079, "String_Node_Str"));
    map4 = newSocketShmIntString((byte) 4, 8079);
}

Output:
     map2 = newSocketShmIntString((byte) 2, 8077, new ClientPort(8078, "String_Node_Str"), new ClientPort(8079, "String_Node_Str"));
-    map3 = newSocketShmIntString((byte) 3, 8078, new ClientPort(8079, "String_Node_Str"));
-    map4 = newSocketShmIntString((byte) 4, 8079);
+    map3 = newSocketShmIntString((byte) 3, 8078, new ClientPort(8079, "String_Node_Str"), new ClientPort(8077, "String_Node_Str"));
+    map4 = newSocketShmIntString((byte) 4, 8079, new ClientPort(8078, "String_Node_Str"), new ClientPort(8077, "String_Node_Str"));
 }


Input:
public void actionMenuFileImportHierarchy() {
    if (model == null) {
        main.showInfoDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
        return;
    } else if (model.getInputConfig().getInput() == null) {
        main.showInfoDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
        return;
    }
    final String path = actionShowOpenFileDialog("String_Node_Str");
    if (path != null) {
        DialogSeparator dialog = null;
        try {
            dialog = new DialogSeparator(main.getShell(), this, path, false);
            dialog.create();
            if (dialog.open() == Window.CANCEL) {
                return;
            }
        } catch (Throwable error) {
            if (error instanceof RuntimeException) {
                if (error.getCause() != null) {
                    error = error.getCause();
                }
            }
            if ((error instanceof IllegalArgumentException) || (error instanceof IOException)) {
                main.showInfoDialog("String_Node_Str", error.getMessage());
            } else {
                main.showErrorDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"), error);
            }
            return;
        }
        final char separator = dialog.getSeparator();
        final Hierarchy hierarchy = actionImportHierarchy(path, separator);
        if (hierarchy != null) {
            model.getInputConfig().setHierarchy(model.getSelectedAttribute(), hierarchy);
            update(new ModelEvent(this, ModelPart.HIERARCHY, hierarchy));
        }
    }
}

Output:
         if (hierarchy != null) {
-            model.getInputConfig().setHierarchy(model.getSelectedAttribute(), hierarchy);
+            String attr = model.getSelectedAttribute();
+            model.getInputConfig().setMaximumGeneralization(attr, null);
+            model.getInputConfig().setMinimumGeneralization(attr, null);
+            model.getInputConfig().setHierarchy(attr, hierarchy);
             update(new ModelEvent(this, ModelPart.HIERARCHY, hierarchy));


Input:
private String getTableNameFromColumn(TdColumn column) {
    ColumnSet columnSetOwner = ColumnHelper.getColumnSetOwner(column);
    if (columnSetOwner == null) {
        log.error("String_Node_Str" + column.getName() + "String_Node_Str");
    } else {
        Package pack = ColumnSetHelper.getParentCatalogOrSchema(columnSetOwner);
        if (SwitchHelpers.SCHEMA_SWITCH.doSwitch(pack) != null) {
            schemaName = pack.getName();
            Package catalog = ColumnSetHelper.getParentCatalogOrSchema(pack);
            if (catalog != null && SwitchHelpers.CATALOG_SWITCH.doSwitch(catalog) != null) {
                catalogName = catalog.getName();
            }
        }
        if (SwitchHelpers.CATALOG_SWITCH.doSwitch(pack) != null) {
            catalogName = pack.getName();
        }
        if (dbms().getDbmsName().equals(SupportDBUrlType.SYBASEDEFAULTURL.getLanguage())) {
            schemaName = ColumnSetHelper.getTableOwner(columnSetOwner);
        }
        return dbms().toQualifiedName(catalogName, schemaName, columnSetOwner.getName());
    }
    return null;
}

Output:
         }
-        if (dbms().getDbmsName().equals(SupportDBUrlType.SYBASEDEFAULTURL.getLanguage())) {
+        if (ConnectionUtils.isSybaseeDBProducts(dbms().getDbmsName())) {
             schemaName = ColumnSetHelper.getTableOwner(columnSetOwner);


Input:
public Flux<ResolvedTarget> resolveSingleTarget(Target configTarget) {
    if (configTarget.getApplicationName() != null) {
        ResolvedTarget rt = new ResolvedTarget(configTarget);
        return Flux.just(rt);
    }
    Mono<String> orgIdMono = this.cfAccessor.retrieveOrgId(configTarget.getOrgName()).map(r -> r.getResources()).map(l -> l.get(0)).map(e -> e.getMetadata()).map(entry -> entry.getId());
    Mono<String> spaceIdMono = orgIdMono.flatMap(orgId -> {
        return this.cfAccessor.retrieveSpaceId(orgId, configTarget.getSpaceName());
    }).map(r -> r.getResources()).map(l -> l.get(0)).map(e -> e.getMetadata()).map(entry -> entry.getId());
    Mono<ListApplicationsResponse> responseMono = Mono.zip(orgIdMono, spaceIdMono).flatMap(tuple -> this.cfAccessor.retrieveAllApplicationIdsInSpace(tuple.getT1(), tuple.getT2()));
    Flux<String> applicationsInSpace = responseMono.map(r -> r.getResources()).flatMapMany(resources -> {
        List<String> appNames = new LinkedList<>();
        for (ApplicationResource ar : resources) {
            if (!isApplicationInScrapableState(ar.getEntity().getState())) {
                continue;
            }
            appNames.add(ar.getEntity().getName());
        }
        return Flux.fromIterable(appNames);
    });
    Flux<String> filteredApplicationsInSpace = applicationsInSpace;
    if (configTarget.getApplicationRegex() != null) {
        final Pattern filterPattern = Pattern.compile(configTarget.getApplicationRegex());
        filteredApplicationsInSpace = applicationsInSpace.filter(appName -> {
            Matcher m = filterPattern.matcher(appName);
            return m.matches();
        });
    }
    Flux<ResolvedTarget> result = filteredApplicationsInSpace.map(appName -> {
        ResolvedTarget newTarget = new ResolvedTarget(configTarget);
        newTarget.setApplicationName(appName);
        return newTarget;
    });
    return result;
}

Output:
     }).map(r -> r.getResources()).map(l -> l.get(0)).map(e -> e.getMetadata()).map(entry -> entry.getId());
-    Mono<ListApplicationsResponse> responseMono = Mono.zip(orgIdMono, spaceIdMono).flatMap(tuple -> this.cfAccessor.retrieveAllApplicationIdsInSpace(tuple.getT1(), tuple.getT2()));
-    Flux<String> applicationsInSpace = responseMono.map(r -> r.getResources()).flatMapMany(resources -> {
-        List<String> appNames = new LinkedList<>();
-        for (ApplicationResource ar : resources) {
-            if (!isApplicationInScrapableState(ar.getEntity().getState())) {
-                continue;
-            }
-            appNames.add(ar.getEntity().getName());
-        }
-        return Flux.fromIterable(appNames);
-    });
-    Flux<String> filteredApplicationsInSpace = applicationsInSpace;
-    if (configTarget.getApplicationRegex() != null) {
-        final Pattern filterPattern = Pattern.compile(configTarget.getApplicationRegex());
-        filteredApplicationsInSpace = applicationsInSpace.filter(appName -> {
-            Matcher m = filterPattern.matcher(appName);
-            return m.matches();
-        });
-    }
-    Flux<ResolvedTarget> result = filteredApplicationsInSpace.map(appName -> {
+    Flux<String> applicationNamesFlux = selectApplications(configTarget, orgIdMono, spaceIdMono);
+    Flux<ResolvedTarget> result = applicationNamesFlux.map(appName -> {
         ResolvedTarget newTarget = new ResolvedTarget(configTarget);


Input:
public void activateSubViewport(int row, int column, boolean centerCamera) {
    validateCoordinates(row, column);
    Array<SubView> rowMap = subViews.get(row);
    Viewport viewport = rowMap.get(column).viewport;
    calculateSubViewportArea(row, column, subViewportArea);
    viewport.update((int) subViewportArea.width, (int) subViewportArea.height, centerCamera);
    float originalWorldWidth = viewport.getWorldWidth();
    float originalWorldHeight = viewport.getWorldHeight();
    if (viewport.getScreenWidth() > subViewportArea.width) {
        float offcutWidth = viewport.getScreenWidth() - subViewportArea.width;
        viewport.setScreenWidth((int) subViewportArea.width);
        viewport.setWorldWidth(viewport.getWorldWidth() - offcutWidth);
        viewport.setScreenX((int) (viewport.getScreenX() + offcutWidth / 2));
    }
    if (viewport.getScreenHeight() > subViewportArea.height) {
        float offcutHeight = viewport.getScreenHeight() - subViewportArea.height;
        viewport.setScreenHeight((int) subViewportArea.height);
        viewport.setWorldHeight(viewport.getWorldHeight() - offcutHeight);
        viewport.setScreenY((int) (viewport.getScreenY() + offcutHeight / 2));
    }
    viewport.setScreenX((int) (viewport.getScreenX() + subViewportArea.x));
    viewport.setScreenY((int) (viewport.getScreenX() + subViewportArea.y));
    viewport.apply();
    viewport.setWorldWidth(originalWorldWidth);
    viewport.setWorldHeight(originalWorldHeight);
    activeViewport = viewport;
}

Output:
     viewport.setScreenX((int) (viewport.getScreenX() + subViewportArea.x));
-    viewport.setScreenY((int) (viewport.getScreenX() + subViewportArea.y));
+    viewport.setScreenY((int) (viewport.getScreenY() + subViewportArea.y));
     viewport.apply();


Input:
public void load(Object entity, boolean useCache, EnumDBMasterSlave masterSlave) {
    if (entity == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    EntityPK entityPk = entityMetaManager.getEntityPK(entity);
    List<?> resultList = null;
    Class<?> clazz = entity.getClass();
    if (entityMetaManager.isShardingEntity(clazz)) {
        resultList = this.shardingQuery.findByPkList(Lists.newArrayList(entityPk), clazz, useCache, masterSlave);
    } else {
        resultList = this.globalQuery.findByPkList(Lists.newArrayList(entityPk), clazz, useCache, masterSlave);
    }
    if (resultList.isEmpty()) {
        throw new DBOperationException("String_Node_Str" + entityPk);
    }
    if (resultList.size() > 1) {
        throw new DBOperationException("String_Node_Str");
    }
    try {
        BeansUtil.copyProperties(resultList.get(0), entity);
    } catch (Exception e) {
        throw new DBOperationException(e);
    }
}

Output:
     EntityPK entityPk = entityMetaManager.getEntityPK(entity);
-    List<?> resultList = null;
+    Object loadEntity = null;
     Class<?> clazz = entity.getClass();


Input:
private URI assembleEAR(String name, Map<String, File> archives, Map<String, File> metadatas) throws IOException {
    File ear = new File(System.getProperty("String_Node_Str"), name + "String_Node_Str");
    ear.deleteOnExit();
    JarOutputStream jos = new JarOutputStream(new FileOutputStream(ear));
    for (String key : metadatas.keySet()) {
        tranferFile(metadatas.get(key), jos, key, false);
    }
    for (String archiveName : archives.keySet()) {
        File archive = archives.get(archiveName);
        if (archive.isDirectory()) {
            archive = new File(assembleJAR(archiveName, archive, Collections.EMPTY_LIST, Collections.EMPTY_MAP));
        }
        tranferFile(archive, jos, archiveName, false);
    }
    jos.close();
    return ear.toURI();
}

Output:
     JarOutputStream jos = new JarOutputStream(new FileOutputStream(ear));
-    for (String key : metadatas.keySet()) {
-        tranferFile(metadatas.get(key), jos, key, false);
+    for (Map.Entry<String, File> me : metadatas.entrySet()) {
+        tranferFile(me.getValue(), jos, me.getKey(), false);
     }


Input:
public boolean isConnected(ForgeDirection dir, PneumaticTube otherTube) {
    if (otherTube != null) {
        if (!(this instanceof Accelerator) && this instanceof MagTube != otherTube instanceof MagTube && !(otherTube instanceof Accelerator))
            return false;
        TubeColor otherTubeColor = otherTube.getColor(dir.getOpposite());
        if (otherTubeColor != TubeColor.NONE && getColor(dir) != TubeColor.NONE && getColor(dir) != otherTubeColor)
            return false;
    }
    return getWorld() == null || OcclusionHelper.microblockOcclusionTest(getParent(), MicroblockShape.FACE_HOLLOW, 8, dir);
}

Output:
     }
-    return getWorld() == null || OcclusionHelper.microblockOcclusionTest(getParent(), MicroblockShape.FACE_HOLLOW, 8, dir);
+    return getWorld() == null || OcclusionHelper.microblockOcclusionTest(getParent(), true, MicroblockShape.FACE_HOLLOW, 8, dir);
 }


Input:
public Iterable<Pair<Integer, Collection<Integer>>> getConnectedClients() {
    Collection<Integer> clients = null;
    synchronized (channelsPerClient) {
        clients = new ArrayList<Integer>(channelsPerClient.keySet());
    }
    Map<Integer, Collection<Integer>> txs = ((MasterImpl) realMaster).getOngoingTransactions();
    Collection<Pair<Integer, Collection<Integer>>> result = new ArrayList<Pair<Integer, Collection<Integer>>>();
    for (Integer id : clients) {
        result.add(new Pair<Integer, Collection<Integer>>(id, txs.get(id)));
    }
    return result;
}

Output:
     for (Integer id : clients) {
-        result.add(new Pair<Integer, Collection<Integer>>(id, txs.get(id)));
+        Collection<Integer> ongoingTxs = txs.get(id);
+        result.add(new Pair<Integer, Collection<Integer>>(id, ongoingTxs != null ? ongoingTxs : Collections.<Integer>emptyList()));
     }


Input:
public boolean removeItem(String name, Object key, Object value) {
    ThreadContext threadContext = ThreadContext.get();
    TransactionImpl txn = threadContext.getCallContext().getTransaction();
    if (txn != null && txn.getStatus() == Transaction.TXN_STATUS_ACTIVE) {
        try {
            boolean locked;
            if (!txn.has(name, key)) {
                MLock mlock = new MLock();
                locked = mlock.lockAndGetValue(name, key, DEFAULT_TXN_TIMEOUT);
                if (!locked)
                    throwCME(key);
                Object oldObject = null;
                Data oldValue = mlock.oldValue;
                if (oldValue != null) {
                    oldObject = threadContext.toObject(oldValue);
                }
                txn.attachRemoveOp(name, key, null, (oldObject == null));
                return (oldObject != null);
            } else {
                return (txn.attachRemoveOp(name, key, null, false) != null);
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return false;
    } else {
        boolean removed = booleanCall(CONCURRENT_MAP_REMOVE_ITEM, name, key, value, 0, -1);
        if (removed) {
            backup(CONCURRENT_MAP_BACKUP_REMOVE);
        }
        return removed;
    }
}

Output:
                 if (oldValue != null) {
-                    oldObject = threadContext.toObject(oldValue);
+                    oldObject = threadContext.isClient() ? oldValue : threadContext.toObject(oldValue);
                 }


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    MageObject sourceObject = source.getSourceObject(game);
    if (controller != null && sourceObject != null) {
        Map<UUID, Cards> cardsToDiscard = new HashMap<>();
        Map<UUID, Cards> cardsToReveal = new HashMap<>();
        for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
            Player player = game.getPlayer(playerId);
            if (player != null) {
                Cards cards = new CardsImpl();
                Target target = new TargetDiscard(0, 1, new FilterCard(), playerId);
                player.chooseTarget(outcome, target, source, game);
                cards.addAll(target.getTargets());
                cardsToDiscard.put(playerId, cards);
            }
        }
        for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
            Player player = game.getPlayer(playerId);
            if (player != null) {
                Cards cardsPlayer = cardsToDiscard.get(playerId);
                if (cardsPlayer != null) {
                    for (UUID cardId : cardsPlayer) {
                        Card card = game.getCard(cardId);
                        if (card != null) {
                            player.discard(card, source, game);
                        }
                    }
                }
            }
        }
        for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
            Player player = game.getPlayer(playerId);
            if (player != null) {
                Cards cardsPlayer = cardsToDiscard.get(playerId);
                if (cardsPlayer != null && !cardsPlayer.isEmpty()) {
                    TargetCardInLibrary target = new TargetCardInLibrary(0, 1, StaticFilters.FILTER_BASIC_LAND_CARD);
                    if (player.searchLibrary(target, game)) {
                        if (!target.getTargets().isEmpty()) {
                            Cards cards = new CardsImpl(target.getTargets());
                            cards.addAll(target.getTargets());
                            cardsToReveal.put(playerId, cards);
                        }
                    }
                }
            }
        }
        for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
            Player player = game.getPlayer(playerId);
            if (player != null) {
                Cards cardsPlayer = cardsToReveal.get(playerId);
                if (cardsPlayer != null) {
                    for (UUID cardId : cardsPlayer) {
                        Cards cards = new CardsImpl(game.getCard(cardId));
                        Card card = game.getCard(cardId);
                        player.revealCards(sourceObject.getIdName() + "String_Node_Str" + player.getName() + ')', cards, game);
                        player.moveCards(card, Zone.HAND, source, game);
                        player.shuffleLibrary(source, game);
                    }
                }
            }
        }
        return true;
    }
    return false;
}

Output:
                 if (cardsPlayer != null && !cardsPlayer.isEmpty()) {
-                    TargetCardInLibrary target = new TargetCardInLibrary(0, 1, StaticFilters.FILTER_BASIC_LAND_CARD);
+                    TargetCardInLibrary target = new TargetCardInLibrary(0, 1, StaticFilters.FILTER_CARD_BASIC_LAND);
                     if (player.searchLibrary(target, game)) {


Input:
public void testGetProblem() {
    ProblemDAO dao = (ProblemDAO) PersistenceContext.getInstance().getBean("String_Node_Str");
    Problem expProblem = new Problem();
    expProblem.setId(3);
    expProblem.setTitle("String_Node_Str");
    expProblem.setContact("String_Node_Str");
    expProblem.setDoc("String_Node_Str");
    List<String> procedures = new ArrayList<String>(3);
    procedures.add("String_Node_Str");
    procedures.add("String_Node_Str");
    procedures.add("String_Node_Str");
    expProblem.setProcedures(procedures);
    Problem actualProblem = dao.getProblem(3L);
    assertEquals(expProblem, actualProblem);
}

Output:
     Problem expProblem = new Problem();
-    expProblem.setId(3);
+    expProblem.setId(2);
     expProblem.setTitle("String_Node_Str");


Input:
public void drawSeries(Canvas canvas, GraphViewDataInterface[] values, float graphwidth, float graphheight, float border, double minX, double minY, double diffX, double diffY, float horstart, GraphViewSeriesStyle style) {
    float colwidth = graphwidth / values.length;
    paint.setStrokeWidth(style.thickness);
    paint.setColor(style.color);
    List<BarChartRect> barChartRects = new LinkedList<BarChartRect>();
    for (int i = 0; i < values.length; i++) {
        float valY = (float) (values[i].getY() - minY);
        float ratY = (float) (valY / diffY);
        float y = graphheight * ratY;
        if (style.getValueDependentColor() != null) {
            paint.setColor(style.getValueDependentColor().get(values[i]));
        }
        float pad = style.padding;
        float left = (i * colwidth) + horstart;
        float top = (border - y) + graphheight;
        float right = left + colwidth;
        float bottom = graphheight + border - 1;
        if ((top - bottom) == 1) {
            if (mBarPositionToHighlight == i) {
                paint.setColor(getResources().getColor(R.color.stats_views_hover_color));
                paint.setAlpha(75);
                canvas.drawRect(left + pad, 10f, right - pad, bottom, paint);
            } else {
                paint.setColor(style.color);
                paint.setAlpha(25);
                Shader shader = new LinearGradient(left + pad, bottom - 50, left + pad, bottom, Color.WHITE, Color.BLACK, Shader.TileMode.CLAMP);
                paint.setShader(shader);
                canvas.drawRect(left + pad, bottom - 50, right - pad, bottom, paint);
                paint.setShader(null);
            }
        } else {
            if (mBarPositionToHighlight == i) {
                paint.setColor(getResources().getColor(R.color.stats_views_hover_color));
            } else {
                paint.setColor(style.color);
            }
            canvas.drawRect(left + pad, top, right - pad, bottom, paint);
        }
        barChartRects.add(new BarChartRect(left + pad, top, right - pad, bottom));
    }
    mSeriesRectsDrawedOnScreen.add(barChartRects);
}

Output:
     paint.setColor(style.color);
-    List<BarChartRect> barChartRects = new LinkedList<BarChartRect>();
+    List<BarChartRect> barChartRects = new LinkedList<>();
     for (int i = 0; i < values.length; i++) {


Input:
public Map<String, GridComponentColumn> getColumns() {
    return columns;
}

Output:
 public Map<String, GridComponentColumn> getColumns() {
-    return columns;
+    return Maps.filterEntries(columns, Predicates.compose(COLUMNS_VISIBLE_FOR_TENANT_PREDICATE, VALUE_FROM_MAP_ENTRY_FUNCTION));
 }


Input:
public List<Ingredient> transform(ModificationPoint modificationPoint, Ingredient ingredient) {
    ExecutionContext collectedValues = contextColector.collectValues(AstorMain.projectFacade, modificationPoint);
    CtType expectedType = null;
    if (modificationPoint.getCodeElement() instanceof CtExpression) {
        CtExpression exp = (CtExpression) modificationPoint.getCodeElement();
        expectedType = exp.getType().getTypeDeclaration();
    }
    List<CtElement> synthesizedElements = this.synthesizer.executeSynthesis(modificationPoint, modificationPoint.getCodeElement(), expectedType, modificationPoint.getContextOfModificationPoint(), collectedValues);
    List<Ingredient> ingredients = new ArrayList<>();
    for (CtElement ctElement : synthesizedElements) {
        ingredients.add(new Ingredient(ctElement));
    }
    return ingredients;
}

Output:
 public List<Ingredient> transform(ModificationPoint modificationPoint, Ingredient ingredient) {
-    ExecutionContext collectedValues = contextColector.collectValues(AstorMain.projectFacade, modificationPoint);
+    ExecutionContext collectedValues = getContext(modificationPoint);
     CtType expectedType = null;


Input:
public void testMd5SignatureVerification() throws Exception {
    test(mockerMD5);
}

Output:
 public void testMd5SignatureVerification() throws Exception {
-    test(mockerMD5);
+    runTest(mockerMD5);
 }


Input:
public boolean isAlive() {
    if (subClass == HeroSubClass.BERSERKER) {
        Berserk berserk = buff(Berserk.class);
        if (berserk != null && berserk.berserking()) {
            return true;
        }
    }
    return super.isAlive();
}

Output:
 public boolean isAlive() {
-    if (subClass == HeroSubClass.BERSERKER) {
-        Berserk berserk = buff(Berserk.class);
-        if (berserk != null && berserk.berserking()) {
-            return true;
-        }
+    if (subClass == HeroSubClass.BERSERKER && berserk != null && berserk.berserking()) {
+        return true;
     }


Input:
public static void stopService(Context context, Class<? extends ChildService> clazz) {
    synchronized (monitor) {
        if (sCreated) {
            Intent intent = new Intent(ACTION_REMOVE_SERVICE);
            intent.putExtra(EXTRA_SERVICE_CLASS, clazz);
            LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
        } else if (sServiceMap.containsKey(clazz)) {
            ChildService child = sServiceMap.remove(clazz);
            child.onDestroy();
        }
    }
}

Output:
             LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
-        } else if (sServiceMap.containsKey(clazz)) {
-            ChildService child = sServiceMap.remove(clazz);
-            child.onDestroy();
+        } else {
+            sServiceMap.remove(clazz);
         }


Input:
protected List getPostTasks() {
    List retValue = new ArrayList();
    retValue.addAll(super.getPostTasks());
    if (container instanceof TableItem || container instanceof TableGroup || container instanceof TableRow) {
        TableItem table = LayoutUtil.getTableContainer(container);
        if (table != null)
            retValue.add(new LayoutActivityTask(module, table));
    }
    NotificationEvent event = null;
    if (add && state != UNDONE_STATE || !add && state == UNDONE_STATE)
        event = new ContentEvent(container, content, slotID, ContentEvent.ADD);
    else
        event = new ContentEvent(container, content, slotID, ContentEvent.REMOVE);
    if (state == DONE_STATE)
        event.setSender(sender);
    retValue.add(new NotificationRecordTask(container, event));
    if (add && state != UNDONE_STATE || !add && state == UNDONE_STATE) {
        if (isSelector(content))
            retValue.add(new NotificationRecordTask(content, event, container.getRoot()));
        return retValue;
    }
    if (content instanceof Parameter || content instanceof ParameterGroup || content instanceof DataSet) {
        event = new ElementDeletedEvent(container, content);
        if (state == DONE_STATE)
            event.setSender(sender);
        retValue.add(new NotificationRecordTask(content, event, container.getRoot()));
    }
    return retValue;
}

Output:
     }
-    if (content instanceof Parameter || content instanceof ParameterGroup || content instanceof DataSet) {
+    if (content instanceof Parameter || content instanceof ParameterGroup || content instanceof DataSet || content instanceof StyleElement) {
         event = new ElementDeletedEvent(container, content);


Input:
public void testZSS441ThreeDimensionalReference() {
    Book workbook = Util.loadBook("String_Node_Str");
    Sheet sheet = workbook.getSheet("String_Node_Str");
    Range sumResult = Ranges.range(sheet, "String_Node_Str");
    assertEquals(11, sumResult.getCellData().getDoubleValue().intValue());
    sumResult = Ranges.range(sheet, "String_Node_Str");
    assertEquals(22, sumResult.getCellData().getDoubleValue().intValue());
    sumResult = Ranges.range(sheet, "String_Node_Str");
    assertEquals(33, sumResult.getCellData().getDoubleValue().intValue());
}

Output:
 public void testZSS441ThreeDimensionalReference() {
-    Book workbook = Util.loadBook("String_Node_Str");
+    Book workbook = Util.loadBook(this, "String_Node_Str");
     Sheet sheet = workbook.getSheet("String_Node_Str");


Input:
private Token getToken(InputStream inputStream) throws IOException {
    if (ch == '\0') {
        ch = nextCharacter(inputStream);
    }
    skipWhitespace(inputStream);
    if (isLabelCharacter(ch)) {
        sb.setLength(0);
        do {
            sb.append(ch);
            ch = nextCharacter(inputStream);
        } while (isLabelCharacter(ch));
        return new Token(ID_TOKEN, sb.toString());
    } else if (ch == '=') {
        ch = nextCharacter(inputStream);
        skipWhitespace(inputStream);
        if (isValueCharacter(ch)) {
            sb.setLength(0);
            do {
                sb.append(ch);
                ch = nextCharacter(inputStream);
            } while (isValueCharacter(ch));
            return new Token(VALUE_TOKEN, sb.toString().trim());
        }
    } else if (ch == '[') {
        ch = nextCharacter(inputStream);
        Token id = getToken(inputStream);
        ch = nextCharacter(inputStream);
        return new Token(SECTION_TOKEN, id.getValue());
    } else if (ch == '#') {
        do {
            ch = nextCharacter(inputStream);
        } while (!isNewLineCharacter(ch));
        return getToken(inputStream);
    }
    return null;
}

Output:
         ch = nextCharacter(inputStream);
-        skipWhitespace(inputStream);
+        sb.setLength(0);
         if (isValueCharacter(ch)) {