Input:
MaybeEmptyCallableMemberDescriptor getMostSpecific(List memberDescs, boolean varArg) {
    LinkedList applicables = getApplicables(memberDescs, varArg);
    if (applicables.isEmpty()) {
        return EmptyCallableMemberDescriptor.NO_SUCH_METHOD;
    }
    if (applicables.size() == 1) {
        return (CallableMemberDescriptor) applicables.getFirst();
    }
    LinkedList maximals = new LinkedList();
    for (Iterator it = applicables.iterator(); it.hasNext(); ) {
        CallableMemberDescriptor applicable = (CallableMemberDescriptor) it.next();
        Class[] appParamTypes = applicable.paramTypes;
        boolean lessSpecific = false;
        for (Iterator maximal = maximals.iterator(); maximal.hasNext(); ) {
            CallableMemberDescriptor max = (CallableMemberDescriptor) maximal.next();
            Class[] maxParamTypes = max.paramTypes;
            switch(moreSpecific(appParamTypes, maxParamTypes, varArg)) {
                case MORE_SPECIFIC:
                    {
                        maximal.remove();
                        break;
                    }
                case LESS_SPECIFIC:
                    {
                        lessSpecific = true;
                        break;
                    }
            }
        }
        if (!lessSpecific) {
            maximals.addLast(applicable);
        }
    }
    if (maximals.size() > 1) {
        return EmptyCallableMemberDescriptor.AMBIGUOUS_METHOD;
    }
    return (CallableMemberDescriptor) maximals.getFirst();
}

Output:
     LinkedList maximals = new LinkedList();
-    for (Iterator it = applicables.iterator(); it.hasNext(); ) {
-        CallableMemberDescriptor applicable = (CallableMemberDescriptor) it.next();
-        Class[] appParamTypes = applicable.paramTypes;
+    for (Iterator applicablesIter = applicables.iterator(); applicablesIter.hasNext(); ) {
+        CallableMemberDescriptor applicable = (CallableMemberDescriptor) applicablesIter.next();
         boolean lessSpecific = false;


Input:
public void updateCurrentPosition(int colspan, int rowspan) {
    ensureRowIsStarted();
    while (lastEmptyRow.size() < currCol) {
        lastEmptyRow.add((Integer) currRow);
    }
    Integer value = (Integer) currRow + rowspan;
    if (lastEmptyRow.size() == currCol) {
        lastEmptyRow.add(value);
    } else {
        lastEmptyRow.set(currCol, Math.max(value, lastEmptyRow.get(currCol)));
    }
    int size = lastEmptyRow.size();
    int end = currCol + colspan;
    while (lastEmptyRow.size() < end) {
        lastEmptyRow.add(value);
    }
    for (int i = currCol; i < size; ++i) {
        lastEmptyRow.set(i, Math.max(value, lastEmptyRow.get(i)));
    }
    currCol = end;
}

Output:
     while (lastEmptyRow.size() < currCol) {
-        lastEmptyRow.add((Integer) currRow);
+        lastEmptyRow.add(currRow);
     }


Input:
public void replaceView(ProteusView proteusView) {
    if (proteusView instanceof DataProteusView) {
        DataProteusView dataProteusView = (DataProteusView) proteusView;
        this.bindings = dataProteusView.getBindings();
        this.childLayout = dataProteusView.getChildLayout();
        this.dataPathForChildren = dataProteusView.getDataPathForChildren();
        this.parserContext = dataProteusView.getParserContext();
    }
    super.replaceView(proteusView);
}

Output:
     }
-    super.replaceView(proteusView);
+    super.replaceView(view);
 }


Input:
public boolean next(final NullWritable key, final VectorizedRowBatch outputBatch) throws IOException {
    outputBatch.reset();
    if (!isPartitionSetting) {
        setting.setPartitionValues(outputBatch);
        isPartitionSetting = true;
    }
    if (indexSize <= currentIndex) {
        if (!currentReader.hasNext()) {
            updateCounter(currentReader.getReadStats());
            outputBatch.endOfFile = true;
            isEnd = true;
            return false;
        }
        while (!setSpread()) {
            if (!currentReader.hasNext()) {
                updateCounter(currentReader.getReadStats());
                outputBatch.endOfFile = true;
                isEnd = true;
                return false;
            }
        }
    }
    int maxSize = outputBatch.getMaxSize();
    if (indexSize < currentIndex + maxSize) {
        maxSize = indexSize - currentIndex;
    }
    for (int colIndex : needColumnIds) {
        assignors[colIndex].setColumnVector(outputBatch.cols[colIndex], currentIndexList, currentIndex, maxSize);
    }
    outputBatch.size = maxSize;
    currentIndex += maxSize;
    if (indexSize <= currentIndex && !currentReader.hasNext()) {
        outputBatch.endOfFile = true;
    }
    return outputBatch.size > 0;
}

Output:
     outputBatch.reset();
-    if (!isPartitionSetting) {
-        setting.setPartitionValues(outputBatch);
-        isPartitionSetting = true;
-    }
+    setting.setPartitionValues(outputBatch);
     if (indexSize <= currentIndex) {


Input:
private void addAttributeBlock(Composite container, final AttributeDesignation attribute) {
    final Label label = new Label(container, SWT.NONE);
    label.setText(attribute.getType().getName());
    final Text value = new Text(container, SWT.BORDER);
    value.setText(attribute.getType().getConverter().toString(attribute.getValue()));
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).applyTo(value);
    final Button deleteButton = new Button(container, SWT.PUSH);
    deleteButton.setImage(Images.REMOVE.image());
    final Binding binding = bindings.getBindingContext().bindValue(WidgetProperties.text(SWT.Modify).observe(value), BeanProperties.value("String_Node_Str").observe(attribute), new UpdateValueStrategy().setConverter(new ToAttributeObjectConverter(attribute)), new UpdateValueStrategy().setConverter(new ToAttributeStringConverter(attribute)));
    deleteButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            model.getAttributes().remove(attribute);
            bindings.getBindingContext().removeBinding(binding);
            Composite parent = deleteButton.getParent();
            label.dispose();
            value.dispose();
            deleteButton.dispose();
            parent.getParent().layout(true);
        }
    });
}

Output:
     deleteButton.setImage(Images.REMOVE.image());
-    final Binding binding = bindings.getBindingContext().bindValue(WidgetProperties.text(SWT.Modify).observe(value), BeanProperties.value("String_Node_Str").observe(attribute), new UpdateValueStrategy().setConverter(new ToAttributeObjectConverter(attribute)), new UpdateValueStrategy().setConverter(new ToAttributeStringConverter(attribute)));
+    ToAttributeObjectConverter input2model = new ToAttributeObjectConverter(attribute);
+    final Binding binding = bindings.getBindingContext().bindValue(WidgetProperties.text(SWT.Modify).observe(value), BeanProperties.value("String_Node_Str").observe(attribute), new UpdateValueStrategy().setAfterGetValidator(input2model).setConverter(input2model), new UpdateValueStrategy().setConverter(new ToAttributeStringConverter(attribute)));
     deleteButton.addSelectionListener(new SelectionAdapter() {


Input:
public boolean performAccessibilityAction(int action, Bundle arguments) {
    if (super.performAccessibilityAction(action, arguments)) {
        return true;
    }
    switch(action) {
        case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD:
            {
                setRelativeFocusedTask(true, false, false);
                return true;
            }
        case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD:
            {
                setRelativeFocusedTask(false, false, false);
                return true;
            }
    }
    return false;
}

Output:
     }
-    switch(action) {
-        case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD:
-            {
-                setRelativeFocusedTask(true, false, false);
-                return true;
-            }
-        case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD:
-            {
-                setRelativeFocusedTask(false, false, false);
-                return true;
-            }
+    Task focusedTask = getAccessibilityFocusedTask();
+    int taskIndex = mStack.indexOfStackTask(focusedTask);
+    if (0 <= taskIndex && taskIndex < mStack.getTaskCount()) {
+        switch(action) {
+            case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD:
+                {
+                    setFocusedTask(taskIndex + 1, true, true, 0);
+                    return true;
+                }
+            case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD:
+                {
+                    setFocusedTask(taskIndex - 1, true, true, 0);
+                    return true;
+                }
+        }
     }


Input:
protected boolean buildInstaller(BuildSpec buildSpec, String targDirPath) {
    if (buildSpec.verbose) {
        handler.log("String_Node_Str" + buildSpec);
    }
    AJInstaller installer = new AJInstaller();
    installer.setProject(project);
    installer.setBasedir(targDirPath);
    File installSrcDir = new File(buildSpec.productDir, "String_Node_Str");
    Util.iaxIfNotCanReadDir(installSrcDir, "String_Node_Str");
    installer.setHtmlSrc(installSrcDir.getPath());
    String resourcePath = getProductInstallResourcesSrc(buildSpec);
    File resourceSrcDir = new File(resourcePath);
    Util.iaxIfNotCanReadDir(resourceSrcDir, "String_Node_Str");
    installer.setResourcesSrc(resourcePath);
    String name = getProductInstallerFileName(buildSpec);
    File outFile = new File(buildSpec.jarDir, name);
    installer.setZipfile(outFile.getPath());
    installer.setMainclass(getProductInstallerMainClass(buildSpec));
    installer.setInstallerclassjar(getBuildJar(buildSpec));
    return executeTask(installer);
}

Output:
     AJInstaller installer = new AJInstaller();
-    installer.setProject(project);
+    setupTask(installer, "String_Node_Str");
     installer.setBasedir(targDirPath);


Input:
public void testPromptsNoLocalizer() {
    QuestionDef q = new QuestionDef();
    q.putQuestionString("String_Node_Str", new QuestionString("String_Node_Str", "String_Node_Str"));
    if (!"String_Node_Str".equals(q.getQuestionString("String_Node_Str"))) {
        fail("String_Node_Str");
    }
}

Output:
     q.putQuestionString("String_Node_Str", new QuestionString("String_Node_Str", "String_Node_Str"));
-    if (!"String_Node_Str".equals(q.getQuestionString("String_Node_Str"))) {
+    if (!"String_Node_Str".equals(q.getQuestionString("String_Node_Str").getTextInner())) {
         fail("String_Node_Str");


Input:
private Node _getLastNodeBeforeTime(IOPort port, Time upper) {
    List<Node> nodes = (List<Node>) _graph.nodes();
    Node lastNodeBeforeTime = null;
    Time time = Time.NEGATIVE_INFINITY;
    for (Node node : nodes) {
        TDLAction gnode = (TDLAction) node.getWeight();
        if (gnode.object.equals(port) && upper.compareTo(gnode.time) >= 0 && time.compareTo(gnode.time) < 0) {
            lastNodeBeforeTime = node;
            time = gnode.time;
        }
    }
    return lastNodeBeforeTime;
}

Output:
         TDLAction gnode = (TDLAction) node.getWeight();
-        if (gnode.object.equals(port) && upper.compareTo(gnode.time) >= 0 && time.compareTo(gnode.time) < 0) {
+        if (gnode.object != null && gnode.object.equals(port) && upper.compareTo(gnode.time) >= 0 && time.compareTo(gnode.time) < 0) {
             lastNodeBeforeTime = node;


Input:
public void enable(boolean enabled) {
    this.enabled = enabled;
    if (!enabled) {
        instanceInitialized = false;
        middleware.setSSLContext(null);
    }
}

Output:
         instanceInitialized = false;
-        middleware.setSSLContext(null);
+        for (AsyncSSLSocketMiddleware m : middleware) {
+            m.setSSLContext(null);
+        }
     }


Input:
public Collection<TypeElement> getClassElements(PackageElement pkg) {
    Set<TypeElement> r = new TreeSet<TypeElement>(TYPE_COMPARATOR);
    for (TypeElement e : classElements) {
        Element p = e.getEnclosingElement();
        if (p.equals(pkg))
            r.add(e);
    }
    return r;
}

Output:
     Set<TypeElement> r = new TreeSet<TypeElement>(TYPE_COMPARATOR);
-    for (TypeElement e : classElements) {
+    for (TypeElement e : parsedTypes.keySet()) {
         Element p = e.getEnclosingElement();


Input:
public Object get(String name, Scriptable start) {
    DummyParameterAttribute attr = (DummyParameterAttribute) this.params.get(this.parameterName);
    if (attr == null) {
        return null;
    }
    if (FIELD_VALUE.equals(name)) {
        return attr.getValue();
    } else if (FIELD_DISPLAY_TEXT.equals(name)) {
        return attr.getDisplayText();
    }
    Object value = attr.getValue();
    Scriptable jsStr = Context.toObject(value, start);
    if (jsStr != null && jsStr.getPrototype() != null) {
        return jsStr.getPrototype().get(name, jsStr);
    }
    return null;
}

Output:
     Object value = attr.getValue();
-    Scriptable jsStr = Context.toObject(value, start);
-    if (jsStr != null && jsStr.getPrototype() != null) {
-        return jsStr.getPrototype().get(name, jsStr);
+    if (value instanceof Scriptable) {
+        Scriptable jsValue = (Scriptable) value;
+        Object property = jsValue.getPrototype().get(name, jsValue);
+        if (property instanceof Callable) {
+            Callable callable = (Callable) property;
+            return new JsValueCallable(callable);
+        }
+        return jsValue.get(name, jsValue);
+    } else {
+        Scriptable jsValue = Context.toObject(value, start);
+        return jsValue.get(name, jsValue);
     }


Input:
protected void okPressed() {
    String name = getName();
    if (name.length() == 0) {
        MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
        nameText.setFocus();
        isOK = false;
        return;
    }
    if (MDMServerHelper.getServer(name) != null) {
        MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
        isOK = false;
        return;
    }
    if (getServer().length() == 0) {
        MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
        urlText.setFocus();
        isOK = false;
        return;
    }
    if (getUsernameText().length() == 0) {
        MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
        userText.setFocus();
        isOK = false;
        return;
    }
    if (getPasswordText().length() == 0) {
        MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
        passwordText.setFocus();
        isOK = false;
        return;
    }
    isOK = true;
    setReturnCode(OK);
}

Output:
     }
-    if (MDMServerHelper.getServer(name) != null) {
-        MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
-        isOK = false;
-        return;
+    MDMServerDef server = MDMServerHelper.getServer(name);
+    if (server != null) {
+        if ((!isUpdateServerLocation()) || (isUpdateServerLocation() && (!server.getName().equalsIgnoreCase(selectedServerDef.getName())))) {
+            MessageDialog.openError(null, "String_Node_Str", "String_Node_Str");
+            isOK = false;
+            return;
+        }
     }


Input:
public QueryImpl<T> clone() {
    QueryImpl<T> n = new QueryImpl<T>(clazz, dbColl, ds);
    n.batchSize = batchSize;
    n.cache = this.ds.getMapper().createEntityCache();
    n.fields = fields == null ? null : Arrays.copyOf(fields, fields.length);
    n.includeFields = includeFields;
    n.indexHint = indexHint;
    n.limit = limit;
    n.noTimeout = noTimeout;
    n.query = n;
    n.offset = offset;
    n.slaveOk = slaveOk;
    n.snapshotted = snapshotted;
    n.validateName = validateName;
    n.validateType = validateType;
    n.sort = (BasicDBObject) (sort == null ? null : sort.clone());
    n.baseQuery = (BasicDBObject) (baseQuery == null ? null : baseQuery.clone());
    n.attachedTo = attachedTo;
    n.children = children == null ? null : new ArrayList<Criteria>(children);
    n.tail = tail;
    n.tail_await_data = tail_await_data;
    return n;
}

Output:
     n.offset = offset;
-    n.slaveOk = slaveOk;
+    n.readPref = readPref;
     n.snapshotted = snapshotted;


Input:
public void removeLayout(GlimpseLayout layout) {
    lock.lock();
    try {
        layoutChildren.remove(layout);
        layoutDelegate.removeLayout(layout);
        invalidateLayout();
    } finally {
        lock.unlock();
    }
}

Output:
     try {
-        layoutChildren.remove(layout);
+        manager.removeLayout(layout);
         layoutDelegate.removeLayout(layout);


Input:
private boolean upgradeTwoEighttoTwoNine(SQLiteDatabase database) {
    String ssdTable = TableBuilder.scrubName(SessionStateDescriptor.STORAGE_KEY);
    String tempssdTable = TableBuilder.scrubName(SessionStateDescriptor.STORAGE_KEY + "String_Node_Str");
    int oldRows = countRows(database, ssdTable);
    try {
        database.beginTransaction();
        TableBuilder builder = new TableBuilder(AndroidLogEntry.STORAGE_KEY);
        builder.addData(new AndroidLogEntry());
        database.execSQL(builder.getTableCreateString());
        builder = new TableBuilder(DeviceReportRecord.STORAGE_KEY);
        builder.addData(new DeviceReportRecord());
        database.execSQL(builder.getTableCreateString());
        database.execSQL(String.format("String_Node_Str", ssdTable, tempssdTable));
        builder = new TableBuilder(SessionStateDescriptor.STORAGE_KEY);
        builder.setUnique(SessionStateDescriptor.META_FORM_RECORD_ID);
        builder.addData(new SessionStateDescriptor());
        database.execSQL(builder.getTableCreateString());
        String cols = builder.getColumns();
        database.execSQL(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str", ssdTable, cols, cols, tempssdTable));
        database.execSQL(String.format("String_Node_Str", tempssdTable));
        database.setTransactionSuccessful();
        int newRows = countRows(database, ssdTable);
        if (oldRows != newRows) {
            Logger.log(AndroidLogger.TYPE_MAINTENANCE, "String_Node_Str");
        }
        return true;
    } finally {
        database.endTransaction();
    }
}

Output:
         if (oldRows != newRows) {
-            Logger.log(AndroidLogger.TYPE_MAINTENANCE, "String_Node_Str");
+            Logger.log(AndroidLogger.TYPE_MAINTENANCE, String.format("String_Node_Str", String.valueOf(newRows - oldRows)));
         }


Input:
public double getNoHitsFraction() {
    return 1.0 * noHits / processedQueries;
}

Output:
 public double getNoHitsFraction() {
-    return 1.0 * noHits / processedQueries;
+    return 1.0 * noHits / processedGoodQueries;
 }


Input:
public void iteration() {
    final int rowCount = this.trainingData.size();
    final int coeffCount = this.algorithm.getLongTermMemory().length;
    final double[][] working = new double[rowCount][coeffCount];
    final double[] errors = new double[rowCount];
    final double[] weights = new double[rowCount];
    final Matrix deltas;
    for (int i = 0; i < rowCount; i++) {
        final BasicData element = this.trainingData.get(i);
        working[i][0] = 1;
        for (int j = 0; j < element.getInput().length; j++) working[i][j + 1] = element.getInput()[j];
    }
    for (int i = 0; i < rowCount; i++) {
        final BasicData element = this.trainingData.get(i);
        final double y = this.algorithm.computeRegression(element.getInput())[0];
        errors[i] = y - element.getIdeal()[0];
        weights[i] = y * (1.0 - y);
    }
    for (int i = 0; i < gradient.getColumnDimension(); i++) {
        gradient.set(0, i, 0);
        for (int j = 0; j < gradient.getColumnDimension(); j++) hessian[i][j] = 0;
    }
    for (int j = 0; j < working.length; j++) {
        for (int i = 0; i < gradient.getColumnDimension(); i++) {
            gradient.set(i, 0, gradient.get(i, 0) + working[j][i] * errors[j]);
        }
    }
    for (int k = 0; k < weights.length; k++) {
        final double[] r = working[k];
        for (int j = 0; j < r.length; j++) {
            for (int i = 0; i < r.length; i++) {
                hessian[j][i] += r[i] * r[j] * weights[k];
            }
        }
    }
    final LUDecomposition lu = new LUDecomposition(new Matrix(hessian));
    if (lu.isNonsingular()) {
        deltas = lu.solve(gradient);
    } else {
        throw new AIFHError("String_Node_Str");
    }
    final double[] prev = this.algorithm.getLongTermMemory().clone();
    for (int i = 0; i < this.algorithm.getLongTermMemory().length; i++) this.algorithm.getLongTermMemory()[i] -= deltas.get(i, 0);
    double max = 0;
    for (int i = 0; i < deltas.getColumnDimension(); i++) max = Math.max(Math.abs(deltas.get(i, 0)) / Math.abs(prev[i]), max);
    this.error = max;
}

Output:
     for (int j = 0; j < working.length; j++) {
-        for (int i = 0; i < gradient.getColumnDimension(); i++) {
+        for (int i = 0; i < gradient.getRowDimension(); i++) {
             gradient.set(i, 0, gradient.get(i, 0) + working[j][i] * errors[j]);


Input:
public void run() {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str" + id + "String_Node_Str");
    }
    for (NetworkPartitionContext networkPartitionContext : networkPartitionContexts) {
        for (InstanceContext instanceContext : networkPartitionContext.getInstanceIdToInstanceContextMap().values()) {
            GroupInstance instance = (GroupInstance) instanceIdToInstanceMap.get(instanceContext.getId());
            if (instance.getStatus().getCode() <= GroupStatus.Active.getCode()) {
                if (!instanceContext.getIdToScalingOverMaxEvent().isEmpty()) {
                    handleScalingMaxOut(networkPartitionContext, instanceContext);
                } else if (!instanceContext.getIdToScalingEvent().isEmpty()) {
                    handleDependentScaling(instanceContext, networkPartitionContext);
                } else if (!instanceContext.getIdToScalingDownBeyondMinEvent().isEmpty()) {
                    handleScalingDownBeyondMin(instanceContext, networkPartitionContext);
                }
            }
        }
    }
}

Output:
                 if (!instanceContext.getIdToScalingOverMaxEvent().isEmpty()) {
-                    handleScalingMaxOut(networkPartitionContext, instanceContext);
+                    handleScalingMaxOut(instanceContext, networkPartitionContext);
                 } else if (!instanceContext.getIdToScalingEvent().isEmpty()) {


Input:
public void setEvictedNodes(ModuleId moduleId, String rootModuleConf, Collection evicted) {
    _evictedDeps.put(new ModuleIdConf(moduleId, rootModuleConf), new HashSet(evicted));
}

Output:
 public void setEvictedNodes(ModuleId moduleId, String rootModuleConf, Collection evicted) {
-    _evictedDeps.put(new ModuleIdConf(moduleId, rootModuleConf), new HashSet(evicted));
+    ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
+    _evictedDeps.put(moduleIdConf, new HashSet(evicted));
+    Collection evictedRevs = new HashSet();
+    for (Iterator iter = evicted.iterator(); iter.hasNext(); ) {
+        IvyNode node = (IvyNode) iter.next();
+        evictedRevs.add(node.getId());
+        evictedRevs.add(node.getResolvedId());
+    }
+    _evictedRevs.put(moduleIdConf, evictedRevs);
 }


Input:
public void tickClient() {
    if (isCloudlessStorm())
        return;
    if (particleBehaviorFog == null) {
        particleBehaviorFog = new ParticleBehaviorFog(new Vec3(pos.xCoord, pos.yCoord, pos.zCoord));
    } else {
        if (!Minecraft.getMinecraft().isSingleplayer() || !(Minecraft.getMinecraft().currentScreen instanceof GuiIngameMenu)) {
            particleBehaviorFog.tickUpdateList();
        }
    }
    EntityPlayer entP = Minecraft.getMinecraft().thePlayer;
    spinSpeed = 0.02D;
    double spinSpeedMax = 0.4D;
    if (isCycloneFormingOrGreater()) {
        spinSpeed = spinSpeedMax * 0.00D + ((levelCurIntensityStage - levelStormIntensityFormingStartVal + 1) * spinSpeedMax * 0.2D);
    } else if (isTornadoFormingOrGreater()) {
        spinSpeed = spinSpeedMax * 0.2D;
    } else if (levelCurIntensityStage >= STATE_HIGHWIND) {
        spinSpeed = spinSpeedMax * 0.05D;
    } else {
        spinSpeed = spinSpeedMax * 0.02D;
    }
    if (isHurricane()) {
        spinSpeed += 0.1D;
    }
    if (size == 0)
        size = 1;
    int delay = Math.max(1, (int) (100F / size * 1F));
    int loopSize = 1;
    int extraSpawning = 0;
    if (isSpinning()) {
        loopSize += 4;
        extraSpawning = 300;
    }
    if (stormType == TYPE_WATER) {
        if (levelCurIntensityStage >= STATE_STAGE5) {
            loopSize = 10;
            extraSpawning = 800;
        } else if (levelCurIntensityStage >= STATE_STAGE4) {
            loopSize = 8;
            extraSpawning = 700;
        } else if (levelCurIntensityStage >= STATE_STAGE3) {
            loopSize = 6;
            extraSpawning = 500;
        } else if (levelCurIntensityStage >= STATE_STAGE2) {
            loopSize = 4;
            extraSpawning = 400;
        } else {
            extraSpawning = 300;
        }
    }
    Random rand = new Random();
    Vec3 playerAdjPos = new Vec3(entP.posX, pos.yCoord, entP.posZ);
    double maxSpawnDistFromPlayer = 512;
    if (this.manager.getWorld().getTotalWorldTime() % (delay + ConfigMisc.Cloud_ParticleSpawnDelay) == 0) {
        for (int i = 0; i < loopSize; i++) {
            if (listParticlesCloud.size() < size + extraSpawning) {
                double spawnRad = size;
                Vec3 tryPos = new Vec3(pos.xCoord + (rand.nextDouble() * spawnRad) - (rand.nextDouble() * spawnRad), layers.get(layer), pos.zCoord + (rand.nextDouble() * spawnRad) - (rand.nextDouble() * spawnRad));
                if (tryPos.distanceTo(playerAdjPos) < maxSpawnDistFromPlayer) {
                    EntityRotFX particle;
                    if (WeatherUtil.isAprilFoolsDay()) {
                        particle = spawnFogParticle(tryPos.xCoord, tryPos.yCoord, tryPos.zCoord, 0, ParticleRegistry.chicken);
                    } else {
                        particle = spawnFogParticle(tryPos.xCoord, tryPos.yCoord, tryPos.zCoord, 0);
                    }
                    listParticlesCloud.add(particle);
                }
            }
        }
    }
    if (levelCurIntensityStage >= STATE_HIGHWIND) {
        for (int i = 0; i < (stormType == TYPE_WATER ? 50 : 3); i++) {
            if (listParticlesGround.size() < (stormType == TYPE_WATER ? 600 : 150)) {
                double spawnRad = size / 4 * 3;
                if (stormType == TYPE_WATER) {
                    spawnRad = size * 3;
                }
                Vec3 tryPos = new Vec3(pos.xCoord + (rand.nextDouble() * spawnRad) - (rand.nextDouble() * spawnRad), posGround.yCoord, pos.zCoord + (rand.nextDouble() * spawnRad) - (rand.nextDouble() * spawnRad));
                if (tryPos.distanceTo(playerAdjPos) < maxSpawnDistFromPlayer) {
                    int groundY = WeatherUtilBlock.getPrecipitationHeightSafe(manager.getWorld(), new BlockPos((int) tryPos.xCoord, 0, (int) tryPos.zCoord)).getY();
                    EntityRotFX particle;
                    if (WeatherUtil.isAprilFoolsDay()) {
                        particle = spawnFogParticle(tryPos.xCoord, groundY + 3, tryPos.zCoord, 0, ParticleRegistry.potato);
                    } else {
                        particle = spawnFogParticle(tryPos.xCoord, groundY + 3, tryPos.zCoord, 0);
                    }
                    particle.setScale(100);
                    particle.rotationYaw = rand.nextInt(360);
                    particle.rotationPitch = rand.nextInt(360);
                    listParticlesGround.add(particle);
                }
            }
        }
    }
    delay = 1;
    loopSize = 2;
    double spawnRad = size / 48;
    if (levelCurIntensityStage >= STATE_STAGE5) {
        spawnRad = 200;
        loopSize = 10;
        sizeMaxFunnelParticles = 1200;
    } else if (levelCurIntensityStage >= STATE_STAGE4) {
        spawnRad = 150;
        loopSize = 8;
        sizeMaxFunnelParticles = 1000;
    } else if (levelCurIntensityStage >= STATE_STAGE3) {
        spawnRad = 100;
        loopSize = 6;
        sizeMaxFunnelParticles = 800;
    } else if (levelCurIntensityStage >= STATE_STAGE2) {
        spawnRad = 50;
        loopSize = 4;
        sizeMaxFunnelParticles = 600;
    } else {
        sizeMaxFunnelParticles = 600;
    }
    if (isTornadoFormingOrGreater() || (attrib_waterSpout)) {
        if (this.manager.getWorld().getTotalWorldTime() % (delay + ConfigStorm.Storm_ParticleSpawnDelay) == 0) {
            for (int i = 0; i < loopSize; i++) {
                if (listParticlesFunnel.size() >= sizeMaxFunnelParticles) {
                    listParticlesFunnel.get(0).setExpired();
                    listParticlesFunnel.remove(0);
                }
                if (listParticlesFunnel.size() < sizeMaxFunnelParticles) {
                    Vec3 tryPos = new Vec3(pos.xCoord + (rand.nextDouble() * spawnRad) - (rand.nextDouble() * spawnRad), pos.yCoord, pos.zCoord + (rand.nextDouble() * spawnRad) - (rand.nextDouble() * spawnRad));
                    if (tryPos.distanceTo(playerAdjPos) < maxSpawnDistFromPlayer) {
                        EntityRotFX particle;
                        if (WeatherUtil.isAprilFoolsDay()) {
                            particle = spawnFogParticle(tryPos.xCoord, posBaseFormationPos.yCoord, tryPos.zCoord, 1, ParticleRegistry.potato);
                        } else {
                            particle = spawnFogParticle(tryPos.xCoord, posBaseFormationPos.yCoord, tryPos.zCoord, 1);
                        }
                        particle.setMaxAge(150 + ((levelCurIntensityStage - 1) * 100) + rand.nextInt(100));
                        float baseBright = 0.3F;
                        float randFloat = (rand.nextFloat() * 0.6F);
                        particle.rotationYaw = rand.nextInt(360);
                        float finalBright = Math.min(1F, baseBright + randFloat);
                        if (levelCurIntensityStage == STATE_HIGHWIND) {
                            particle.setScale(150);
                            particle.setRBGColorF(finalBright - 0.2F, finalBright - 0.2F, finalBright);
                        } else {
                            particle.setScale(250);
                            particle.setRBGColorF(finalBright, finalBright, finalBright);
                        }
                        listParticlesFunnel.add(particle);
                    }
                } else {
                }
            }
        }
    }
    for (int i = 0; i < listParticlesFunnel.size(); i++) {
        EntityRotFX ent = listParticlesFunnel.get(i);
        if (!ent.isAlive()) {
            listParticlesFunnel.remove(ent);
        } else if (ent.getPosY() > pos.yCoord) {
            ent.setExpired();
            listParticlesFunnel.remove(ent);
        } else {
            double var16 = this.pos.xCoord - ent.getPosX();
            double var18 = this.pos.zCoord - ent.getPosZ();
            ent.rotationYaw = (float) (Math.atan2(var18, var16) * 180.0D / Math.PI) - 90.0F;
            ent.rotationYaw += ent.getEntityId() % 90;
            ent.rotationPitch = -30F;
            if (levelCurIntensityStage == STATE_HIGHWIND) {
                int fadingDistStart = 30;
                if (ent.getPosY() > posGround.yCoord + fadingDistStart) {
                    float maxVal = ent.getBlueColorF();
                    float fadeRate = 0.002F;
                    ent.setRBGColorF(Math.min(maxVal, ent.getRedColorF() + fadeRate), Math.min(maxVal, ent.getGreenColorF() + fadeRate), maxVal);
                }
            }
            spinEntity(ent);
        }
    }
    for (int i = 0; i < listParticlesCloud.size(); i++) {
        EntityRotFX ent = listParticlesCloud.get(i);
        if (!ent.isAlive()) {
            listParticlesCloud.remove(ent);
        } else {
            double curSpeed = Math.sqrt(ent.getMotionX() * ent.getMotionX() + ent.getMotionY() * ent.getMotionY() + ent.getMotionZ() * ent.getMotionZ());
            double curDist = ent.getDistance(pos.xCoord, ent.getPosY(), pos.zCoord);
            float dropDownRange = 15F;
            float extraDropCalc = 0;
            if (curDist < 200 && ent.getEntityId() % 20 < 5) {
                extraDropCalc = ((ent.getEntityId() % 20) * dropDownRange);
                if (isCycloneFormingOrGreater()) {
                    extraDropCalc = ((ent.getEntityId() % 20) * dropDownRange * 5F);
                }
            }
            if (isSpinning()) {
                double speed = spinSpeed + (rand.nextDouble() * 0.01D);
                double distt = size;
                double vecX = ent.getPosX() - pos.xCoord;
                double vecZ = ent.getPosZ() - pos.zCoord;
                float angle = (float) (Math.atan2(vecZ, vecX) * 180.0D / Math.PI);
                angle += speed * 50D;
                angle -= (ent.getEntityId() % 10) * 3D;
                angle += rand.nextInt(10) - rand.nextInt(10);
                if (curDist > distt) {
                    angle += 40;
                }
                if (ent.getEntityId() % 20 < 5) {
                    if (levelCurIntensityStage >= STATE_FORMING) {
                        if (stormType == TYPE_WATER) {
                            angle += 40 + ((ent.getEntityId() % 5) * 4);
                            if (curDist > 150 + ((levelCurIntensityStage - levelStormIntensityFormingStartVal + 1) * 30)) {
                                angle += 10;
                            }
                        } else {
                            angle += 30 + ((ent.getEntityId() % 5) * 4);
                        }
                    } else {
                        if (curDist > 150) {
                            angle += 50 + ((ent.getEntityId() % 5) * 4);
                        }
                    }
                    double var16 = this.pos.xCoord - ent.getPosX();
                    double var18 = this.pos.zCoord - ent.getPosZ();
                    ent.rotationYaw = (float) (Math.atan2(var18, var16) * 180.0D / Math.PI) - 90.0F;
                    ent.rotationPitch = -20F - (ent.getEntityId() % 10);
                }
                if (curSpeed < speed * 20D) {
                    ent.setMotionX(ent.getMotionX() + -Math.sin(Math.toRadians(angle)) * speed);
                    ent.setMotionZ(ent.getMotionZ() + Math.cos(Math.toRadians(angle)) * speed);
                }
            } else {
                float cloudMoveAmp = 0.2F * (1 + layer);
                float speed = getAdjustedSpeed() * cloudMoveAmp;
                float angle = getAdjustedAngle();
                dropDownRange = 5;
                if (ent.getEntityId() % 20 < 5) {
                    extraDropCalc = ((ent.getEntityId() % 20) * dropDownRange);
                }
                if (curSpeed < speed * 1D) {
                    ent.setMotionX(ent.getMotionX() + -Math.sin(Math.toRadians(angle)) * speed);
                    ent.setMotionZ(ent.getMotionZ() + Math.cos(Math.toRadians(angle)) * speed);
                }
            }
            if (Math.abs(ent.getPosY() - (pos.yCoord - extraDropCalc)) > 2F) {
                if (ent.getPosY() < pos.yCoord - extraDropCalc) {
                    ent.setMotionY(ent.getMotionY() + 0.1D);
                } else {
                    ent.setMotionY(ent.getMotionY() + 0.1D);
                }
            }
            float dropDownSpeedMax = 0.15F;
            if (isCycloneFormingOrGreater()) {
                dropDownSpeedMax = 0.9F;
            }
            if (ent.getMotionY() < -dropDownSpeedMax) {
                ent.setMotionY(-dropDownSpeedMax);
            }
            if (ent.getMotionY() > dropDownSpeedMax) {
                ent.setMotionY(dropDownSpeedMax);
            }
        }
    }
    for (int i = 0; i < listParticlesGround.size(); i++) {
        EntityRotFX ent = listParticlesGround.get(i);
        double curDist = ent.getDistance(pos.xCoord, ent.getPosY(), pos.zCoord);
        if (!ent.isAlive()) {
            listParticlesGround.remove(ent);
        } else {
            double curSpeed = Math.sqrt(ent.getMotionX() * ent.getMotionX() + ent.getMotionY() * ent.getMotionY() + ent.getMotionZ() * ent.getMotionZ());
            double speed = Math.max(0.2F, 5F * spinSpeed) + (rand.nextDouble() * 0.01D);
            double distt = size;
            double vecX = ent.getPosX() - pos.xCoord;
            double vecZ = ent.getPosZ() - pos.zCoord;
            float angle = (float) (Math.atan2(vecZ, vecX) * 180.0D / Math.PI);
            angle += 85;
            int maxParticleSize = 60;
            if (stormType == TYPE_WATER) {
                maxParticleSize = 150;
                speed /= 5D;
            }
            ent.setScale((float) Math.min(maxParticleSize, curDist * 2F));
            if (curDist < 20) {
                ent.setExpired();
            }
            double var16 = this.pos.xCoord - ent.getPosX();
            double var18 = this.pos.zCoord - ent.getPosZ();
            if (curSpeed < speed * 20D) {
                ent.setMotionX(ent.getMotionX() + -Math.sin(Math.toRadians(angle)) * speed);
                ent.setMotionZ(ent.getMotionZ() + Math.cos(Math.toRadians(angle)) * speed);
            }
        }
    }
}

Output:
                 } else {
-                    ent.setMotionY(ent.getMotionY() + 0.1D);
+                    ent.setMotionY(ent.getMotionY() - 0.1D);
                 }


Input:
void printJsonForTargets(CommandRunnerParams params, Executor executor, SortedMap<String, TargetNode<?>> buildIndex) throws BuildFileParseException, IOException, InterruptedException {
    params.getConsole().getStdOut().println("String_Node_Str");
    ObjectMapper mapper = params.getObjectMapper();
    Iterator<TargetNode<?>> valueIterator = buildIndex.values().iterator();
    while (valueIterator.hasNext()) {
        TargetNode<?> targetNode = valueIterator.next();
        SortedMap<String, Object> sortedTargetRule = null;
        sortedTargetRule = params.getParser().getRawTargetNode(params.getBuckEventBus(), params.getCell(), getEnableProfiling(), executor, targetNode);
        if (sortedTargetRule == null) {
            params.getConsole().printErrorText("String_Node_Str" + targetNode.getBuildTarget().getFullyQualifiedName());
            continue;
        }
        StringWriter stringWriter = new StringWriter();
        try {
            mapper.writerWithDefaultPrettyPrinter().writeValue(stringWriter, sortedTargetRule);
        } catch (IOException e) {
            throw Throwables.propagate(e);
        }
        String output = stringWriter.getBuffer().toString();
        if (valueIterator.hasNext()) {
            output += "String_Node_Str";
        }
        params.getConsole().getStdOut().println(output);
    }
    params.getConsole().getStdOut().println("String_Node_Str");
}

Output:
     ObjectMapper mapper = params.getObjectMapper();
-    Iterator<TargetNode<?>> valueIterator = buildIndex.values().iterator();
-    while (valueIterator.hasNext()) {
-        TargetNode<?> targetNode = valueIterator.next();
-        SortedMap<String, Object> sortedTargetRule = null;
+    Iterator<Entry<String, TargetNode<?>>> mapIterator = buildIndex.entrySet().iterator();
+    while (mapIterator.hasNext()) {
+        Entry<String, TargetNode<?>> current = mapIterator.next();
+        String target = current.getKey();
+        TargetNode<?> targetNode = current.getValue();
+        SortedMap<String, Object> sortedTargetRule;
         sortedTargetRule = params.getParser().getRawTargetNode(params.getBuckEventBus(), params.getCell(), getEnableProfiling(), executor, targetNode);


Input:
private boolean canProceed() {
    TacitFormComposite.updateStatusMessage(getViewSite(), null, null, form);
    boolean canPerform = true;
    form.getMessageManager().removeMessage("String_Node_Str");
    form.getMessageManager().removeMessage("String_Node_Str");
    form.getMessageManager().removeMessage("String_Node_Str");
    String message = OutputPathValidation.getInstance().validateOutputDirectory(layoutData.getOutputLabel().getText(), "String_Node_Str");
    if (message != null) {
        message = layoutData.getOutputLabel().getText() + "String_Node_Str" + message;
        form.getMessageManager().addMessage("String_Node_Str", message, null, IMessageProvider.ERROR);
        canPerform = false;
    }
    try {
        if (inputLayoutData.getTypeCheckedSelectedFiles(checkType).size() < 1) {
            form.getMessageManager().addMessage("String_Node_Str", "String_Node_Str", null, IMessageProvider.ERROR);
            canPerform = false;
        }
    } catch (Exception e) {
        canPerform = false;
    }
    try {
        if (dictLayoutData.getTypeCheckedSelectedFiles(checkType).size() < 1) {
            form.getMessageManager().addMessage("String_Node_Str", "String_Node_Str", null, IMessageProvider.ERROR);
            canPerform = false;
        }
    } catch (Exception e) {
        canPerform = false;
    }
    return canPerform;
}

Output:
         form.getMessageManager().addMessage("String_Node_Str", message, null, IMessageProvider.ERROR);
-        canPerform = false;
+        return false;
     }


Input:
private void mockRandomRepeatData(double crossValidationRate, double random) {
    long trainingSize = this.trainingData.getRecordCount();
    long testingSize = this.testingData.getRecordCount();
    long size = trainingSize + testingSize;
    int next = RandomUtils.nextInt((int) size);
    MLDataPair dataPair = new BasicMLDataPair(new BasicMLData(new double[this.inputNodeCount]), new BasicMLData(new double[this.outputNodeCount]));
    if (next >= trainingSize) {
        this.testingData.getRecord(next - trainingSize, dataPair);
    } else {
        this.trainingData.getRecord(next, dataPair);
    }
    if (Double.valueOf(random).compareTo(Double.valueOf(crossValidationRate)) < 0) {
        this.testingData.add(dataPair);
    } else {
        this.trainingData.add(dataPair);
    }
}

Output:
     }
-    if (Double.valueOf(random).compareTo(Double.valueOf(crossValidationRate)) < 0) {
+    if (Double.compare(random, crossValidationRate) < 0) {
         this.testingData.add(dataPair);


Input:
public final boolean moveTo(final long pNodeKey) {
    assertNotClosed();
    if (pNodeKey == EFixed.NULL_NODE_KEY.getStandardProperty()) {
        return false;
    }
    final INode oldNode = mCurrentNode;
    Optional<? extends INode> newNode;
    try {
        if (pNodeKey < 0) {
            if (mItemList.size() > 0) {
                newNode = mItemList.getItem(pNodeKey);
            } else {
                newNode = Optional.absent();
            }
        } else {
            final Optional<? extends INode> node = (Optional<? extends INode>) mPageReadTrx.getNode(pNodeKey, EPage.NODEPAGE);
            newNode = node;
        }
    } catch (final TTIOException e) {
        newNode = Optional.absent();
    }
    if (newNode.isPresent()) {
        mCurrentNode = newNode.get();
        return true;
    } else {
        mCurrentNode = oldNode;
        return false;
    }
}

Output:
     final INode oldNode = mCurrentNode;
-    Optional<? extends INode> newNode;
+    Optional<? extends INodeBase> newNode;
     try {


Input:
private boolean validateDomainNameIsValidIdna(String domainName) {
    String decodeDomain = DomainUtil.decodeAndTrimAndReplaceAsciiToLowercase(domainName);
    return DomainUtil.validateDomainNameIsValidIdna(decodeDomain);
}

Output:
 private boolean validateDomainNameIsValidIdna(String domainName) {
-    String decodeDomain = DomainUtil.decodeAndTrimAndReplaceAsciiToLowercase(domainName);
+    String decodeDomain = DomainUtil.decodeAndReplaceAsciiToLowercase(domainName);
     return DomainUtil.validateDomainNameIsValidIdna(decodeDomain);


Input:
private boolean _tryToMatchCompositeEntity(CompositeEntity lhsEntity, CompositeEntity hostEntity) {
    FastLinkedList<MarkedEntityList> lhsMarkedList = new FastLinkedList<MarkedEntityList>();
    AtomicActor lhsNextActor = _findFirstAtomicActor(lhsEntity, lhsMarkedList, _match.keySet());
    _match.put(lhsEntity, hostEntity);
    if (lhsNextActor == null) {
        return true;
    } else {
        FastLinkedList<NamedObj>.Entry lhsTail = _lhsFrontier.getTail();
        FastLinkedList<NamedObj>.Entry hostTail = _hostFrontier.getTail();
        FastLinkedList<MarkedEntityList> hostMarkedList = new FastLinkedList<MarkedEntityList>();
        AtomicActor hostNextActor = _findFirstAtomicActor(hostEntity, hostMarkedList, _match.values());
        while (hostNextActor != null) {
            _lhsFrontier.add(lhsNextActor);
            _hostFrontier.add(hostNextActor);
            if (_match(lhsTail.getNext(), hostTail.getNext())) {
                return true;
            } else {
                _hostFrontier.removeAllAfter(hostTail);
                _lhsFrontier.removeAllAfter(lhsTail);
                hostNextActor = _findNextAtomicActor(hostEntity, hostMarkedList, _match.values());
            }
        }
        _match.remove(lhsEntity);
        return false;
    }
}

Output:
     AtomicActor lhsNextActor = _findFirstAtomicActor(lhsEntity, lhsMarkedList, _match.keySet());
-    _match.put(lhsEntity, hostEntity);
+    boolean firstEntrance = !_match.containsKey(lhsEntity);
+    if (firstEntrance) {
+        _match.put(lhsEntity, hostEntity);
+    }
     if (lhsNextActor == null) {


Input:
private void updateDate() {
    baseDate = new GregorianCalendar();
    baseDate.add(Calendar.DAY_OF_YEAR, -(dataOffset - 1) * 7);
    nDays = (nColumns - 1) * 7;
    todayWeekday = new GregorianCalendar().get(Calendar.DAY_OF_WEEK) % 7;
    baseDate.add(Calendar.DAY_OF_YEAR, -nDays);
    baseDate.add(Calendar.DAY_OF_YEAR, -todayWeekday);
}

Output:
     baseDate = new GregorianCalendar();
-    baseDate.add(Calendar.DAY_OF_YEAR, -(dataOffset - 1) * 7);
+    baseDate.add(Calendar.DAY_OF_YEAR, -(getDataOffset() - 1) * 7);
     nDays = (nColumns - 1) * 7;


Input:
public int size() {
    return initialNode.distanceToEnd() + 1;
}

Output:
 public int size() {
-    return initialNode.distanceToEnd() + 1;
+    return initialNode.distanceToEnd();
 }


Input:
public ByteBuffer getByteBuffer() throws IOException {
    return fileUpload.getByteBuf().nioBuffer();
}

Output:
 public ByteBuffer getByteBuffer() throws IOException {
-    return fileUpload.getByteBuf().nioBuffer();
+    ByteBuf byteBuf = fileUpload.getByteBuf();
+    try {
+        return byteBuf.nioBuffer();
+    } finally {
+        byteBuf.release();
+    }
 }


Input:
public void create() {
    ConnInstanceTO connectorTO = new ConnInstanceTO();
    connectorTO.setVersion(connidSoapVersion);
    connectorTO.setConnectorName(WebServiceConnector.class.getName());
    connectorTO.setBundleName("String_Node_Str");
    connectorTO.setDisplayName("String_Node_Str");
    Set<ConnConfProperty> conf = new HashSet<ConnConfProperty>();
    ConnConfPropSchema endpointSchema = new ConnConfPropSchema();
    endpointSchema.setName("String_Node_Str");
    endpointSchema.setType(String.class.getName());
    endpointSchema.setRequired(true);
    ConnConfProperty endpoint = new ConnConfProperty();
    endpoint.setSchema(endpointSchema);
    endpoint.setValues(Collections.singletonList("String_Node_Str"));
    ConnConfPropSchema servicenameSchema = new ConnConfPropSchema();
    servicenameSchema.setName("String_Node_Str");
    servicenameSchema.setType(String.class.getName());
    servicenameSchema.setRequired(true);
    ConnConfProperty servicename = new ConnConfProperty();
    servicename.setSchema(servicenameSchema);
    servicename.setValues(Collections.singletonList("String_Node_Str"));
    conf.add(endpoint);
    conf.add(servicename);
    connectorTO.setConfiguration(conf);
    connectorTO.addCapability(ConnectorCapability.ASYNC_CREATE);
    connectorTO.addCapability(ConnectorCapability.SYNC_CREATE);
    connectorTO.addCapability(ConnectorCapability.ASYNC_UPDATE);
    ConnInstanceTO actual = restTemplate.postForObject(BASE_URL + "String_Node_Str", connectorTO, ConnInstanceTO.class);
    assertNotNull(actual);
    assertEquals(actual.getBundleName(), connectorTO.getBundleName());
    assertEquals(actual.getConnectorName(), connectorTO.getConnectorName());
    assertEquals(actual.getVersion(), connectorTO.getVersion());
    assertEquals("String_Node_Str", actual.getDisplayName());
    assertEquals(connectorTO.getCapabilities(), actual.getCapabilities());
    Throwable t = null;
    connectorTO.setId(actual.getId());
    connectorTO.removeCapability(ConnectorCapability.ASYNC_UPDATE);
    actual = null;
    try {
        actual = restTemplate.postForObject(BASE_URL + "String_Node_Str", connectorTO, ConnInstanceTO.class);
    } catch (HttpStatusCodeException e) {
        LOG.error("String_Node_Str", e);
        t = e;
    }
    assertNull(t);
    assertNotNull(actual);
    assertEquals(connectorTO.getCapabilities(), actual.getCapabilities());
    try {
        restTemplate.delete(BASE_URL + "String_Node_Str", actual.getId().toString());
    } catch (HttpStatusCodeException e) {
        LOG.error("String_Node_Str", e);
        t = e;
    }
    assertNull(t);
    try {
        restTemplate.getForObject(BASE_URL + "String_Node_Str", ConnInstanceTO.class, actual.getId().toString());
    } catch (HttpStatusCodeException e) {
        assertEquals(e.getStatusCode(), HttpStatus.NOT_FOUND);
    }
}

Output:
     connectorTO.setConfiguration(conf);
-    connectorTO.addCapability(ConnectorCapability.ASYNC_CREATE);
-    connectorTO.addCapability(ConnectorCapability.SYNC_CREATE);
-    connectorTO.addCapability(ConnectorCapability.ASYNC_UPDATE);
+    connectorTO.addCapability(ConnectorCapability.TWO_PHASES_CREATE);
+    connectorTO.addCapability(ConnectorCapability.ONE_PHASE_CREATE);
+    connectorTO.addCapability(ConnectorCapability.TWO_PHASES_UPDATE);
     ConnInstanceTO actual = restTemplate.postForObject(BASE_URL + "String_Node_Str", connectorTO, ConnInstanceTO.class);


Input:
public void testLike() {
    String[] script = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    boolean[] result = new boolean[] { true, true, true, true, true, false, false, false, true, false, true, false, false };
    for (int i = 0; i < script.length; i++) {
        assertTrue(((Boolean) cx.evaluateString(scope, script[i], "String_Node_Str", 1, null)).booleanValue() == result[i]);
    }
}

Output:
     String[] script = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
-    boolean[] result = new boolean[] { true, true, true, true, true, false, false, false, true, false, true, false, false };
+    boolean[] result = new boolean[] { true, true, true, true, true, false, false, false, true, false, true, false, true };
     for (int i = 0; i < script.length; i++) {


Input:
public void parse() {
    if (zipBtn.getSelection()) {
        zipfile = zip.getText().getText();
        importFolder = System.getProperty("String_Node_Str") + "String_Node_Str";
        try {
            ZipToFile.unZipFile(zipfile, importFolder);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    if (folderBtn.getSelection()) {
        importFolder = folder.getText().getText();
    }
    try {
        FileReader reader = new FileReader(importFolder + "String_Node_Str");
        Exports exports = (Exports) Unmarshaller.unmarshal(Exports.class, reader);
        TreeParent reserverRoot = new TreeParent(serverRoot.getDisplayName(), null, TreeObject._SERVER_, serverRoot.getWsKey(), serverRoot.getWsObject());
        reserverRoot.setUser(serverRoot.getUser());
        TreeParent clusters = new TreeParent(EXtentisObjects.DataCluster.getDisplayName(), reserverRoot, TreeObject.DATA_CLUSTER, null, null);
        TreeParent models = new TreeParent(EXtentisObjects.DataMODEL.getDisplayName(), reserverRoot, TreeObject.DATA_MODEL, null, null);
        TreeParent menus = new TreeParent(EXtentisObjects.Menu.getDisplayName(), reserverRoot, TreeObject.MENU, null, null);
        TreeParent roles = new TreeParent(EXtentisObjects.Role.getDisplayName(), reserverRoot, TreeObject.ROLE, null, null);
        TreeParent routingrules = new TreeParent(EXtentisObjects.RoutingRule.getDisplayName(), reserverRoot, TreeObject.ROUTING_RULE, null, null);
        TreeParent storeprocedures = new TreeParent(EXtentisObjects.StoredProcedure.getDisplayName(), reserverRoot, TreeObject.STORED_PROCEDURE, null, null);
        TreeParent syncplans = new TreeParent(EXtentisObjects.SynchronizationPlan.getDisplayName(), reserverRoot, TreeObject.SYNCHRONIZATIONPLAN, null, null);
        TreeParent transformers = new TreeParent(EXtentisObjects.Transformer.getDisplayName(), reserverRoot, TreeObject.TRANSFORMER, null, null);
        TreeParent universes = new TreeParent(EXtentisObjects.Universe.getDisplayName(), reserverRoot, TreeObject.UNIVERSE, null, null);
        TreeParent views = new TreeParent(EXtentisObjects.View.getDisplayName(), reserverRoot, TreeObject.VIEW, null, null);
        reserverRoot.addChild(clusters);
        reserverRoot.addChild(models);
        reserverRoot.addChild(menus);
        reserverRoot.addChild(roles);
        reserverRoot.addChild(routingrules);
        reserverRoot.addChild(storeprocedures);
        reserverRoot.addChild(syncplans);
        reserverRoot.addChild(transformers);
        reserverRoot.addChild(universes);
        reserverRoot.addChild(views);
        boolean isOverrideAll = false;
        for (TreeObject obj : exports.getItems()) {
            obj.setServerRoot(reserverRoot);
            switch(obj.getType()) {
                case TreeObject.DATA_CLUSTER:
                    if (port.getDataCluster(new WSGetDataCluster(new WSDataClusterPK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    clusters.addChild(obj);
                    break;
                case TreeObject.DATA_MODEL:
                    if (port.getDataModel(new WSGetDataModel(new WSDataModelPK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    models.addChild(obj);
                    break;
                case TreeObject.MENU:
                    if (port.getMenu(new WSGetMenu(new WSMenuPK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    menus.addChild(obj);
                    break;
                case TreeObject.ROLE:
                    if (port.getRole(new WSGetRole(new WSRolePK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    roles.addChild(obj);
                    break;
                case TreeObject.ROUTING_RULE:
                    if (port.getRoutingRule(new WSGetRoutingRule(new WSRoutingRulePK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    routingrules.addChild(obj);
                    break;
                case TreeObject.STORED_PROCEDURE:
                    if (port.getStoredProcedure(new WSGetStoredProcedure(new WSStoredProcedurePK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    storeprocedures.addChild(obj);
                    break;
                case TreeObject.SYNCHRONIZATIONPLAN:
                    if (port.getSynchronizationPlan(new WSGetSynchronizationPlan(new WSSynchronizationPlanPK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    syncplans.addChild(obj);
                    break;
                case TreeObject.TRANSFORMER:
                    if (port.getTransformer(new WSGetTransformer(new WSTransformerPK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    transformers.addChild(obj);
                    break;
                case TreeObject.UNIVERSE:
                    if (port.getUniverse(new WSGetUniverse(new WSUniversePK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    universes.addChild(obj);
                    break;
                case TreeObject.VIEW:
                    if (port.getView(new WSGetView(new WSViewPK(obj.getDisplayName()))) != null) {
                        if (!isOverrideAll) {
                            int result = isOveride(obj.getDisplayName());
                            if (result == IDialogConstants.CANCEL_ID) {
                                return;
                            }
                            if (result == IDialogConstants.YES_TO_ALL_ID) {
                                isOverrideAll = true;
                            }
                            if (result == IDialogConstants.NO_ID) {
                                break;
                            }
                        }
                    }
                    views.addChild(obj);
                    break;
                default:
                    if (obj.getItems().length > 0) {
                        for (int i = 0; i < obj.getItems().length; i++) {
                            if (obj.getItems()[i].split("String_Node_Str")[1] != null)
                                dataClusterContent.put(obj.getItems()[i].split("String_Node_Str")[1], obj.getItems());
                        }
                    }
            }
        }
        treeViewer.setRoot(reserverRoot);
        treeViewer.getViewer().setInput(view.getSite());
        treeViewer.setCheckItems(Arrays.asList(exports.getItems()));
        GridData gd = (GridData) treeViewer.getViewer().getControl().getLayoutData();
        gd.heightHint = 300;
        treeViewer.getViewer().getControl().getParent().layout(true);
        treeViewer.getViewer().getControl().getShell().layout(true);
    } catch (Exception e) {
    }
}

Output:
                 case TreeObject.DATA_CLUSTER:
-                    if (port.getDataCluster(new WSGetDataCluster(new WSDataClusterPK(obj.getDisplayName()))) != null) {
+                    if (port.existsDataCluster(new WSExistsDataCluster(new WSDataClusterPK(obj.getDisplayName()))).is_true()) {
                         if (!isOverrideAll) {


Input:
protected int getWizardWidth() {
    return 600;
}

Output:
 protected int getWizardWidth() {
-    return 600;
+    return 780;
 }


Input:
protected boolean matchMediaTypes(Link link) {
    if (link.getMediaTypes().size() != 0 && mediaTypes.size() != 0) {
        Set<String> linkMediaTypes = new HashSet<String>();
        for (MediaType type : link.getMediaTypes()) {
            linkMediaTypes.add(type.getValue());
        }
        for (String typeValue : mediaTypes) {
            if (!linkMediaTypes.contains(typeValue)) {
                return false;
            }
        }
    }
    return true;
}

Output:
 protected boolean matchMediaTypes(Link link) {
-    if (link.getMediaTypes().size() != 0 && mediaTypes.size() != 0) {
+    if (mediaTypes.size() != 0) {
         Set<String> linkMediaTypes = new HashSet<String>();


Input:
public final void sendSipTermination(final JingleIQ iq, final CallSession callSession) {
    try {
        JID from;
        Message lastResponse = callSession.getLastSentResponse();
        if (lastResponse != null && lastResponse.getContactHeader() != null) {
            from = Participants.getFromJidForResponse(lastResponse);
            if (sipToJingleBind != null) {
                from = sipToJingleBind.getXmppTo(from, callSession.getLastReceivedJingle());
            }
            if (!from.toBareJID().equals(iq.getFrom().toBareJID())) {
                lastResponse = null;
            }
            if (sipToJingleBind != null) {
                iq.setFrom(sipToJingleBind.getSipFrom(iq.getFrom()));
            }
        }
        if (lastResponse != null && (lastResponse.isRinging() || lastResponse.isTrying())) {
            if (iq.getJingle().getReason() != null && iq.getJingle().getReason().getType().equals(Reason.Type.media_error)) {
                lastResponse.setStatusLine(new StatusLine(415, "String_Node_Str"));
            } else {
                lastResponse.setStatusLine(new StatusLine(480, "String_Node_Str"));
            }
            gatewayRouter.routeSIP(lastResponse, callSession.getUser());
        } else {
            lastResponse = callSession.getLastReceivedResponse();
            final Message lastSentRequest = callSession.getLastSentRequest();
            if (lastResponse == null || (lastResponse.isRinging() || lastResponse.isTrying())) {
                Message message = callSession.getLastSentRequest();
                if (message == null) {
                    message = callSession.getLastReceivedRequest();
                }
                if (message == null) {
                    message = callSession.getLastMessage();
                }
                final Message cancel = SipProcessor.createSipCancel(message);
                cancel.setSendTo(lastSentRequest.getSendTo());
                cancel.setArrivedAt(lastSentRequest.getArrivedAt());
                callSession.addSentRequest(cancel);
                callSession.setRetries(2);
                gatewayRouter.routeSIP(cancel, callSession.getUser());
            } else {
                final Message bye = SipProcessor.createSipBye(iq, sipProviderInfo, lastResponse, callSession);
                Message msg = lastSentRequest;
                if (msg == null) {
                    msg = callSession.getLastReceivedRequest();
                    if (msg == null) {
                        log.debug("String_Node_Str");
                    }
                }
                if (msg == null) {
                    log.warn("String_Node_Str");
                    return;
                }
                bye.setSendTo(msg.getSendTo());
                bye.setArrivedAt(msg.getArrivedAt());
                gatewayRouter.routeSIP(bye, callSession.getUser());
                final ContactHeader contact = msg.getContactHeader();
                if (contact != null) {
                    final SipURL url = contact.getNameAddress().getAddress();
                    if (url.getHost() != null && url.getPort() > 0 && url.getPort() < 70000) {
                        gatewayRouter.routeSIP(bye, callSession.getUser());
                        gatewayRouter.routeSIP(bye, callSession.getUser());
                    }
                }
            }
        }
    } catch (JingleSipException e) {
        log.warn("String_Node_Str", e);
    } catch (SipParsingException e) {
        log.warn("String_Node_Str", e);
    }
}

Output:
             }
-            if (sipToJingleBind != null) {
+            if (sipToJingleBind != null && sipToJingleBind.getSipFrom(iq.getFrom()) != null) {
                 iq.setFrom(sipToJingleBind.getSipFrom(iq.getFrom()));


Input:
public ShortPoint2D findTarget(AiPositions playerBorder, ShortPoint2D center) {
    if (aiStatistics.resourceCountInDefaultPartition(resourceType) == 0)
        return null;
    int factor = aiStatistics.getTotalNumberOfBuildingTypeForPlayer(mineBuildingType, playerId) + 1;
    int tiles = mineBuildingType.getProtectedTiles().length * 2;
    if (aiStatistics.resourceCountOfPlayer(resourceType, playerId) > tiles * factor)
        return null;
    ShortPoint2D nearestResourceAbroad = aiStatistics.getNearestResourcePointInDefaultPartitionFor(center, resourceType, searchDistance);
    if (nearestResourceAbroad == null)
        return null;
    ShortPoint2D target = playerBorder.getNearestPoint(nearestResourceAbroad, searchDistance);
    return target;
}

Output:
         return null;
-    ShortPoint2D nearestResourceAbroad = aiStatistics.getNearestResourcePointInDefaultPartitionFor(center, resourceType, searchDistance);
+    ShortPoint2D nearestResourceAbroad = aiStatistics.getNearestResourcePointInDefaultPartitionFor(center, resourceType, searchDistance, sourroundedByResourceFilter);
     if (nearestResourceAbroad == null)


Input:
private static byte[] textToNumericFormatV4(String ipString) {
    if (ipString.contains("String_Node_Str")) {
        return null;
    }
    String[] address = ipString.split("String_Node_Str");
    if (address.length != IPV4_PART_COUNT) {
        return null;
    }
    byte[] bytes = new byte[IPV4_PART_COUNT];
    try {
        for (int i = 0; i < bytes.length; i++) {
            int piece = Integer.parseInt(address[i]);
            if (piece < 0 || piece > 255) {
                return null;
            }
            if (address[i].startsWith("String_Node_Str") && address[i].length() != 1) {
                return null;
            }
            bytes[i] = (byte) piece;
        }
    } catch (NumberFormatException ex) {
        return null;
    }
    return bytes;
}

Output:
     }
-    String[] address = ipString.split("String_Node_Str");
+    String[] address = ipString.split("String_Node_Str", IPV4_PART_COUNT + 1);
     if (address.length != IPV4_PART_COUNT) {


Input:
private static void triggerPathwayLoading() {
    if (GeneralManager.get().getUseCase(EDataDomain.GENETIC_DATA) != null) {
        new PathwayLoadingProgressIndicatorAction().run(null);
    }
}

Output:
 private static void triggerPathwayLoading() {
-    if (GeneralManager.get().getUseCase(EDataDomain.GENETIC_DATA) != null) {
-        new PathwayLoadingProgressIndicatorAction().run(null);
-    }
+    new PathwayLoadingProgressIndicatorAction().run(null);
 }


Input:
public FieldPanel setNewModel(final List<Serializable> list) {
    setNewModel(new Model() {
        private static final long serialVersionUID = 527651414610325237L;
        final DateFormat formatter = new SimpleDateFormat(datePattern);

        public Serializable getObject() {
            Date date = null;
            if (list != null && !list.isEmpty() && StringUtils.hasText(list.get(0).toString())) {
                try {
                    date = formatter.parse(list.get(0).toString());
                } catch (ParseException e) {
                    LOG.error("String_Node_Str", e);
                }
            }
            return date;
        }
        public void setObject(Serializable object) {
            if (object != null) {
                list.clear();
                list.add((String) formatter.format((Date) object));
            }
        }
    });
    return this;
}

Output:
         private static final long serialVersionUID = 527651414610325237L;
-        final DateFormat formatter = new SimpleDateFormat(datePattern);
+        private final DateFormat formatter = new SimpleDateFormat(datePattern);


Input:
public void testExceptionCase() {
    try {
        String invalidURLFile = "String_Node_Str";
        InputStream is = getSchemaInputStream(invalidURLFile);
        List types = xsdHelper.define(is, getSchemaLocation());
    } catch (org.eclipse.persistence.exceptions.SDOException ex) {
    }
}

Output:
         List types = xsdHelper.define(is, getSchemaLocation());
-    } catch (org.eclipse.persistence.exceptions.SDOException ex) {
+    } catch (Exception ex) {
     }


Input:
protected ProteusView buildImpl(ParserContext context, final ProteusView parent, final JsonObject layout, View existingView, final int childIndex, Styles styles) {
    JsonElement viewTypeElement = layout.get(ProteusConstants.TYPE);
    String viewType;
    if (viewTypeElement != null) {
        viewType = viewTypeElement.getAsString();
    } else {
        Log.e(TAG, "String_Node_Str");
        return null;
    }
    LayoutHandler<View> handler = layoutHandlers.get(viewType);
    if (handler == null) {
        return onUnknownViewEncountered(context, viewType, parent, layout, childIndex);
    }
    final View createdView;
    if (existingView == null) {
        ViewGroup parentViewGroup = (ViewGroup) parent.getView();
        createdView = createView(context, parentViewGroup, handler, layout);
        handler.setupView(context, parentViewGroup, createdView, layout);
    } else {
        createdView = existingView;
    }
    ProteusView createdProteusView = createProteusViewToReturn(createdView, layout, childIndex, parent);
    prepareView(createdProteusView, context);
    for (Map.Entry<String, JsonElement> entry : layout.entrySet()) {
        if (ProteusConstants.TYPE.equals(entry.getKey()) || ProteusConstants.CHILDREN.equals(entry.getKey()) || ProteusConstants.CHILD_TYPE.equals(entry.getKey()) || ProteusConstants.STYLE.equals(entry.getKey())) {
            continue;
        }
        JsonElement jsonDataValue = entry.getValue();
        String attributeName = entry.getKey();
        boolean handled;
        handled = handleAttribute(handler, context, attributeName, jsonDataValue, layout, createdProteusView, parent, childIndex);
        if (!handled) {
            onUnknownAttributeEncountered(context, attributeName, jsonDataValue, layout, createdView, childIndex);
        }
    }
    if (styles != null && layout.has(ProteusConstants.STYLE) && !layout.get(ProteusConstants.STYLE).isJsonNull() && layout.get(ProteusConstants.STYLE).isJsonPrimitive()) {
        String[] styleSet = layout.get(ProteusConstants.STYLE).getAsString().split(ProteusConstants.STYLE_DELIMITER);
        for (String styleName : styleSet) {
            processStyle(styles.getStyle(styleName), layout, createdProteusView, handler, context, parent, childIndex);
        }
    }
    List<ProteusView> childrenToAdd = parseChildren(handler, context, createdProteusView, layout, childIndex, styles);
    if (childrenToAdd == null) {
        return createdProteusView;
    }
    if (childrenToAdd.size() > 0) {
        handler.addChildren(context, createdProteusView, childrenToAdd, layout);
    }
    return createdProteusView;
}

Output:
         for (String styleName : styleSet) {
-            processStyle(styles.getStyle(styleName), layout, createdProteusView, handler, context, parent, childIndex);
+            if (styles.hasStyle(styleName)) {
+                processStyle(styles.getStyle(styleName), layout, createdProteusView, handler, context, parent, childIndex);
+            }
         }


Input:
List<RolapStar.Measure> getDistinctSqlMeasures(List<RolapStar.Measure> measuresList) {
    List<RolapStar.Measure> distinctSqlMeasureList = new ArrayList<RolapStar.Measure>();
    for (RolapStar.Measure measure : measuresList) {
        if (measure.getAggregator().isDistinct() && measure.getExpression() instanceof MondrianDef.MeasureExpression) {
            distinctSqlMeasureList.add(measure);
        }
    }
    return distinctSqlMeasureList;
}

Output:
         if (measure.getAggregator().isDistinct() && measure.getExpression() instanceof MondrianDef.MeasureExpression) {
-            distinctSqlMeasureList.add(measure);
+            MondrianDef.MeasureExpression measureExpr = (MondrianDef.MeasureExpression) measure.getExpression();
+            MondrianDef.SQL measureSql = measureExpr.expressions[0];
+            if (measureSql.cdata.toUpperCase().contains("String_Node_Str")) {
+                distinctSqlMeasureList.add(measure);
+            }
         }


Input:
private void getMetaUsingPolicy0() {
    java.sql.ResultSetMetaData resultmd;
    try {
        resultmd = preStat.getMetaData();
        this.cachedResultMetaData = new ResultSetMetaData(resultmd);
    } catch (Throwable e) {
    }
}

Output:
         resultmd = preStat.getMetaData();
-        this.cachedResultMetaData = new ResultSetMetaData(resultmd);
+        if (resultmd != null)
+            this.cachedResultMetaData = new ResultSetMetaData(resultmd);
     } catch (Throwable e) {


Input:
public static Format getAssociatedFormat(final String filename) {
    for (Format format : formats) {
        if (format.match(filename)) {
            LOGGER.trace("String_Node_Str" + format + "String_Node_Str" + filename + "String_Node_Str");
            return format.duplicate();
        }
    }
    LOGGER.trace("String_Node_Str" + filename + "String_Node_Str");
    return null;
}

Output:
 public static Format getAssociatedFormat(final String filename) {
-    for (Format format : formats) {
-        if (format.match(filename)) {
-            LOGGER.trace("String_Node_Str" + format + "String_Node_Str" + filename + "String_Node_Str");
-            return format.duplicate();
+    formatsLock.readLock().lock();
+    try {
+        for (Format format : formats) {
+            if (format.match(filename)) {
+                LOGGER.trace("String_Node_Str" + format + "String_Node_Str" + filename + "String_Node_Str");
+                return format.duplicate();
+            }
         }


Input:
private ClusterStatus getClusterStatus(Map<String, ClusterDataHolder> clusterData) {
    ClusterStatus status = null;
    boolean clusterActive = false;
    boolean clusterTerminated = false;
    for (Map.Entry<String, ClusterDataHolder> clusterDataHolderEntry : clusterData.entrySet()) {
        Service service = TopologyManager.getTopology().getService(clusterDataHolderEntry.getValue().getServiceType());
        Cluster cluster = service.getCluster(clusterDataHolderEntry.getValue().getClusterId());
        if (cluster.getStatus() == ClusterStatus.Active) {
            clusterActive = true;
            clusterTerminated = false;
        } else if (cluster.getStatus() == ClusterStatus.Inactive) {
            status = ClusterStatus.Inactive;
            clusterActive = false;
            clusterTerminated = false;
            break;
        } else if (cluster.getStatus() == ClusterStatus.Terminated) {
            clusterActive = false;
            clusterTerminated = true;
        } else if (cluster.getStatus() == ClusterStatus.Terminating) {
            status = ClusterStatus.Terminating;
            clusterActive = false;
            clusterTerminated = false;
        } else if (cluster.getStatus() == ClusterStatus.Created) {
            status = ClusterStatus.Created;
            clusterActive = false;
            clusterTerminated = false;
        }
    }
    if (clusterActive) {
        status = ClusterStatus.Active;
    } else if (clusterTerminated) {
        status = ClusterStatus.Terminated;
    }
    return status;
}

Output:
     ClusterStatus status = null;
-    boolean clusterActive = false;
-    boolean clusterTerminated = false;
+    boolean clusterActive = true;
+    boolean clusterTerminated = true;
     for (Map.Entry<String, ClusterDataHolder> clusterDataHolderEntry : clusterData.entrySet()) {


Input:
final protected VM_Address allocSlowOnce(int bytes, int align, int offset, boolean inGC) {
    int header = superPageHeaderSize() + cellHeaderSize();
    int pages = (getMaximumAlignedSize(bytes + header, align) + BYTES_IN_PAGE - 1) >> LOG_BYTES_IN_PAGE;
    VM_Address sp = allocSuperPage(pages);
    if (sp.isZero())
        return sp;
    VM_Address cell = alignAllocation(sp.add(header), align, offset);
    Memory.zero(cell, VM_Extent.fromIntZeroExtend(bytes));
    return cell;
}

Output:
     int header = superPageHeaderSize() + cellHeaderSize();
-    int pages = (getMaximumAlignedSize(bytes + header, align) + BYTES_IN_PAGE - 1) >> LOG_BYTES_IN_PAGE;
+    int maxbytes = getMaximumAlignedSize(bytes + header, align);
+    int pages = (maxbytes + BYTES_IN_PAGE - 1) >> LOG_BYTES_IN_PAGE;
     VM_Address sp = allocSuperPage(pages);


Input:
private void cleanup() {
    try {
        if (this.session.get() != null) {
            this.session.clear();
        }
        this.delegate = null;
        if (this.em != null) {
            this.em.close();
        }
        this.em = null;
    } finally {
        outstanding.remove(this.txUuid);
    }
}

Output:
     try {
-        if (this.session.get() != null) {
+        if (this.session != null && this.session.get() != null) {
             this.session.clear();


Input:
public void onReceivedIcon(WebView view, Bitmap icon) {
    final String url = view.getUrl();
    if (TextUtils.isEmpty(url)) {
        return;
    }
    final Bitmap refinedBitmap = FavIconUtils.getRefinedBitmap(view.getResources(), icon, FavIconUtils.getRepresentativeCharacter(url));
    final Site site = new Site();
    site.setTitle(view.getTitle());
    site.setUrl(url);
    site.setFavIcon(refinedBitmap);
    BrowsingHistoryManager.getInstance().updateLastEntry(site, null);
    if (this.tabChromeClient != null) {
        this.tabChromeClient.onReceivedIcon(view, refinedBitmap);
    }
}

Output:
     if (this.tabChromeClient != null) {
-        this.tabChromeClient.onReceivedIcon(view, refinedBitmap);
+        this.tabChromeClient.onReceivedIcon(view, icon);
     }


Input:
public void saveToEmf(EList contextTypeList) {
    if (contextTypeList == null) {
        return;
    }
    if (listContext.isEmpty()) {
        retrieveDefaultContext();
    }
    EList newcontextTypeList = new BasicEList();
    for (int i = 0; i < listContext.size(); i++) {
        IContext context = listContext.get(i);
        String contextGroupName = context.getName();
        ContextType contextType = findContextType(contextTypeList, contextGroupName);
        if (contextType == null) {
            contextType = TalendFileFactory.eINSTANCE.createContextType();
            contextType.setName(contextGroupName);
        }
        contextType.setConfirmationNeeded(context.isConfirmationNeeded());
        newcontextTypeList.add(contextType);
        EList contextTypeParamList = contextType.getContextParameter();
        List<IContextParameter> contextParameterList = context.getContextParameterList();
        EList newContextTypeParamList = new BasicEList();
        if (contextParameterList != null) {
            for (int j = 0; j < contextParameterList.size(); j++) {
                IContextParameter contextParam = contextParameterList.get(j);
                ContextParameterType contextParamType = findContextParameterType(contextTypeParamList, contextParam.getName());
                if (contextParamType == null) {
                    contextParamType = TalendFileFactory.eINSTANCE.createContextParameterType();
                    contextParamType.setName(contextParam.getName());
                }
                newContextTypeParamList.add(contextParamType);
                contextParamType.setPrompt(contextParam.getPrompt());
                contextParamType.setType(contextParam.getType());
                contextParamType.setRawValue(contextParam.getValue());
                contextParamType.setPromptNeeded(contextParam.isPromptNeeded());
                contextParamType.setComment(contextParam.getComment());
                if (!contextParam.isBuiltIn()) {
                    Item item = ContextUtils.getRepositoryContextItemById(contextParam.getSource());
                    if (item != null) {
                        contextParamType.setRepositoryContextId(item.getProperty().getId());
                    }
                }
            }
            contextTypeParamList.clear();
            contextTypeParamList.addAll(newContextTypeParamList);
        }
    }
    contextTypeList.clear();
    contextTypeList.addAll(newcontextTypeList);
}

Output:
         IContext context = listContext.get(i);
-        String contextGroupName = context.getName();
+        String contextGroupName = renameGroupContext.get(context);
+        if (contextGroupName == null) {
+            contextGroupName = context.getName();
+        }
         ContextType contextType = findContextType(contextTypeList, contextGroupName);


Input:
public void execute(MessageReceiver caller, String[] parameters) {
    CanaryToVanilla converter = new CanaryToVanilla();
    String world = Configuration.getServerConfig().getDefaultWorldName();
    world = world + "String_Node_Str";
    if (parameters.length > 1) {
        world = parameters[1];
    }
    if (converter.convert(world) == false) {
        caller.notice("String_Node_Str");
    } else {
        caller.message(Colors.YELLOW + "String_Node_Str");
    }
}

Output:
     }
-    if (converter.convert(world) == false) {
+    if (!converter.convert(world)) {
         caller.notice("String_Node_Str");


Input:
public void createControl(Composite parent) {
    initializeDialogUnits(parent);
    Composite workArea = new Composite(parent, SWT.NONE);
    setControl(workArea);
    workArea.setLayout(new GridLayout(2, false));
    workArea.setLayoutData(new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL));
    new Label(workArea, SWT.NONE).setText(UIText.GitCreateGeneralProjectPage_ProjectNameLabel);
    projectText = new Text(workArea, SWT.BORDER);
    GridDataFactory.fillDefaults().grab(true, false).applyTo(projectText);
    projectText.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            checkPage();
        }
    });
    new Label(workArea, SWT.NONE).setText(UIText.GitCreateGeneralProjectPage_DirLabel);
    directoryText = new Text(workArea, SWT.BORDER);
    directoryText.setEnabled(false);
    GridDataFactory.fillDefaults().grab(true, false).applyTo(directoryText);
    Dialog.applyDialogFont(workArea);
}

Output:
     projectText.addModifyListener(new ModifyListener() {
-        public void modifyText(ModifyEvent e) {
-            checkPage();
-        }
-    });
+            public void modifyText(ModifyEvent e) {
+                checkPage();
+            }
+        });
     new Label(workArea, SWT.NONE).setText(UIText.GitCreateGeneralProjectPage_DirLabel);


Input:
public TmfEventField[] extractItemFields() {
    if (fData != null)
        processData();
    return fColumnData;
}

Output:
         processData();
-    return fColumnData;
+    return Arrays.copyOf(fColumnData, fColumnData.length);
 }


Input:
public void removeSubscription(int tenantId, String type, String subscriptionAlias, String clusterId) {
    tenantIdToSubscriptionContext.removeSubscriptionContext(tenantId, type, subscriptionAlias);
    clusterIdToSubscription.removeSubscription(clusterId);
}

Output:
     tenantIdToSubscriptionContext.removeSubscriptionContext(tenantId, type, subscriptionAlias);
-    clusterIdToSubscription.removeSubscription(clusterId);
+    clusterIdToSubscription.removeSubscription(clusterId, subscriptionAlias);
 }


Input:
public ClusterResponse createClusterResponse(Cluster cluster, Boolean showCapacities) {
    ClusterResponse clusterResponse = new ClusterResponse();
    clusterResponse.setId(cluster.getId());
    clusterResponse.setName(cluster.getName());
    clusterResponse.setPodId(cluster.getPodId());
    clusterResponse.setZoneId(cluster.getDataCenterId());
    clusterResponse.setHypervisorType(cluster.getHypervisorType().toString());
    clusterResponse.setClusterType(cluster.getClusterType().toString());
    clusterResponse.setAllocationState(cluster.getAllocationState().toString());
    clusterResponse.setManagedState(cluster.getManagedState().toString());
    HostPodVO pod = ApiDBUtils.findPodById(cluster.getPodId());
    if (pod != null) {
        clusterResponse.setPodName(pod.getName());
    }
    DataCenterVO zone = ApiDBUtils.findZoneById(cluster.getDataCenterId());
    clusterResponse.setZoneName(zone.getName());
    if (showCapacities != null && showCapacities) {
        List<SummedCapacity> capacities = ApiDBUtils.getCapacityByClusterPodZone(null, null, cluster.getId());
        Set<CapacityResponse> capacityResponses = new HashSet<CapacityResponse>();
        float cpuOverprovisioningFactor = ApiDBUtils.getCpuOverprovisioningFactor();
        for (SummedCapacity capacity : capacities) {
            CapacityResponse capacityResponse = new CapacityResponse();
            capacityResponse.setCapacityType(capacity.getCapacityType());
            capacityResponse.setCapacityUsed(capacity.getUsedCapacity());
            if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_CPU) {
                capacityResponse.setCapacityTotal(new Long((long) (capacity.getTotalCapacity() * cpuOverprovisioningFactor)));
            } else if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED) {
                List<SummedCapacity> c = ApiDBUtils.findNonSharedStorageForClusterPodZone(null, null, cluster.getId());
                capacityResponse.setCapacityTotal(capacity.getTotalCapacity() - c.get(0).getTotalCapacity());
                capacityResponse.setCapacityUsed(capacity.getUsedCapacity() - c.get(0).getUsedCapacity());
            } else {
                capacityResponse.setCapacityTotal(capacity.getTotalCapacity());
            }
            if (capacityResponse.getCapacityTotal() != 0) {
                capacityResponse.setPercentUsed(s_percentFormat.format((float) capacityResponse.getCapacityUsed() / (float) capacityResponse.getCapacityTotal() * 100f));
            } else {
                capacityResponse.setPercentUsed(s_percentFormat.format(0L));
            }
            capacityResponses.add(capacityResponse);
        }
        capacityResponses.addAll(getStatsCapacityresponse(null, null, pod.getId(), pod.getDataCenterId()));
        clusterResponse.setCapacitites(new ArrayList<CapacityResponse>(capacityResponses));
    }
    clusterResponse.setObjectName("String_Node_Str");
    return clusterResponse;
}

Output:
         }
-        capacityResponses.addAll(getStatsCapacityresponse(null, null, pod.getId(), pod.getDataCenterId()));
+        capacityResponses.addAll(getStatsCapacityresponse(null, cluster.getId(), pod.getId(), pod.getDataCenterId()));
         clusterResponse.setCapacitites(new ArrayList<CapacityResponse>(capacityResponses));


Input:
public void hideAll() {
    hidePopup();
    startHideTimeout();
    this.state = false;
    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.TARGET);
    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.PAIRED);
    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.SOURCE);
}

Output:
     this.state = false;
-    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.TARGET);
-    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.PAIRED);
-    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.SOURCE);
+    ArrowBuilder.getBuilder().removeArrowsByType(gameId, ArrowBuilder.Type.TARGET);
+    ArrowBuilder.getBuilder().removeArrowsByType(gameId, ArrowBuilder.Type.PAIRED);
+    ArrowBuilder.getBuilder().removeArrowsByType(gameId, ArrowBuilder.Type.SOURCE);
 }


Input:
public static String signature(String... para) {
    Arrays.sort(para);
    StringBuilder sb = new StringBuilder();
    for (String str : para) {
        sb.append(str);
    }
    return DigestUtil.SHA1(sb.toString());
}

Output:
     Arrays.sort(para);
-    StringBuilder sb = new StringBuilder();
+    StringBuffer sb = new StringBuffer();
     for (String str : para) {


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    if (null == convertView) {
        convertView = LayoutInflater.from(parent.getContext()).inflate(R.layout.view_flip_frame, parent, false);
    }
    convertView.getLayoutParams().height = targetHeight;
    final Id frameId = getItem(position);
    final RxViewGroup rxVg = (RxViewGroup) convertView.findViewWithTag(RxViewGroup.TAG);
    if (null != rxVg) {
        rxVg.reset();
        updateIndefinitely(convertView, rxVg.bind(demo.getFlipVmm().get(flipId).map(new Func1<FlipViewModel, FrameViewModel>() {
            public FrameViewModel call(FlipViewModel flipVm) {
                return flipVm.frameVms.get(frameId);
            }
        })));
    } else {
        updateIndefinitely(convertView, demo.getFlipVmm().peek(flipId).map(new Func1<FlipViewModel, FrameViewModel>() {
            public FrameViewModel call(FlipViewModel flipVm) {
                return flipVm.frameVms.get(frameId);
            }
        }));
    }
    return convertView;
}

Output:
     final Id frameId = getItem(position);
-    final RxViewGroup rxVg = (RxViewGroup) convertView.findViewWithTag(RxViewGroup.TAG);
+    RxViewGroup rxVg = (RxViewGroup) convertView.findViewWithTag(RxViewGroup.TAG);
     if (null != rxVg) {