Input:
public byte[] exportMovie(DefineVideoStreamTag videoStream, MovieExportMode mode) throws IOException {
    SWF swf = videoStream.getSwf();
    HashMap<Integer, VideoFrameTag> frames = new HashMap<>();
    SWF.populateVideoFrames(videoStream.characterID, swf.tags, frames);
    if (frames.isEmpty()) {
        return SWFInputStream.BYTE_ARRAY_EMPTY;
    }
    ByteArrayOutputStream fos = new ByteArrayOutputStream();
    OutputStream tos = fos;
    FLVOutputStream flv = new FLVOutputStream(tos);
    flv.writeHeader(false, true);
    int horizontalAdjustment = 0;
    int verticalAdjustment = 0;
    for (int i = 0; i < frames.size(); i++) {
        VideoFrameTag tag = frames.get(i);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int frameType = 1;
        if ((videoStream.codecID == DefineVideoStreamTag.CODEC_VP6) || (videoStream.codecID == DefineVideoStreamTag.CODEC_VP6_ALPHA)) {
            SWFInputStream sis = new SWFInputStream(swf, tag.videoData.getRangeData());
            if (videoStream.codecID == DefineVideoStreamTag.CODEC_VP6_ALPHA) {
                sis.readUI24("String_Node_Str");
            }
            int frameMode = (int) sis.readUB(1, "String_Node_Str");
            if (frameMode == 0) {
                frameType = 1;
            } else {
                frameType = 2;
            }
            sis.readUB(6, "String_Node_Str");
            int marker = (int) sis.readUB(1, "String_Node_Str");
            if (frameMode == 0) {
                int version = (int) sis.readUB(5, "String_Node_Str");
                int version2 = (int) sis.readUB(2, "String_Node_Str");
                sis.readUB(1, "String_Node_Str");
                if (marker == 1 || version2 == 0) {
                    sis.readUI16("String_Node_Str");
                }
                int dim_y = sis.readUI8("String_Node_Str");
                int dim_x = sis.readUI8("String_Node_Str");
                sis.readUI8("String_Node_Str");
                sis.readUI8("String_Node_Str");
                horizontalAdjustment = (int) (dim_x * Math.ceil(((double) videoStream.width) / (double) dim_x)) - videoStream.width;
                verticalAdjustment = (int) (dim_y * Math.ceil(((double) videoStream.height) / (double) dim_y)) - videoStream.height;
            }
            SWFOutputStream sos = new SWFOutputStream(baos, swf.version);
            sos.writeUB(4, horizontalAdjustment);
            sos.writeUB(4, verticalAdjustment);
        }
        if (videoStream.codecID == DefineVideoStreamTag.CODEC_SORENSON_H263) {
            SWFInputStream sis = new SWFInputStream(swf, tag.videoData.getRangeData());
            sis.readUB(17, "String_Node_Str");
            sis.readUB(5, "String_Node_Str");
            sis.readUB(8, "String_Node_Str");
            int pictureSize = (int) sis.readUB(3, "String_Node_Str");
            if (pictureSize == 0) {
                sis.readUB(8, "String_Node_Str");
                sis.readUB(8, "String_Node_Str");
            }
            if (pictureSize == 1) {
                sis.readUB(16, "String_Node_Str");
                sis.readUB(16, "String_Node_Str");
            }
            int pictureType = (int) sis.readUB(2, "String_Node_Str");
            switch(pictureType) {
                case 0:
                    frameType = 1;
                    break;
                case 1:
                    frameType = 2;
                    break;
                case 2:
                    frameType = 3;
                    break;
            }
        }
        baos.write(tag.videoData.getRangeData());
        flv.writeTag(new FLVTAG((int) Math.floor(i * 1000.0 / swf.frameRate), new VIDEODATA(frameType, videoStream.codecID, baos.toByteArray())));
    }
    return fos.toByteArray();
}

Output:
     int verticalAdjustment = 0;
-    for (int i = 0; i < frames.size(); i++) {
-        VideoFrameTag tag = frames.get(i);
+    int[] frameNumArray = Helper.toIntArray(frames.keySet());
+    Arrays.sort(frameNumArray);
+    for (int i = 0; i < frameNumArray.length; i++) {
+        VideoFrameTag tag = frames.get(frameNumArray[i]);
         ByteArrayOutputStream baos = new ByteArrayOutputStream();


Input:
public void testFulltext() {
    BatchInserter inserter = new BatchInserterImpl(PATH);
    BatchInserterIndexProvider provider = new LuceneBatchInserterIndexProvider(inserter);
    String name = "String_Node_Str";
    BatchInserterIndex index = provider.nodeIndex(name, MapUtil.stringMap("String_Node_Str", "String_Node_Str"));
    long id1 = inserter.createNode(null);
    index.add(id1, MapUtil.map("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str"));
    long id2 = inserter.createNode(null);
    index.add(id2, MapUtil.map("String_Node_Str", "String_Node_Str"));
    index.flush();
    assertContains(index.get("String_Node_Str", "String_Node_Str"), id1);
    assertContains(index.query("String_Node_Str", "String_Node_Str"), id1);
    assertContains(index.query("String_Node_Str", "String_Node_Str"));
    assertContains(index.query("String_Node_Str", "String_Node_Str"), id1, id2);
    assertContains(index.query("String_Node_Str", "String_Node_Str"), id1);
    assertContains(index.get("String_Node_Str", "String_Node_Str"), id1);
    long id3 = inserter.createNode(null);
    index.add(id3, MapUtil.map("String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str" }));
    index.flush();
    assertContains(index.get("String_Node_Str", "String_Node_Str"), id3);
    assertContains(index.get("String_Node_Str", "String_Node_Str"), id3);
    provider.shutdown();
    inserter.shutdown();
    GraphDatabaseService db = new EmbeddedGraphDatabase(PATH);
    Index<Node> dbIndex = db.index().forNodes(name);
    Node node1 = db.getNodeById(id1);
    Node node2 = db.getNodeById(id2);
    assertContains(dbIndex.query("String_Node_Str", "String_Node_Str"), node1, node2);
    db.shutdown();
}

Output:
     String name = "String_Node_Str";
-    BatchInserterIndex index = provider.nodeIndex(name, MapUtil.stringMap("String_Node_Str", "String_Node_Str"));
+    BatchInserterIndex index = provider.nodeIndex(name, stringMap("String_Node_Str", "String_Node_Str"));
     long id1 = inserter.createNode(null);


Input:
private CursorWrapper wrapCursor(Uri uri, Cursor cursor) {
    String[] args = null;
    String snippetArgs = getQueryParameter(uri, SearchSnippetColumns.SNIPPET_ARGS_PARAM_KEY);
    if (snippetArgs != null) {
        args = snippetArgs.split("String_Node_Str");
    }
    String query = uri.getLastPathSegment();
    String startMatch = args != null && args.length > 0 ? args[0] : DEFAULT_SNIPPET_ARG_START_MATCH;
    String endMatch = args != null && args.length > 1 ? args[1] : DEFAULT_SNIPPET_ARG_END_MATCH;
    String ellipsis = args != null && args.length > 2 ? args[2] : DEFAULT_SNIPPET_ARG_ELLIPSIS;
    int maxTokens = args != null && args.length > 3 ? Integer.parseInt(args[3]) : DEFAULT_SNIPPET_ARG_MAX_TOKENS;
    CrossProcessCursor crossProcessCursor = getCrossProcessCursor(cursor);
    if (crossProcessCursor != null) {
        return new SnippetizingCursorWrapper(cursor, query, startMatch, endMatch, ellipsis, maxTokens);
    } else {
        return new SnippetizingCursorWrapper(matrixCursorFromCursor(cursor), query, startMatch, endMatch, ellipsis, maxTokens);
    }
}

Output:
     int maxTokens = args != null && args.length > 3 ? Integer.parseInt(args[3]) : DEFAULT_SNIPPET_ARG_MAX_TOKENS;
-    CrossProcessCursor crossProcessCursor = getCrossProcessCursor(cursor);
-    if (crossProcessCursor != null) {
-        return new SnippetizingCursorWrapper(cursor, query, startMatch, endMatch, ellipsis, maxTokens);
-    } else {
-        return new SnippetizingCursorWrapper(matrixCursorFromCursor(cursor), query, startMatch, endMatch, ellipsis, maxTokens);
-    }
+    return new SnippetizingCursorWrapper(cursor, query, startMatch, endMatch, ellipsis, maxTokens);
 }


Input:
public void testSort() {
    List unsorted = new ArrayList();
    unsorted.add(new Position(4));
    unsorted.add(new Position(1));
    unsorted.add(new Position(3));
    List sorted1 = new ArrayList();
    sorted1.addAll(unsorted);
    Collections.sort(sorted1);
    List sorted2 = new ArrayList();
    sorted2.addAll(unsorted);
    Collections.sort(sorted2, GlazedLists.beanPropertyComparator(Position.class, "String_Node_Str"));
    assertEquals(sorted1, sorted2);
}

Output:
     sorted2.addAll(unsorted);
-    Collections.sort(sorted2, GlazedLists.beanPropertyComparator(Position.class, "String_Node_Str"));
+    Collections.sort(sorted2, GlazedLists.beanPropertyComparator(Position.class, "String_Node_Str", new String[0]));
     assertEquals(sorted1, sorted2);


Input:
private Composite build(final Composite parent) {
    final Composite mBase = new Composite(parent, SWT.NONE);
    mBase.setLayout(GridLayoutFactory.swtDefaults().numColumns(4).create());
    final Label mLabel = new Label(mBase, SWT.PUSH);
    mLabel.setText(Resources.getMessage("String_Node_Str"));
    GridData d2 = new GridData();
    d2.heightHint = LABEL_HEIGHT;
    d2.minimumHeight = LABEL_HEIGHT;
    mLabel.setLayoutData(d2);
    comboMetric = new Combo(mBase, SWT.READ_ONLY);
    GridData d30 = SWTUtil.createFillHorizontallyGridData();
    d30.verticalAlignment = SWT.CENTER;
    d30.horizontalSpan = 3;
    comboMetric.setLayoutData(d30);
    comboMetric.setItems(LABELS);
    comboMetric.select(0);
    comboMetric.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            if (comboMetric.getSelectionIndex() != -1) {
                selectMetricAction(METRICS.get(comboMetric.getSelectionIndex()));
            }
        }
    });
    final Label mLabel2 = new Label(mBase, SWT.PUSH);
    mLabel2.setText(Resources.getMessage("String_Node_Str"));
    GridData d22 = new GridData();
    d22.heightHint = LABEL_HEIGHT;
    d22.minimumHeight = LABEL_HEIGHT;
    mLabel2.setLayoutData(d22);
    monotonicVariant = new Button(mBase, SWT.CHECK);
    monotonicVariant.setText(Resources.getMessage("String_Node_Str"));
    monotonicVariant.setSelection(false);
    monotonicVariant.setEnabled(false);
    monotonicVariant.setLayoutData(GridDataFactory.swtDefaults().span(3, 1).create());
    monotonicVariant.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            model.getMetricConfiguration().setMonotonic(monotonicVariant.getSelection());
        }
    });
    final Label mLabel3 = new Label(mBase, SWT.PUSH);
    mLabel3.setText(Resources.getMessage("String_Node_Str"));
    GridData d23 = new GridData();
    d23.heightHint = LABEL_HEIGHT;
    d23.minimumHeight = LABEL_HEIGHT;
    mLabel3.setLayoutData(d23);
    comboAggregate = new Combo(mBase, SWT.NULL);
    GridData d31 = SWTUtil.createFillHorizontallyGridData();
    d31.verticalAlignment = SWT.CENTER;
    d31.horizontalSpan = 3;
    comboAggregate.setLayoutData(d31);
    comboAggregate.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            String selected = comboAggregate.getItem(comboAggregate.getSelectionIndex());
            for (AggregateFunction function : model.getMetricDescription().getSupportedAggregateFunctions()) {
                if (function.toString().equals(selected)) {
                    model.getMetricConfiguration().setAggregateFunction(function);
                }
            }
        }
    });
    return mBase;
}

Output:
     mLabel3.setLayoutData(d23);
-    comboAggregate = new Combo(mBase, SWT.NULL);
+    comboAggregate = new Combo(mBase, SWT.READ_ONLY);
     GridData d31 = SWTUtil.createFillHorizontallyGridData();


Input:
public synchronized void onResumeGame() {
    if (ResourcesManager.getInstance().settingsService.isMute()) {
        ResourcesManager.getInstance().musicService.muteMusic();
    }
    if (!(mEngine.getScene() instanceof GameScene) && !(mEngine.getScene() instanceof ScoreScreen)) {
        ResourcesManager.getInstance().musicService.playMusic();
    }
    levelInfoDataSource.open();
    super.onResumeGame();
}

Output:
     }
-    if (!(mEngine.getScene() instanceof GameScene) && !(mEngine.getScene() instanceof ScoreScreen)) {
+    if ((mEngine.getScene() instanceof MainMenuScene) || (mEngine.getScene() instanceof SettingsScene) || (mEngine.getScene() instanceof LevelChoiceScene)) {
         ResourcesManager.getInstance().musicService.playMusic();


Input:
private void addTwoDimensionalArray(String entityName, String attribName) {
    EClassifier finalType = null;
    if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = schemaPack.getEClassifier("String_Node_Str");
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = schemaPack.getEClassifier("String_Node_Str");
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = schemaPack.getEClassifier("String_Node_Str");
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = EcorePackage.eINSTANCE.getEInt();
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = EcorePackage.eINSTANCE.getEDouble();
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = schemaPack.getEClassifier("String_Node_Str");
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = schemaPack.getEClassifier("String_Node_Str");
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = schemaPack.getEClassifier("String_Node_Str");
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = EcorePackage.eINSTANCE.getEInt();
    } else if (entityName.equals("String_Node_Str") && attribName.equals("String_Node_Str")) {
        finalType = EcorePackage.eINSTANCE.getEInt();
    } else {
        System.out.println("String_Node_Str" + entityName + "String_Node_Str" + attribName);
    }
    EClass containerClass = (EClass) schemaPack.getEClassifier("String_Node_Str" + finalType.getName());
    if (containerClass == null) {
        containerClass = EcoreFactory.eINSTANCE.createEClass();
        containerClass.setName("String_Node_Str" + finalType.getName());
        if (finalType.getEPackage() == EcorePackage.eINSTANCE) {
            EAttribute finalAttribute = EcoreFactory.eINSTANCE.createEAttribute();
            finalAttribute.setName("String_Node_Str");
            finalAttribute.setEType(finalType);
            finalAttribute.setUpperBound(-1);
            containerClass.getEAttributes().add(finalAttribute);
        } else {
            EReference finalReference = EcoreFactory.eINSTANCE.createEReference();
            finalReference.setName("String_Node_Str");
            finalReference.setEType(finalType);
            finalReference.setUpperBound(-1);
            containerClass.getEReferences().add(finalReference);
        }
        schemaPack.getEClassifiers().add(containerClass);
    }
    EReference eReference = EcoreFactory.eINSTANCE.createEReference();
    eReference.getEAnnotations().add(createTwoDimensionalArrayAnnotation());
    eReference.setName(attribName);
    eReference.setUpperBound(-1);
    eReference.setEType(containerClass);
    EClass cls = (EClass) schemaPack.getEClassifier(entityName);
    cls.getEStructuralFeatures().add(eReference);
}

Output:
     } else {
-        System.out.println("String_Node_Str" + entityName + "String_Node_Str" + attribName);
+        throw new RuntimeException("String_Node_Str" + entityName + "String_Node_Str" + attribName);
     }


Input:
public void dataSent(int[] data) {
    if (connections.size() > 0) {
        for (int i = 0; i < data.length; i++) {
            buf[i] = (byte) data[i];
        }
        ConnectionThread[] cthr = connections.toArray(new ConnectionThread[connections.size()]);
        for (int i = 0; i < cthr.length; i++) {
            if (cthr[i].isClosed()) {
                connections.remove(cthr);
            } else {
                try {
                    cthr[i].output.write((byte) data.length);
                    cthr[i].output.write(buf);
                    if (DEBUG)
                        System.out.println("String_Node_Str" + data.length + "String_Node_Str");
                } catch (IOException e) {
                    e.printStackTrace();
                    cthr[i].close();
                }
            }
        }
    }
}

Output:
                     cthr[i].output.write((byte) data.length);
-                    cthr[i].output.write(buf);
-                    if (DEBUG)
+                    cthr[i].output.write(buf, 0, data.length);
+                    if (DEBUG) {
                         System.out.println("String_Node_Str" + data.length + "String_Node_Str");


Input:
public void testCorrectorCoefficients() {
    double[] coeffs1 = new AdamsMoultonIntegrator(1, 0.01).getCorrectorCoeffs();
    assertEquals(2, coeffs1.length);
    assertEquals(1.0 / 2.0, coeffs1[0], 1.0e-16);
    assertEquals(1.0 / 2.0, coeffs1[1], 1.0e-16);
    double[] coeffs2 = new AdamsMoultonIntegrator(2, 0.01).getCorrectorCoeffs();
    assertEquals(3, coeffs2.length);
    assertEquals(5.0 / 12.0, coeffs2[0], 1.0e-16);
    assertEquals(8.0 / 12.0, coeffs2[1], 1.0e-16);
    assertEquals(-1.0 / 12.0, coeffs2[2], 1.0e-16);
    double[] coeffs3 = new AdamsMoultonIntegrator(3, 0.01).getCorrectorCoeffs();
    assertEquals(4, coeffs3.length);
    assertEquals(9.0 / 24.0, coeffs3[0], 1.0e-16);
    assertEquals(19.0 / 24.0, coeffs3[1], 1.0e-16);
    assertEquals(-5.0 / 24.0, coeffs3[2], 1.0e-16);
    assertEquals(1.0 / 24.0, coeffs3[3], 1.0e-16);
    double[] coeffs4 = new AdamsMoultonIntegrator(4, 0.01).getCorrectorCoeffs();
    assertEquals(5, coeffs4.length);
    assertEquals(251.0 / 720.0, coeffs4[0], 1.0e-16);
    assertEquals(646.0 / 720.0, coeffs4[1], 1.0e-16);
    assertEquals(-264.0 / 720.0, coeffs4[2], 1.0e-16);
    assertEquals(106.0 / 720.0, coeffs4[3], 1.0e-16);
    assertEquals(-19.0 / 720.0, coeffs4[4], 1.0e-16);
    double[] coeffs5 = new AdamsMoultonIntegrator(5, 0.01).getCorrectorCoeffs();
    assertEquals(6, coeffs5.length);
    assertEquals(475.0 / 1440.0, coeffs5[0], 1.0e-16);
    assertEquals(1427.0 / 1440.0, coeffs5[1], 1.0e-16);
    assertEquals(-798.0 / 1440.0, coeffs5[2], 1.0e-16);
    assertEquals(482.0 / 1440.0, coeffs5[3], 1.0e-16);
    assertEquals(-173.0 / 1440.0, coeffs5[4], 1.0e-16);
    assertEquals(27.0 / 1440.0, coeffs5[5], 1.0e-16);
    double[] coeffs6 = new AdamsMoultonIntegrator(6, 0.01).getCorrectorCoeffs();
    assertEquals(7, coeffs6.length);
    assertEquals(19087.0 / 60480.0, coeffs6[0], 1.0e-16);
    assertEquals(65112.0 / 60480.0, coeffs6[1], 1.0e-16);
    assertEquals(-46461.0 / 60480.0, coeffs6[2], 1.0e-16);
    assertEquals(37504.0 / 60480.0, coeffs6[3], 1.0e-16);
    assertEquals(-20211.0 / 60480.0, coeffs6[4], 1.0e-16);
    assertEquals(6312.0 / 60480.0, coeffs6[5], 1.0e-16);
    assertEquals(-863.0 / 60480.0, coeffs6[6], 1.0e-16);
    double[] coeffs7 = new AdamsMoultonIntegrator(7, 0.01).getCorrectorCoeffs();
    assertEquals(8, coeffs7.length);
    assertEquals(36799.0 / 120960.0, coeffs7[0], 1.0e-16);
    assertEquals(139849.0 / 120960.0, coeffs7[1], 1.0e-16);
    assertEquals(-121797.0 / 120960.0, coeffs7[2], 1.0e-16);
    assertEquals(123133.0 / 120960.0, coeffs7[3], 1.0e-16);
    assertEquals(-88547.0 / 120960.0, coeffs7[4], 1.0e-16);
    assertEquals(41499.0 / 120960.0, coeffs7[5], 1.0e-16);
    assertEquals(-11351.0 / 120960.0, coeffs7[6], 1.0e-16);
    assertEquals(1375.0 / 120960.0, coeffs7[7], 1.0e-16);
    double[] coeffs8 = new AdamsMoultonIntegrator(8, 0.01).getCorrectorCoeffs();
    assertEquals(9, coeffs8.length);
    assertEquals(1070017.0 / 3628800.0, coeffs8[0], 1.0e-16);
    assertEquals(4467094.0 / 3628800.0, coeffs8[1], 1.0e-16);
    assertEquals(-4604594.0 / 3628800.0, coeffs8[2], 1.0e-16);
    assertEquals(5595358.0 / 3628800.0, coeffs8[3], 1.0e-16);
    assertEquals(-5033120.0 / 3628800.0, coeffs8[4], 1.0e-16);
    assertEquals(3146338.0 / 3628800.0, coeffs8[5], 1.0e-16);
    assertEquals(-1291214.0 / 3628800.0, coeffs8[6], 1.0e-16);
    assertEquals(312874.0 / 3628800.0, coeffs8[7], 1.0e-16);
    assertEquals(-33953.0 / 3628800.0, coeffs8[8], 1.0e-16);
}

Output:
 public void testCorrectorCoefficients() {
-    double[] coeffs1 = new AdamsMoultonIntegrator(1, 0.01).getCorrectorCoeffs();
+    double[] coeffs1 = new AdamsMoultonIntegrator(2, 0.01).getCorrectorCoeffs();
     assertEquals(2, coeffs1.length);


Input:
private void findEnd(final Iterator<Range> rangeIt, final Collection<Range> internalRanges, final Range seekRange) {
    while (rangeIt.hasNext()) {
        final Range internalRange = rangeIt.next();
        if (internalRange.getEndKey().compareTo(seekRange.getEndKey()) > 0) {
            if (internalRange.getStartKey().compareTo(seekRange.getEndKey()) > 0) {
                return;
            } else {
                internalRanges.add(new Range(internalRange.getStartKey(), seekRange.getEndKey()));
                return;
            }
        } else {
            internalRanges.add(internalRange);
        }
    }
}

Output:
         final Range internalRange = rangeIt.next();
-        if (internalRange.getEndKey().compareTo(seekRange.getEndKey()) > 0) {
-            if (internalRange.getStartKey().compareTo(seekRange.getEndKey()) > 0) {
+        if (internalRange.getEndKey() == null || internalRange.getEndKey().compareTo(seekRange.getEndKey()) > 0) {
+            if (internalRange.getStartKey() != null && internalRange.getStartKey().compareTo(seekRange.getEndKey()) > 0) {
                 return;


Input:
public void onSuccess(RtpEndPoint result) {
    System.out.println("String_Node_Str");
    RtpEndPoint stream = result;
    final Semaphore semCont = new Semaphore(0);
    try {
        stream.generateOffer(new Continuation<String>() {
            public void onSuccess(String result) {
                System.out.println("String_Node_Str" + result);
                semCont.release();
            }
            public void onError(Throwable cause) {
                System.out.println("String_Node_Str");
            }
        });
        Assert.assertTrue(semCont.tryAcquire(500, TimeUnit.MILLISECONDS));
        releaseMediaObject(stream);
        sem.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    } catch (KurentoMediaFrameworkException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
    try {
        stream.processOffer("String_Node_Str", new Continuation<String>() {
            public void onSuccess(String result) {
                System.out.println("String_Node_Str" + result);
                semCont.release();
            }
            public void onError(Throwable cause) {
                System.out.println("String_Node_Str");
            }
        });
        Assert.assertTrue(semCont.tryAcquire(500, TimeUnit.MILLISECONDS));
        releaseMediaObject(stream);
        sem.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    } catch (KurentoMediaFrameworkException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
    try {
        stream.processAnswer("String_Node_Str", new Continuation<String>() {
            public void onSuccess(String result) {
                System.out.println("String_Node_Str" + result);
                semCont.release();
            }
            public void onError(Throwable cause) {
                System.out.println("String_Node_Str");
            }
        });
        Assert.assertTrue(semCont.tryAcquire(500, TimeUnit.MILLISECONDS));
        releaseMediaObject(stream);
        sem.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    } catch (KurentoMediaFrameworkException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
    try {
        stream.getLocalSessionDescriptor(new Continuation<String>() {
            public void onSuccess(String result) {
                System.out.println("String_Node_Str" + result);
                semCont.release();
            }
            public void onError(Throwable cause) {
                System.out.println("String_Node_Str");
            }
        });
        Assert.assertTrue(semCont.tryAcquire(500, TimeUnit.MILLISECONDS));
        releaseMediaObject(stream);
        sem.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    } catch (KurentoMediaFrameworkException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
    try {
        stream.getRemoteSessionDescriptor(new Continuation<String>() {
            public void onSuccess(String result) {
                System.out.println("String_Node_Str" + result);
                semCont.release();
            }
            public void onError(Throwable cause) {
                System.out.println("String_Node_Str");
            }
        });
        Assert.assertTrue(semCont.tryAcquire(500, TimeUnit.MILLISECONDS));
        releaseMediaObject(stream);
        sem.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    } catch (KurentoMediaFrameworkException e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
}

Output:
         });
-        Assert.assertTrue(semCont.tryAcquire(500, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semCont.tryAcquire(5000, TimeUnit.MILLISECONDS));
         releaseMediaObject(stream);


Input:
private int getIndex(int k, int p) {
    if ((k & 1) != 0) {
        return (k >>> 6 & ((1 << p) - 1));
    } else {
        return (k >>> 1 & ((1 << p) - 1));
    }
}

Output:
     } else {
-        return (k >>> 1 & ((1 << p) - 1));
+        return (k >>> (1 + (sp - p)));
     }


Input:
public void onKeyDown(KeyDownEvent event) {
    final int keyCode = event.getNativeKeyCode();
    log.fine("String_Node_Str" + keyCode + "String_Node_Str" + event.getNativeEvent().getKeyCode());
    Selection selection = getTextArea().getDocument().getSelection();
    if (selection.getRangeCount() > 0) {
        Range range = selection.getRangeAt(0);
        OperationTarget t = getTarget(range);
        log.fine("String_Node_Str" + t);
        int pos = t.getStartOffset();
        List<Integer> path = t.getStartContainer();
        TreeOperation op = null;
        if (keyCode == 8) {
            if (pos == 0) {
                if (isNoteworthyPath(path)) {
                    op = new TreeMergeParagraph(clientJupiter.getSiteId(), path.get(0), 1, 1);
                    op.setPath(convertPath(path));
                }
            } else {
                pos = pos - 1;
                op = new TreeDeleteText(clientJupiter.getSiteId(), pos, convertPath(path));
            }
        } else if (keyCode == 46) {
            Text textNode = Text.as(TreeHelper.getChildNodeFromLocator(bodyNode, convertPath(t.getStartContainer())));
            if ((t.getStartOffset() == t.getEndOffset()) && (textNode.getLength() == t.getStartOffset())) {
                path.set(0, path.get(0) + 1);
                op = new TreeMergeParagraph(clientJupiter.getSiteId(), path.get(0), 1, 1);
            } else {
                op = new TreeDeleteText(clientJupiter.getSiteId(), pos, convertPath(path));
            }
        } else if (keyCode == 13) {
            if (pos == 0 && !isNoteworthyPath(path.subList(1, path.size()))) {
                op = new TreeNewParagraph(clientJupiter.getSiteId(), path.get(0));
                op.setPath(convertPath(path));
            } else {
                op = new TreeInsertParagraph(clientJupiter.getSiteId(), pos, convertPath(path));
            }
        }
        if (op != null) {
            clientJupiter.generate(op);
        }
    }
}

Output:
             if (pos == 0 && !isNoteworthyPath(path.subList(1, path.size()))) {
-                op = new TreeNewParagraph(clientJupiter.getSiteId(), path.get(0));
+                op = new TreeNewParagraph(clientJupiter.getSiteId(), pos);
                 op.setPath(convertPath(path));


Input:
public void reset(int minIndex, int maxIndex) {
    mMinIndex = minIndex;
    mMaxIndex = maxIndex;
    isLeaf = (mMaxIndex - mMinIndex) <= MAX_SIZE;
    boolean first = true;
    for (int i = mMinIndex; i < mMaxIndex; i++) {
        float q = (mDimension == X) ? mPoints[i].x : mPoints[i].y;
        if (first) {
            mMinVal = q;
            mMaxVal = q;
            first = false;
        } else if (q < mMinVal) {
            mMinVal = q;
        } else if (q > mMaxVal) {
            mMaxVal = q;
        }
    }
    if (!isLeaf) {
        float pivotValue = (mMinVal + mMaxVal) / 2;
        int pivotIndex = partition(mDimension, mPoints, mMinIndex, mMaxIndex, pivotValue);
        if (low == null) {
            low = new Quadtree(!mDimension, mEntrySize, mPoints);
        }
        if (high == null) {
            high = new Quadtree(!mDimension, mEntrySize, mPoints);
        }
        low.reset(mMinIndex, pivotIndex);
        high.reset(pivotIndex, mMaxIndex);
    } else {
        low = null;
        high = null;
    }
}

Output:
     if (!isLeaf) {
-        float pivotValue = (mMinVal + mMaxVal) / 2;
-        int pivotIndex = partition(mDimension, mPoints, mMinIndex, mMaxIndex, pivotValue);
+        int pivotIndex = partition(!mDimension, mPoints, mMinIndex, mMaxIndex);
         if (low == null) {


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.SPELL_CAST) {
        Spell spell = game.getStack().getSpell(event.getTargetId());
        if (spell != null && spell.getCardType().contains(CardType.INSTANT) || spell.getCardType().contains(CardType.SORCERY)) {
            Permanent enchantment = game.getPermanent(sourceId);
            if (enchantment != null && enchantment.getAttachedTo() != null) {
                Player player = game.getPlayer(enchantment.getAttachedTo());
                if (player != null && spell.getControllerId().equals(player.getId())) {
                    this.getTargets().get(0).add(spell.getId(), game);
                    return true;
                }
            }
        }
    }
    return false;
}

Output:
         Spell spell = game.getStack().getSpell(event.getTargetId());
-        if (spell != null && spell.getCardType().contains(CardType.INSTANT) || spell.getCardType().contains(CardType.SORCERY)) {
+        if (spell != null && (spell.getCardType().contains(CardType.INSTANT) || spell.getCardType().contains(CardType.SORCERY))) {
             Permanent enchantment = game.getPermanent(sourceId);


Input:
public static List<TreeNode> getMultiLoopsForXmlTree(AbstractInOutTree tree) {
    List<TreeNode> loopNodes = new ArrayList<TreeNode>();
    List<? extends TreeNode> children = new ArrayList<TreeNode>();
    if (tree instanceof InputXmlTree) {
        children = ((InputXmlTree) tree).getNodes();
    } else if (tree instanceof OutputXmlTree) {
        children = ((OutputXmlTree) tree).getNodes();
    }
    getChildLoops(loopNodes, children, false);
    return loopNodes;
}

Output:
     }
-    getChildLoops(loopNodes, children, false);
+    getChildLoops(loopNodes, children);
     return loopNodes;


Input:
public void execute(Intent intent, Throwable error) {
    if (operation.getCode() == AVIMOperation.CONVERSATION_QUIT.getCode()) {
        client.removeConversationCache(AVIMConversation.this);
    }
    if (error == null && occ != null) {
        occ.onComplete();
    } else if (error != null && occ != null) {
        occ.onFailure();
    }
    if (message != null) {
        if (error == null) {
            long timestamp = intent.getExtras().getLong(Conversation.callbackMessageTimeStamp, -1);
            String messageId = intent.getStringExtra(Conversation.callbackMessageId);
            message.setMessageId(messageId);
            message.setMessageStatus(AVIMMessage.AVIMMessageStatus.AVIMMessageStatusSent);
            if (timestamp != -1) {
                message.setTimestamp(timestamp);
            }
            if (null == messageOption || !messageOption.isTransient() && AVIMClient.messageQueryCacheEnabled) {
                setLastMessage(message);
                storage.insertLocalMessage(message);
            }
            AVIMConversation.this.lastMessageAt = new Date(timestamp);
            storage.updateConversationLastMessageAt(AVIMConversation.this);
        } else {
            message.setMessageStatus(AVIMMessage.AVIMMessageStatus.AVIMMessageStatusFailed);
        }
    }
    if (operation.getCode() == AVIMOperation.CONVERSATION_MESSAGE_QUERY.getCode()) {
        List<AVIMMessage> historyMessages = intent.getParcelableArrayListExtra(Conversation.callbackHistoryMessages);
        setLastReadAt(intent.getLongExtra(Conversation.callbackReadAt, 0L), false);
        setLastDeliveredAt(intent.getLongExtra(Conversation.callbackDeliveredAt, 0L), false);
        storage.updateConversationTimes(AVIMConversation.this);
        if (error != null) {
            callback.internalDone(null, AVIMException.wrapperAVException(error));
        } else {
            if (historyMessages == null) {
                historyMessages = Collections.EMPTY_LIST;
            }
            callback.internalDone(historyMessages, null);
        }
        return;
    }
    if (operation.getCode() == AVIMOperation.CONVERSATION_UPDATE.getCode()) {
        if (intent.getExtras().containsKey(Conversation.callbackUpdatedAt)) {
            String updatedAt = intent.getExtras().getString(Conversation.callbackUpdatedAt);
            AVIMConversation.this.updatedAt = updatedAt;
        }
    }
    if (operation.getCode() == AVIMOperation.CONVERSATION_MEMBER_COUNT_QUERY.getCode()) {
        int memberCount = intent.getIntExtra(Conversation.callbackMemberCount, 0);
        callback.internalDone(memberCount, AVIMException.wrapperAVException(error));
        return;
    }
    if (operation.getCode() == AVIMOperation.CONVERSATION_FETCH_RECEIPT_TIME.getCode()) {
        setLastReadAt(intent.getLongExtra(Conversation.callbackReadAt, 0L), false);
        setLastDeliveredAt(intent.getLongExtra(Conversation.callbackDeliveredAt, 0L), false);
        storage.updateConversationTimes(AVIMConversation.this);
        callback.internalDone(null, AVIMException.wrapperAVException(error));
        return;
    }
    if (operation.getCode() == AVIMOperation.CONVERSATION_QUERY.getCode()) {
        if (null != error) {
            callback.internalDone(null, AVIMException.wrapperAVException(error));
        } else {
            Exception exception = processQueryResult(intent.getExtras().getSerializable(Conversation.callbackData));
            callback.internalDone(null, AVIMException.wrapperAVException(exception));
        }
        return;
    }
    callback.internalDone(null, AVIMException.wrapperAVException(error));
}

Output:
         if (error != null) {
-            callback.internalDone(null, AVIMException.wrapperAVException(error));
+            callback.internalDone(null, new AVIMException(AVIMException.TIMEOUT, AVException.CONNECTION_FAILED, error.getMessage()));
         } else {


Input:
private Optional<ImmutableSortedMap<String, HashCode>> calculateClassHashes(ExecutionContext context, Path path) {
    final ImmutableSortedMap.Builder<String, HashCode> classNamesBuilder = ImmutableSortedMap.naturalOrder();
    ClasspathTraversal traversal = new ClasspathTraversal(Collections.singleton(path), context.getProjectFilesystem()) {
        public void visit(final FileLike fileLike) throws IOException {
            if (!FileLikes.isClassFile(fileLike)) {
                return;
            }
            String key = FileLikes.getFileNameWithoutClassSuffix(fileLike);
            ByteSource input = new ByteSource() {
                public InputStream openStream() throws IOException {
                    return fileLike.getInput();
                }
            };
            HashCode value = input.hash(Hashing.sha1());
            classNamesBuilder.put(key, value);
        }
    };
    try {
        new DefaultClasspathTraverser().traverse(traversal);
    } catch (IOException e) {
        context.logError(e, "String_Node_Str", pathToJarOrClassesDirectory);
        return Optional.absent();
    }
    return Optional.of(classNamesBuilder.build());
}

Output:
     } catch (IOException e) {
-        context.logError(e, "String_Node_Str", pathToJarOrClassesDirectory);
+        context.logError(e, "String_Node_Str", path);
         return Optional.absent();


Input:
public ClassNode lookupClassNodeForSource(String typename, JDTResolver jdtResolver) {
    ClassNode node = typenameToClassNodeCache.get(typename);
    if (node != null) {
        return node;
    }
    char[][] compoundName = CharOperation.splitOn('.', typename.toCharArray());
    TypeBinding jdtBinding = null;
    try {
        jdtBinding = getType(compoundName, compoundName.length);
    } catch (AbortCompilation t) {
        if (t.silentException instanceof AbortIncrementalBuildException) {
            jdtBinding = null;
        } else {
            throw t;
        }
    }
    if (jdtBinding != null) {
        if (jdtBinding instanceof SourceTypeBinding) {
            ClassNode classNode = jdtResolver.convertToClassNode(jdtBinding);
            if (classNode != null) {
                typenameToClassNodeCache.put(typename, classNode);
            }
            return classNode;
        } else if (jdtBinding instanceof BinaryTypeBinding) {
            ClassNode newNode = jdtResolver.convertToClassNode(jdtBinding);
            if (newNode != null) {
                typenameToClassNodeCache.put(typename, newNode);
            }
            return newNode;
        }
    }
    if (jdtBinding != null && (jdtBinding instanceof ProblemReferenceBinding)) {
        ProblemReferenceBinding prBinding = (ProblemReferenceBinding) jdtBinding;
        if (prBinding.problemId() == ProblemReasons.InternalNameProvided) {
            jdtBinding = prBinding.closestMatch();
            if (jdtBinding != null && (jdtBinding instanceof SourceTypeBinding)) {
                return jdtResolver.convertToClassNode(jdtBinding);
            }
            if (jdtBinding != null && (jdtBinding instanceof BinaryTypeBinding)) {
                return jdtResolver.convertToClassNode(jdtBinding);
            }
        }
    }
    return null;
}

Output:
     }
-    if (jdtBinding != null) {
-        if (jdtBinding instanceof SourceTypeBinding) {
-            ClassNode classNode = jdtResolver.convertToClassNode(jdtBinding);
-            if (classNode != null) {
-                typenameToClassNodeCache.put(typename, classNode);
-            }
-            return classNode;
-        } else if (jdtBinding instanceof BinaryTypeBinding) {
-            ClassNode newNode = jdtResolver.convertToClassNode(jdtBinding);
-            if (newNode != null) {
-                typenameToClassNodeCache.put(typename, newNode);
-            }
-            return newNode;
-        }
+    if (jdtBinding instanceof SourceTypeBinding || jdtBinding instanceof BinaryTypeBinding) {
+        return jdtResolver.convertToClassNode(jdtBinding);
     }


Input:
public void removeRelationshipFromCache(int id) {
    nodeManager.removeRelationshipFromCache(id);
}

Output:
 public void removeRelationshipFromCache(int id) {
-    nodeManager.removeRelationshipFromCache(id);
+    if (nodeManager != null) {
+        nodeManager.removeRelationshipFromCache(id);
+    }
 }


Input:
private void updateVisible() {
    List<ILoginConnectionService> loginConnectionServices = LoginConnectionManager.getRemoteConnectionService();
    String errorMsg = null;
    if (loginConnectionServices.size() > 0 && getConnection() != null && getConnection().isComplete()) {
        for (ILoginConnectionService loginConncetion : loginConnectionServices) {
            errorMsg = loginConncetion.checkConnectionValidation(getConnection().getName(), getConnection().getDescription(), getConnection().getUser(), getConnection().getPassword(), getConnection().getWorkSpace(), getConnection().getDynamicFields().get(RepositoryConstants.REPOSITORY_URL));
            if (errorMsg != null) {
                break;
            }
        }
    }
    if (getConnection() == null) {
        manageViewer.getControl().setEnabled(false);
        manageProjectsButton.setEnabled(false);
        openProjectBtn.setEnabled(false);
        if (fillProjectsBtn != null) {
            fillProjectsBtn.setEnabled(false);
        }
        projectViewer.getControl().setEnabled(false);
        if (branchesViewer != null) {
            branchesViewer.getControl().setEnabled(false);
        }
    } else if (errorMsg != null) {
        iconLabel.setImage(LOGIN_CRITICAL_IMAGE);
        onIconLabel.setImage(LOGIN_CRITICAL_IMAGE);
        colorComposite.setBackground(RED_COLOR);
        onIconLabel.setBackground(colorComposite.getBackground());
        manageViewer.getControl().setEnabled(false);
        manageProjectsButton.setEnabled(false);
        projectViewer.getControl().setEnabled(false);
        openProjectBtn.setEnabled(false);
        if (fillProjectsBtn != null) {
            fillProjectsBtn.setEnabled(true);
        }
        if (branchesViewer != null) {
            branchesViewer.getControl().setEnabled(false);
        }
        statusLabel.setText(errorMsg);
        statusLabel.setBackground(RED_COLOR);
        statusLabel.setForeground(WHITE_COLOR);
        Font font = new Font(null, LoginComposite.FONT_ARIAL, 9, SWT.BOLD);
        statusLabel.setFont(font);
    } else if (getConnection() != null && projectViewer != null && projectViewer.getInput() == null) {
        manageViewer.getControl().setEnabled(false);
        manageProjectsButton.setEnabled(false);
        projectViewer.getControl().setEnabled(false);
        openProjectBtn.setEnabled(false);
        if (fillProjectsBtn != null) {
            fillProjectsBtn.setEnabled(true);
        }
        if (branchesViewer != null) {
            branchesViewer.getControl().setEnabled(false);
        }
        statusLabel.setText(Messages.getString("String_Node_Str"));
        statusLabel.setBackground(RED_COLOR);
        statusLabel.setForeground(WHITE_COLOR);
        Font font = new Font(null, LoginComposite.FONT_ARIAL, 9, SWT.BOLD);
        statusLabel.setFont(font);
        restartBut.setVisible(false);
    } else if (!isWorkSpaceSame()) {
        manageViewer.getControl().setEnabled(false);
        manageProjectsButton.setEnabled(false);
        openProjectBtn.setEnabled(false);
        if (projectViewer != null) {
            projectViewer.getControl().setEnabled(false);
        }
        if (fillProjectsBtn != null) {
            fillProjectsBtn.setEnabled(false);
        }
        if (branchesViewer != null) {
            branchesViewer.getControl().setEnabled(false);
        }
        restartBut.setVisible(true);
    } else if (inuse) {
        manageViewer.getControl().setEnabled(false);
        manageProjectsButton.setEnabled(false);
        openProjectBtn.setEnabled(false);
        restartBut.setVisible(false);
        if (fillProjectsBtn != null) {
            fillProjectsBtn.setEnabled(false);
        }
        if (branchesViewer != null) {
            branchesViewer.getControl().setEnabled(false);
        }
    } else {
        manageViewer.getControl().setEnabled(true);
        manageProjectsButton.setEnabled(true);
        if (projectViewer != null) {
            final Object input = projectViewer.getInput();
            boolean enabled = input != null && ((input instanceof Project[]) && ((Project[]) input).length > 0);
            openProjectBtn.setEnabled(enabled);
        }
        if (fillProjectsBtn != null) {
            fillProjectsBtn.setEnabled(true);
        }
        if (PluginChecker.isSVNProviderPluginLoaded() && branchesViewer != null) {
            branchesViewer.getControl().setEnabled(true);
        }
        restartBut.setVisible(false);
    }
    if (PluginChecker.isSVNProviderPluginLoaded()) {
        manageViewer.getControl().setEnabled(true);
        manageProjectsButton.setEnabled(true);
    }
}

Output:
             errorMsg = loginConncetion.checkConnectionValidation(getConnection().getName(), getConnection().getDescription(), getConnection().getUser(), getConnection().getPassword(), getConnection().getWorkSpace(), getConnection().getDynamicFields().get(RepositoryConstants.REPOSITORY_URL));
-            if (errorMsg != null) {
+            if (StringUtils.isEmpty(errorMsg)) {
                 break;


Input:
public void initRunner() {
    runner = new Mongobee();
    runner.setDbName("String_Node_Str");
    runner.setHost("String_Node_Str");
    runner.setEnabled(true);
    runner.setChangelogsBasePackage(MongobeeUtilsTestResource.class.getPackage().getName());
}

Output:
     runner.setEnabled(true);
-    runner.setChangelogsBasePackage(MongobeeUtilsTestResource.class.getPackage().getName());
+    runner.setChangelogsBasePackage(MongobeeTestResource.class.getPackage().getName());
 }


Input:
public void testTagAddUsers() throws Exception {
    List<String> userIds = new ArrayList<String>();
    userIds.add(((ApiTestModule.WxXmlCpInMemoryConfigStorage) configStorage).getUserId());
    wxService.tagAddUsers(tagId, userIds);
}

Output:
     userIds.add(((ApiTestModule.WxXmlCpInMemoryConfigStorage) configStorage).getUserId());
-    wxService.tagAddUsers(tagId, userIds);
+    wxService.tagAddUsers(tagId, userIds, null);
 }


Input:
public boolean requiresAlignment() {
    return (alignmentQuality == null);
}

Output:
 public boolean requiresAlignment() {
-    return (alignmentQuality == null);
+    return hasMatchPairs() && (alignmentQuality == null);
 }


Input:
private boolean checkEnvAndParams() {
    if (!env.isDas()) {
        return setFail(Strings.get("String_Node_Str"));
    }
    Cluster cluster = domain.getClusterNamed(clusterName);
    if (cluster == null) {
        return setFail(Strings.get("String_Node_Str", clusterName));
    }
    return true;
}

Output:
     if (!env.isDas()) {
-        return setFail(Strings.get("String_Node_Str"));
+        return setFail(logger, report, Strings.get("String_Node_Str"));
     }


Input:
private Map<String, RangerPolicy.RangerPolicyResource> toRangerResourceList(String resourceString, String resourceType, Boolean isExcludes, Boolean isRecursive, Map<String, RangerPolicy.RangerPolicyResource> resources) {
    Map<String, RangerPolicy.RangerPolicyResource> ret = resources == null ? new HashMap<String, RangerPolicy.RangerPolicyResource>() : resources;
    if (resourceString != null) {
        RangerPolicy.RangerPolicyResource resource = ret.get(resourceType);
        if (resource == null) {
            resource = new RangerPolicy.RangerPolicyResource();
            resource.setIsExcludes(isExcludes);
            resource.setIsRecursive(isRecursive);
            ret.put(resourceType, resource);
        }
        for (String res : resourceString.split("String_Node_Str")) {
            resource.getValues().add(res);
        }
    }
    return ret;
}

Output:
     Map<String, RangerPolicy.RangerPolicyResource> ret = resources == null ? new HashMap<String, RangerPolicy.RangerPolicyResource>() : resources;
-    if (resourceString != null) {
+    if (StringUtils.isNotBlank(resourceString)) {
         RangerPolicy.RangerPolicyResource resource = ret.get(resourceType);


Input:
public void validationOfNamespacesMissingD_NamespaceAtRequiredTag() throws Exception {
    String roomWithValidNamespaces = "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";
    EdmEntitySet entitySet = MockFacade.getMockEdm().getDefaultEntityContainer().getEntitySet("String_Node_Str");
    InputStream reqContent = createContentAsStream(roomWithValidNamespaces);
    readAndExpectException(entitySet, reqContent, false, EntityProviderException.MISSING_PROPERTY.addContent("String_Node_Str"));
}

Output:
 public void validationOfNamespacesMissingD_NamespaceAtRequiredTag() throws Exception {
-    String roomWithValidNamespaces = "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 roomWithValidNamespaces = "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";
     EdmEntitySet entitySet = MockFacade.getMockEdm().getDefaultEntityContainer().getEntitySet("String_Node_Str");


Input:
public void mouseReleased(Canvas canvas, Graphics g, MouseEvent e) {
    Project proj = canvas.getProject();
    if (state == MOVING) {
        setState(proj, IDLE);
        computeDxDy(proj, e, g);
        int dx = curDx;
        int dy = curDy;
        if (dx != 0 || dy != 0) {
            if (!proj.getLogisimFile().contains(canvas.getCircuit())) {
                canvas.setErrorMessage(Strings.getter("String_Node_Str"));
            } else if (proj.getSelection().hasConflictWhenMoved(dx, dy)) {
                canvas.setErrorMessage(Strings.getter("String_Node_Str"));
            } else {
                boolean connect = shouldConnect(canvas, e.getModifiersEx());
                drawConnections = false;
                ReplacementMap repl;
                if (connect) {
                    MoveGesture gesture = moveGesture;
                    if (gesture == null) {
                        gesture = new MoveGesture(new MoveRequestHandler(canvas), canvas.getCircuit(), canvas.getSelection().getAnchoredComponents());
                    }
                    canvas.setErrorMessage(new ComputingMessage(dx, dy), COLOR_COMPUTING);
                    MoveResult result = gesture.forceRequest(dx, dy);
                    clearCanvasMessage(canvas, dx, dy);
                    repl = result.getReplacementMap();
                } else {
                    repl = null;
                }
                Selection sel = proj.getSelection();
                proj.doAction(SelectionActions.translate(sel, dx, dy, repl));
            }
        }
        moveGesture = null;
        proj.repaintCanvas();
    } else if (state == RECT_SELECT) {
        Bounds bds = Bounds.create(start).add(start.getX() + curDx, start.getY() + curDy);
        Circuit circuit = canvas.getCircuit();
        Selection sel = proj.getSelection();
        Collection<Component> in_sel = sel.getComponentsWithin(bds, g);
        for (Component comp : circuit.getAllWithin(bds, g)) {
            if (!in_sel.contains(comp))
                sel.add(comp);
        }
        Action act = SelectionActions.drop(sel, in_sel);
        if (act != null) {
            proj.doAction(act);
        }
        setState(proj, IDLE);
        proj.repaintCanvas();
    }
    if (e.getClickCount() >= 2) {
        Set<Component> comps = canvas.getProject().getSelection().getComponents();
        if (comps.size() == 1) {
            for (Component comp : comps) {
                if (comp.getAttributeSet().containsAttribute(StdAttr.LABEL)) {
                    String OldLabel = comp.getAttributeSet().getValue(StdAttr.LABEL);
                    SetAttributeAction act = new SetAttributeAction(canvas.getCircuit(), Strings.getter("String_Node_Str"));
                    AutoLabel.AskAndSetLabel(comp.getFactory().getDisplayName(), OldLabel, canvas.getCircuit(), comp, comp.getAttributeSet(), act, true);
                    if (!act.isEmpty())
                        canvas.getProject().doAction(act);
                }
            }
        }
    }
}

Output:
                     SetAttributeAction act = new SetAttributeAction(canvas.getCircuit(), Strings.getter("String_Node_Str"));
-                    AutoLabel.AskAndSetLabel(comp.getFactory().getDisplayName(), OldLabel, canvas.getCircuit(), comp, comp.getAttributeSet(), act, true);
+                    AutoLabler.AskAndSetLabel(comp.getFactory().getDisplayName(), OldLabel, canvas.getCircuit(), comp, comp.getAttributeSet(), act, true);
                     if (!act.isEmpty())


Input:
public String getPropertyValue() {
    switch(key) {
        case "String_Node_Str":
            return getDebugLogPath();
        case "String_Node_Str":
            return getRootLevel();
    }
    return null;
}

Output:
         case "String_Node_Str":
-            return getDebugLogPath();
+            result = getDebugLogPath();
         case "String_Node_Str":


Input:
public void generateInvoice(ActionRequest request, ActionResponse response) {
    StockMove stockMove = request.getContext().asType(StockMove.class);
    Invoice invoice = null;
    int numInvoice = 0;
    try {
        stockMove = StockMove.find(stockMove.getId());
        if (stockMove.getSalesOrder() != null) {
            invoice = stockMoveInvoiceService.createInvoiceFromSalesOrder(stockMove, stockMove.getSalesOrder());
            if (invoice != null)
                numInvoice++;
        }
        if (stockMove.getPurchaseOrder() != null) {
            invoice = stockMoveInvoiceService.createInvoiceFromPurchaseOrder(stockMove, stockMove.getPurchaseOrder());
            if (invoice != null)
                numInvoice++;
        }
        if (numInvoice > 0) {
            response.setReload(true);
            if (numInvoice == 1)
                response.setFlash("String_Node_Str");
            else
                response.setFlash(numInvoice + "String_Node_Str");
        }
    } catch (Exception e) {
        TraceBackService.trace(response, e);
    }
}

Output:
         }
-        if (numInvoice > 0) {
+        if (invoice != null) {
             response.setReload(true);


Input:
public void initArchitecture() {
    vizConfig = VizController.getInstance().getVizConfig();
    drawable = VizController.getInstance().getDrawable();
    model.colorMode = new UniqueColorMode(model);
    model.sizeMode = sizeModes[1];
    model.font = vizConfig.getLabelFont();
    model.nodeColor = vizConfig.getDefaultNodeLabelColor();
    model.edgeColor = vizConfig.getDefaultEdgeLabelColor();
    model.setSelectedOnly(vizConfig.isShowLabelOnSelectedOnly());
    renderer = new Renderer3D();
    renderer.initRenderer();
    model.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
            if (!renderer.getFont().equals(model.getFont())) {
                renderer.setFont(model.getFont());
            }
        }
    });
}

Output:
     model.setSelectedOnly(vizConfig.isShowLabelOnSelectedOnly());
-    renderer = new Renderer3D();
+    renderer = new Renderer2D();
     renderer.initRenderer();


Input:
public void run() {
    serv.addError(SpannableString.valueOf(err));
    for (Channel channel : serv.getChannels()) {
        channel.addError(SpannableString.valueOf(err));
    }
    if (adapter != null) {
        adapter.notifyDataSetChanged();
        if (channelAdapter != null)
            channelAdapter.notifyDataSetChanged();
    }
}

Output:
 public void run() {
-    serv.addError(SpannableString.valueOf(err));
+    serv.addMessage(Server.createError(SpannableString.valueOf(err)));
     for (Channel channel : serv.getChannels()) {


Input:
public static List<IAvailableModel> getAvailableModels() {
    try {
        IExtensionRegistry registry = Platform.getExtensionRegistry();
        IConfigurationElement[] configurationElements = registry.getConfigurationElementsFor("String_Node_Str");
        List<IAvailableModel> models = new ArrayList<IAvailableModel>();
        for (int i = 0; i < configurationElements.length; i++) {
            IConfigurationElement element = configurationElements[i];
            IAvailableModel modelcalss = (IAvailableModel) element.createExecutableExtension("String_Node_Str");
            models.add(modelcalss);
        }
        return models;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return new ArrayList<IAvailableModel>();
}

Output:
     } catch (Exception e) {
-        e.printStackTrace();
+        log.error(e.getMessage(), e);
     }


Input:
public void setBasic(GlassFishValve valve) {
    GlassFishValve oldBasic = null;
    synchronized (this) {
        oldBasic = this.basic;
    }
    if (oldBasic == valve) {
        return;
    }
    if (oldBasic != null) {
        synchronized (this) {
            if (started && (oldBasic instanceof Lifecycle)) {
                try {
                    ((Lifecycle) oldBasic).stop();
                } catch (LifecycleException e) {
                    log.log(Level.SEVERE, SET_BASIC_STOP_EXCEPTION, e);
                }
            }
        }
        if (oldBasic instanceof Contained) {
            try {
                ((Contained) oldBasic).setContainer(null);
            } catch (Throwable t) {
            }
        }
    }
    if (valve == null) {
        return;
    }
    if (valve instanceof Contained) {
        ((Contained) valve).setContainer(this.container);
    }
    if (started && (valve instanceof Lifecycle)) {
        try {
            ((Lifecycle) valve).start();
        } catch (LifecycleException e) {
            log.log(Level.SEVERE, SET_BASIC_START_EXCEPTION, e);
            return;
        }
    }
    this.basic = valve;
}

Output:
     }
-    this.basic = valve;
+    synchronized (this) {
+        this.basic = valve;
+    }
 }


Input:
public void setUser(String user) {
    logger.finer("String_Node_Str" + user);
    options.set(USER, user);
}

Output:
 public void setUser(String user) {
-    logger.finer("String_Node_Str" + user);
+    if (logger.isLoggable(Level.FINER))
+        logger.finer("String_Node_Str" + user);
     options.set(USER, user);


Input:
public String getDefaultUnit() {
    if (DEUtil.getInputElements(input) == null || DEUtil.getInputSize(input) == 0) {
        return null;
    }
    String unit = null;
    if (!DEUtil.getGroupElementHandle(DEUtil.getInputElements(input)).isSameType()) {
        return null;
    }
    DesignElementHandle handle = (DesignElementHandle) DEUtil.getInputFirstElement(input);
    unit = handle.getPropertyHandle(getProperty()).getDefaultUnit();
    if (unit != null) {
        if (!StringUtil.isBlank(unit)) {
            unit = ChoiceSetFactory.getElementChoiceSet(getElement(), getProperty()).findChoice(unit).getDisplayName();
        }
        return unit;
    }
    return null;
}

Output:
         if (!StringUtil.isBlank(unit)) {
-            unit = ChoiceSetFactory.getElementChoiceSet(getElement(), getProperty()).findChoice(unit).getDisplayName();
+            unit = ChoiceSetFactory.getDimensionChoiceSet(getElement(), getProperty()).findChoice(unit).getDisplayName();
         }


Input:
public void preUpdate(float delta) {
    update(delta);
    if (velocity == Vector2.ZERO)
        return;
    position = position.add(velocity);
    polygon.setPosition(position);
    getLocalTransform().reset().rotate(Vector3.AXIS_Z, polygon.getRotation()).translate(position);
}

Output:
     polygon.setPosition(position);
-    getLocalTransform().reset().rotate(Vector3.AXIS_Z, polygon.getRotation()).translate(position);
+    getLocalTransform().reset().translate(getPosition().subtract(getCenter())).rotate(Vector3.AXIS_Z, polygon.getRotation()).translate(getCenter());
 }


Input:
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
    String code = (String) mListView.getItemAtPosition(position);
    if (null != code) {
        mInstallButtonGuard.setAppInfo(mCodeAppInfoMap.get(code));
        updateUIState(mCodeAppInfoMap.get(code));
    }
}

Output:
     if (null != code) {
-        mInstallButtonGuard.setAppInfo(mCodeAppInfoMap.get(code));
-        updateUIState(mCodeAppInfoMap.get(code));
+        AppInfo appInfo = mCodeAppInfoMap.get(code);
+        if (null != appInfo) {
+            mInstallButtonGuard.setAppInfo(appInfo);
+            updateUIState(appInfo);
+        }
     }


Input:
public void set(IMetadataColumn bean, String value) {
    bean.setRelationshipType(value);
}

Output:
 public void set(IMetadataColumn bean, String value) {
-    bean.setRelationshipType(value);
+    bean.getAdditionalField().put(field, value);
 }


Input:
protected void prepareParameters() throws Exception, RemoteException {
    __bean = context.getBean();
    __docName = __getReportDocument();
    __checkDocumentExists();
    InputOptions getPageCountOptions = new InputOptions();
    getPageCountOptions.setOption(InputOptions.OPT_LOCALE, __bean.getLocale());
    getPageCountOptions.setOption(InputOptions.OPT_RTL, new Boolean(__bean.isRtl()));
    getPageCountOptions.setOption(InputOptions.OPT_REQUEST, context.getRequest());
    OutputOptions outputOptions = new OutputOptions();
    InputOptions options = new InputOptions();
    __totalPageNumber = getReportService().getPageCount(__docName, getPageCountOptions, outputOptions);
    Boolean isCompleted = (Boolean) outputOptions.getOption(OutputOptions.OPT_REPORT_GENERATION_COMPLETED);
    if (isCompleted != null) {
        __isCompleted = isCompleted.booleanValue();
    }
    __pageNumber = getPageNumber(context.getRequest(), operation.getOprand(), __docName);
    if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
        __bookmark = getBookmark(operation.getOprand(), __bean);
        options.setOption(InputOptions.OPT_REQUEST, context.getRequest());
        options.setOption(InputOptions.OPT_LOCALE, __bean.getLocale());
        __pageNumber = getReportService().getPageNumberByBookmark(__docName, __bookmark, options);
        if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
            __bookmark = (getReportService()).findTocByName(__docName, __bookmark, options);
            __pageNumber = getReportService().getPageNumberByBookmark(__docName, __bookmark, options);
            if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
                AxisFault fault = new AxisFault();
                fault.setFaultReason(BirtResources.getMessage(ResourceConstants.ACTION_EXCEPTION_INVALID_BOOKMARK, new String[] { getBookmark(operation.getOprand(), __bean) }));
                throw fault;
            }
        }
        __useBookmark = true;
    }
    if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
        AxisFault fault = new AxisFault();
        fault.setFaultReason(BirtResources.getMessage(ResourceConstants.ACTION_EXCEPTION_INVALID_PAGE_NUMBER));
        throw fault;
    }
    __svgFlag = getSVGFlag(operation.getOprand());
}

Output:
         __bookmark = getBookmark(operation.getOprand(), __bean);
-        options.setOption(InputOptions.OPT_REQUEST, context.getRequest());
-        options.setOption(InputOptions.OPT_LOCALE, __bean.getLocale());
-        __pageNumber = getReportService().getPageNumberByBookmark(__docName, __bookmark, options);
-        if (!isValidPageNumber(context.getRequest(), __pageNumber, __docName)) {
-            __bookmark = (getReportService()).findTocByName(__docName, __bookmark, options);
+        if (__bookmark != null && __bookmark.length() > 0) {
+            options.setOption(InputOptions.OPT_REQUEST, context.getRequest());
+            options.setOption(InputOptions.OPT_LOCALE, __bean.getLocale());
+            if (__bean.isToc()) {
+                __bookmark = (getReportService()).findTocByName(__docName, __bookmark, options);
+            }
             __pageNumber = getReportService().getPageNumberByBookmark(__docName, __bookmark, options);


Input:
public void initialize() throws IllegalActionException {
    HSDirector dir = (HSDirector) getDirector();
    if (dir == null) {
        throw new IllegalActionException(this, "String_Node_Str");
    } else if (!(dir instanceof CTGeneralDirector)) {
        throw new IllegalActionException("String_Node_Str" + "String_Node_Str");
    }
    ODESolver solver = dir.getCurrentODESolver();
    if (solver == null) {
        throw new IllegalActionException(this, "String_Node_Str");
    }
    super.initialize();
    _tentativeState = ((DoubleToken) initialState.getToken()).doubleValue();
    _state = _tentativeState;
    _storedState = _state;
    _derivative = 0.0;
    if (_debugging) {
        _debug(getName(), "String_Node_Str" + _state + "String_Node_Str" + _derivative);
    }
    _history.clear();
}

Output:
 public void initialize() throws IllegalActionException {
-    HSDirector dir = (HSDirector) getDirector();
-    if (dir == null) {
+    HSDirector director = (HSDirector) getDirector();
+    if (director == null) {
         throw new IllegalActionException(this, "String_Node_Str");


Input:
public EnhanceEntity findById(Object primaryKey, EntityMetadata m, List<String> relationNames, Client client) {
    try {
        Object o = client.find(m.getEntityClazz(), primaryKey);
        if (o == null) {
            return null;
        } else {
            return o instanceof EnhanceEntity ? (EnhanceEntity) o : new EnhanceEntity(o, getId(o, m), null);
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new PersistenceException(e.getMessage());
    }
}

Output:
 public EnhanceEntity findById(Object primaryKey, EntityMetadata m, List<String> relationNames, Client client) {
-    try {
-        Object o = client.find(m.getEntityClazz(), primaryKey);
-        if (o == null) {
-            return null;
-        } else {
-            return o instanceof EnhanceEntity ? (EnhanceEntity) o : new EnhanceEntity(o, getId(o, m), null);
-        }
-    } catch (Exception e) {
-        e.printStackTrace();
-        throw new PersistenceException(e.getMessage());
-    }
+    return super.findById(primaryKey, m, relationNames, client);
 }


Input:
public R next() {
    idx++;
    return null;
}

Output:
 public R next() {
-    idx++;
-    return null;
+    if (hasNext()) {
+        idx++;
+        return null;
+    }
+    throw new NoSuchElementException();
 }


Input:
public ItemStack getStackInSlot(ItemStack me, int slot) {
    NBTTagCompound plateNBT = getPlateNBT(me);
    if (plateNBT != null) {
        return ItemStack.loadItemStackFromNBT(plateNBT.getCompoundTag("String_Node_Str"));
    }
    return null;
}

Output:
     if (plateNBT != null) {
-        return ItemStack.loadItemStackFromNBT(plateNBT.getCompoundTag("String_Node_Str"));
+        return new ItemStack(plateNBT.getCompoundTag("String_Node_Str"));
     }


Input:
public byte getLuminanceFromSky() {
    return (byte) handle.getSkyBlockTypeBrightness(EnumSkyBlock.Sky, x, y, z);
}

Output:
 public byte getLuminanceFromSky() {
-    return (byte) handle.getSkyBlockTypeBrightness(EnumSkyBlock.Sky, x, y, z);
+    return (byte) handle.getLightFor(EnumSkyBlock.SKY, pos);
 }


Input:
public void build() {
    HIARequestOrderDataType request;
    AuthenticationPubKeyInfoType authenticationPubKeyInfo;
    EncryptionPubKeyInfoType encryptionPubKeyInfo;
    PubKeyValueType encryptionPubKeyValue;
    X509DataType encryptionX509Data;
    RSAKeyValueType encryptionRsaKeyValue;
    PubKeyValueType authPubKeyValue;
    X509DataType authX509Data;
    RSAKeyValueType AuthRsaKeyValue;
    EbicsCertificate certificate = session.getUser().getE002Certificate();
    encryptionX509Data = EbicsXmlFactory.createX509DataType(session.getUser().getDn(), certificate.getCertificate());
    encryptionRsaKeyValue = EbicsXmlFactory.createRSAKeyValueType(new BigInteger(certificate.getPublicKeyExponent()).toByteArray(), new BigInteger(certificate.getPublicKeyModulus()).toByteArray());
    encryptionPubKeyValue = EbicsXmlFactory.createH003PubKeyValueType(encryptionRsaKeyValue, Calendar.getInstance());
    encryptionPubKeyInfo = EbicsXmlFactory.createEncryptionPubKeyInfoType("String_Node_Str", encryptionPubKeyValue, encryptionX509Data);
    certificate = session.getUser().getX002Certificate();
    authX509Data = EbicsXmlFactory.createX509DataType(session.getUser().getDn(), certificate.getCertificate());
    AuthRsaKeyValue = EbicsXmlFactory.createRSAKeyValueType(new BigInteger(certificate.getPublicKeyExponent()).toByteArray(), new BigInteger(certificate.getPublicKeyModulus()).toByteArray());
    authPubKeyValue = EbicsXmlFactory.createH003PubKeyValueType(AuthRsaKeyValue, Calendar.getInstance());
    authenticationPubKeyInfo = EbicsXmlFactory.createAuthenticationPubKeyInfoType("String_Node_Str", authPubKeyValue, authX509Data);
    request = EbicsXmlFactory.createHIARequestOrderDataType(authenticationPubKeyInfo, encryptionPubKeyInfo, session.getUser().getEbicsPartner().getPartnerId(), session.getUser().getUserId());
    document = EbicsXmlFactory.createHIARequestOrderDataDocument(request);
}

Output:
     PubKeyValueType encryptionPubKeyValue;
-    X509DataType encryptionX509Data;
+    X509DataType encryptionX509Data = null;
     RSAKeyValueType encryptionRsaKeyValue;


Input:
public static AsyncHttpClient getAsyncHttpClient() {
    return asyncHttpClient;
}

Output:
 public static AsyncHttpClient getAsyncHttpClient() {
-    return asyncHttpClient;
+    return ASYNC_HTTP_CLIENT;
 }


Input:
public static Integer getPort(String fullHostname) {
    int pos = fullHostname.lastIndexOf("String_Node_Str");
    if (pos == -1) {
        try {
            return Integer.parseInt(fullHostname);
        } catch (NumberFormatException nfe) {
            return null;
        }
    } else {
        try {
            return Integer.parseInt(fullHostname.substring(pos + 1));
        } catch (NumberFormatException nfe) {
            return null;
        }
    }
}

Output:
     int pos = fullHostname.lastIndexOf("String_Node_Str");
-    if (pos == -1) {
+    int pos2 = fullHostname.lastIndexOf("String_Node_Str");
+    int lastMarker = Math.max(pos, pos2);
+    if (lastMarker == -1) {
         try {


Input:
public void resolve(List<String> historyTokens, AsyncCallback<Widget> callback) {
    gettingFilterResults = true;
    createPanel.setVisible(false);
    resultsPanel.setVisible(false);
    if (historyTokens.size() == 2) {
        filter = createFilterAndSubtitleFromHistoryTokens(historyTokens);
        String[] parts = RepresentationInformationUtils.breakFilterIntoParts(historyTokens.get(1));
        createPanelTitle.setHTML(messages.representationInformationNoAssociations(parts[0], parts[1], parts[2]));
        resultsPanelTitle.setHTML(messages.representationInformationAssociatedWith(parts[0], parts[1], parts[2]));
        description.setHTML(messages.representationInformationAssociatedWithDescription(parts[0], parts[1], parts[2]));
        addWithAssociationDialogTitle = messages.representationInformationAssociateWith(parts[0], parts[1], parts[2]);
        searchPanel.setDefaultFilter(filter, true);
        representationInformationList.setFilter(filter);
        searchPanel.clearSearchInputBox();
        callback.onSuccess(this);
    } else {
        HistoryUtils.newHistory(RESOLVER);
        callback.onSuccess(null);
    }
}

Output:
     if (historyTokens.size() == 2) {
-        filter = createFilterAndSubtitleFromHistoryTokens(historyTokens);
+        Filter filter = createFilterAndSubtitleFromHistoryTokens(historyTokens);
         String[] parts = RepresentationInformationUtils.breakFilterIntoParts(historyTokens.get(1));


Input:
public void testCopy() {
    final ParameterValueGroup source = DefaultParameterDescriptorGroupTest.M1_M1_O1_O2.createValue();
    final ParameterValue<?> o1 = source.parameter("String_Node_Str");
    final ParameterValue<?> o2 = o1.getDescriptor().createValue();
    source.parameter("String_Node_Str").setValue(20);
    source.values().add(o2);
    o1.setValue(40);
    o2.setValue(50);
    final ParameterValueGroup destination = DefaultParameterDescriptorGroupTest.M1_M1_O1_O2.createValue();
    destination.parameter("String_Node_Str").setValue(-10);
    destination.parameter("String_Node_Str").setValue(30);
    Parameters.copy(source, destination);
    assertEquals("String_Node_Str", 10, destination.parameter("String_Node_Str").intValue());
    assertEquals("String_Node_Str", 20, destination.parameter("String_Node_Str").intValue());
    assertEquals("String_Node_Str", 30, destination.parameter("String_Node_Str").intValue());
    assertEquals("String_Node_Str", 40, destination.parameter("String_Node_Str").intValue());
    assertEquals("String_Node_Str", 50, ((ParameterValue<?>) destination.values().get(4)).intValue());
}

Output:
 public void testCopy() {
-    final ParameterValueGroup source = DefaultParameterDescriptorGroupTest.M1_M1_O1_O2.createValue();
-    final ParameterValue<?> o1 = source.parameter("String_Node_Str");
+    final String subgroupName = DefaultParameterDescriptorGroupTest.M1_M1_O1_O2.getName().getCode();
+    final DefaultParameterDescriptorGroup descriptor = new DefaultParameterDescriptorGroup(Collections.singletonMap(DefaultParameterDescriptorGroup.NAME_KEY, "String_Node_Str"), 1, 1, DefaultParameterDescriptorTest.createSimpleOptional("String_Node_Str", String.class), DefaultParameterDescriptorGroupTest.M1_M1_O1_O2);
+    final ParameterValueGroup source = descriptor.createValue();
+    final ParameterValueGroup sourceSubgroup = source.addGroup(subgroupName);
+    final ParameterValue<?> o1 = sourceSubgroup.parameter("String_Node_Str");
     final ParameterValue<?> o2 = o1.getDescriptor().createValue();


Input:
public Object assignSequenceNumber(Object object, AbstractSession writeSession) throws DatabaseException {
    DatabaseField sequenceNumberField = this.descriptor.getSequenceNumberField();
    Object existingValue = getBaseValueForField(sequenceNumberField, object);
    if (existingValue != null) {
        if (!writeSession.getSequencing().shouldOverrideExistingValue(object.getClass(), existingValue)) {
            return null;
        }
    }
    Object sequenceValue = writeSession.getSequencing().getNextValue(object.getClass());
    writeSession.log(SessionLog.FINEST, SessionLog.SEQUENCING, "String_Node_Str", sequenceValue, object);
    if (sequenceValue == null) {
        return null;
    }
    AbstractRecord tempRow = createRecord(1);
    tempRow.put(sequenceNumberField, sequenceValue);
    ReadObjectQuery query = new ReadObjectQuery();
    query.setSession(writeSession);
    DatabaseMapping mapping = getBaseMappingForField(sequenceNumberField);
    Object sequenceIntoObject = getParentObjectForField(sequenceNumberField, object);
    Object convertedSequenceValue = mapping.readFromRowIntoObject(tempRow, null, sequenceIntoObject, query);
    clearPrimaryKey(object);
    return convertedSequenceValue;
}

Output:
     }
-    AbstractRecord tempRow = createRecord(1);
+    AbstractRecord tempRow = createRecord(1, writeSession);
     tempRow.put(sequenceNumberField, sequenceValue);


Input:
public static String getSAPValuesForFunction(SAPConnection conn, String functionLabel, String paramterName) {
    SAPFunctionUnit unit = null;
    if (conn == null) {
        return null;
    }
    for (int i = 0; i < conn.getFuntions().size(); i++) {
        unit = (SAPFunctionUnit) conn.getFuntions().get(i);
        if (unit.getLabel().equals(functionLabel)) {
            break;
        }
    }
    if (unit == null) {
        return null;
    }
    if (paramterName.equals("String_Node_Str")) {
        if (unit.getOutputType() != null) {
            return unit.getOutputType().replace("String_Node_Str", "String_Node_Str");
        }
    } else if (paramterName.equals("String_Node_Str")) {
        return TalendQuoteUtils.addQuotes(unit.getOutputTableName());
    }
    return null;
}

Output:
     for (int i = 0; i < conn.getFuntions().size(); i++) {
-        unit = (SAPFunctionUnit) conn.getFuntions().get(i);
+        unit = conn.getFuntions().get(i);
         if (unit.getLabel().equals(functionLabel)) {


Input:
public static void main(String[] args) throws IOException {
    createReportGenia(args[0], args[1], args[2], true, false, true, 2, 150, 1, 5, 50, 100, 500, 1000, 5000, 10000);
    System.out.println("String_Node_Str");
    System.out.println();
}

Output:
 public static void main(String[] args) throws IOException {
-    createReportGenia(args[0], args[1], args[2], true, false, true, 2, 150, 1, 5, 50, 100, 500, 1000, 5000, 10000);
-    System.out.println("String_Node_Str");
-    System.out.println();
+    if (args[3].equals("String_Node_Str")) {
+        createReportGenia(args[0], args[1], args[2], true, false, true, 2, 150, 1, 5, 50, 100, 500, 1000, 5000, 10000);
+        System.out.println("String_Node_Str");
+    } else {
+        createReportACLRD(args[0], args[1], args[2], true, false, true, 2, 150, 1, 5, 50, 100, 500, 1000, 5000, 10000);
+        System.out.println();
+    }
 }


Input:
public void read(String pu) {
    Properties properties = new Properties();
    puMetadata = KunderaMetadataManager.getPersistenceUnitMetadata(pu);
    hsmd.onInitialize();
    String propertyName = puMetadata != null ? puMetadata.getProperty(PersistenceProperties.KUNDERA_CLIENT_PROPERTY) : null;
    InputStream inStream = propertyName != null ? ClassLoader.getSystemResourceAsStream(propertyName) : null;
    if (inStream != null) {
        try {
            properties.load(inStream);
            readProperties(properties);
        } catch (IOException e) {
            log.warn("String_Node_Str" + e.getMessage());
            throw new KunderaException(e);
        }
    } else {
        log.warn("String_Node_Str");
    }
}

Output:
     String propertyName = puMetadata != null ? puMetadata.getProperty(PersistenceProperties.KUNDERA_CLIENT_PROPERTY) : null;
-    InputStream inStream = propertyName != null ? ClassLoader.getSystemResourceAsStream(propertyName) : null;
+    InputStream inStream = propertyName != null ? Thread.currentThread().getContextClassLoader().getResourceAsStream(propertyName) : null;
     if (inStream != null) {


Input:
public void insertClock() throws ChangeFailedException {
    ChangeRequest change = new ChangeRequest(_top, "String_Node_Str") {
        public void _execute() throws ChangeFailedException {
            try {
                _clock.output.unlinkAll();
                _rec.input.unlinkAll();
                Clock clock2 = new Clock(_top, "String_Node_Str");
                clock2.values.setExpression("String_Node_Str");
                clock2.offsets.setExpression("String_Node_Str");
                clock2.period.setExpression("String_Node_Str");
                Merge merge = new Merge(_top, "String_Node_Str");
                _top.connect(_clock.output, merge.input);
                _top.connect(clock2.output, merge.input);
                _top.connect(merge.output, _rec.input);
                _rec.input.createReceivers();
            } catch (IllegalActionException ex) {
                throw new ChangeFailedException(this, ex);
            } catch (NameDuplicationException ex) {
                throw new ChangeFailedException(this, ex);
            }
        }
    };
    manager.requestChange(change);
}

Output:
     };
-    manager.requestChange(change);
+    _top.requestChange(change);
 }


Input:
private void populateTimeMirror() throws IOException {
    MemberTreeNode parent;
    MemberTreeNode child;
    Object[] preValue = new Object[rs.getLevelCount()];
    Object[] currValue = new Object[rs.getLevelCount()];
    final int sortType = this.getSortTypeOnMirroredLevel(this.mirrorLevel);
    if (sortType != IDimensionSortDefn.SORT_UNDEFINED) {
        noBreakHierarchyKeyMap = new TreeMap(new Comparator() {
            public int compare(final Object arg0, final Object arg1) {
                if (sortType == IDimensionSortDefn.SORT_ASC)
                    return ((Comparable) arg0).compareTo(arg1);
                else
                    return ((Comparable) arg0).compareTo(arg1) * -1;
            }
        });
    } else {
        noBreakHierarchyKeyMap = new HashMap();
    }
    for (int i = 0; i < rs.length(); i++) {
        rs.seek(i);
        parent = this.rootNode;
        for (int j = 0; j < rs.getLevelCount(); j++) {
            currValue[j] = rs.getLevelKeyValue(j)[0];
        }
        for (int j = 0; j < this.mirrorLevel; j++) {
            if (!isEqualObject(preValue[j], currValue[j])) {
                Member member = new Member();
                member.setKeyValues(new Object[] { currValue[j] });
                member.setAttributes(rs.getLevelAttributesValue(j));
                child = new MemberTreeNode(member);
                parent.insertNode(child);
                child.parentNode = parent;
                parent = child;
            } else {
                if (parent.childNodesList.size() > 0)
                    parent = (MemberTreeNode) parent.childNodesList.get(parent.childNodesList.size() - 1);
                else {
                    Member member = new Member();
                    member.setKeyValues(new Object[] { currValue[j] });
                    member.setAttributes(rs.getLevelAttributesValue(j));
                    child = new MemberTreeNode(member);
                    parent.insertNode(child);
                    child.parentNode = parent;
                    parent = child;
                }
            }
        }
        Member mirrorMember = new Member();
        mirrorMember.setKeyValues(new Object[] { currValue[this.mirrorLevel] });
        mirrorMember.setAttributes(rs.getLevelAttributesValue(this.mirrorLevel));
        if (noBreakHierarchyKeyMap.containsKey(mirrorMember)) {
            MemberTreeNode node = (MemberTreeNode) noBreakHierarchyKeyMap.get(mirrorMember);
            for (int j = this.mirrorLevel + 1; j < this.rs.getLevelCount(); j++) {
                Member member = new Member();
                member.setKeyValues(new Object[] { currValue[j] });
                member.setAttributes(rs.getLevelAttributesValue(j));
                if (!node.containsChild(member)) {
                    if (TimeMemberUtil.isTimeMirror(rs, j)) {
                        break;
                    } else {
                        MemberTreeNode childNode = new MemberTreeNode(member);
                        node.insertNode(childNode);
                        childNode.parentNode = node;
                        node = childNode;
                    }
                } else {
                    node = node.getChild(member);
                }
            }
        } else {
            MemberTreeNode parentNode = null;
            for (int j = this.mirrorLevel; j < this.rs.getLevelCount(); j++) {
                if (TimeMemberUtil.isTimeMirror(rs, j)) {
                    MemberTreeNode[] nodes = TimeMemberUtil.getDateTimeNodes(rs.getAttributeNames(), rs.getLevelAttribute(j, 0), j);
                    for (int k = 0; k < nodes.length; k++) {
                        if (parentNode == null) {
                            noBreakHierarchyKeyMap.put(nodes[k].key, nodes[k]);
                        } else
                            parentNode.insertNode(nodes[k]);
                        nodes[k].parentNode = parentNode;
                    }
                    break;
                } else {
                    if (parentNode == null) {
                        Member member = new Member();
                        member.setKeyValues(new Object[] { currValue[j] });
                        member.setAttributes(rs.getLevelAttributesValue(j));
                        parentNode = new MemberTreeNode(member);
                        noBreakHierarchyKeyMap.put(mirrorMember, parentNode);
                    } else {
                        Member member = new Member();
                        member.setKeyValues(new Object[] { currValue[j] });
                        member.setAttributes(rs.getLevelAttributesValue(j));
                        MemberTreeNode childNode = new MemberTreeNode(member);
                        parentNode.insertNode(childNode);
                        childNode.parentNode = parentNode;
                        parentNode = childNode;
                    }
                }
            }
        }
        for (int k = 0; k < rs.getLevelCount(); k++) {
            preValue[k] = currValue[k];
        }
    }
    int level = mirrorLevel + 1;
    List nodeList1 = new ArrayList();
    nodeList1.addAll(noBreakHierarchyKeyMap.values());
    for (int k = mirrorLevel + 1; k < rs.getLevelCount(); k++) {
        final int childSortType = this.getSortTypeOnMirroredLevel(k);
        List nodeList2 = new ArrayList();
        if (sortType != IDimensionSortDefn.SORT_UNDEFINED) {
            while (k > level) {
                for (int j = 0; j < nodeList1.size(); j++) {
                    nodeList2.addAll(((MemberTreeNode) nodeList1.get(j)).childNodesList);
                }
                nodeList1.clear();
                nodeList1.addAll(nodeList2);
                nodeList2.clear();
                level++;
            }
            for (int j = 0; j < nodeList1.size(); j++) {
                MemberTreeNode node = (MemberTreeNode) nodeList1.get(j);
                Collections.sort(node.childNodesList, new Comparator() {
                    public int compare(final Object arg0, final Object arg1) {
                        if (childSortType == IDimensionSortDefn.SORT_ASC)
                            return ((Comparable) ((MemberTreeNode) arg0).key).compareTo(((MemberTreeNode) arg1).key);
                        else
                            return ((Comparable) ((MemberTreeNode) arg0).key).compareTo(((MemberTreeNode) arg1).key) * -1;
                    }
                });
            }
        }
    }
}

Output:
                 if (!node.containsChild(member)) {
-                    if (TimeMemberUtil.isTimeMirror(rs, j)) {
+                    if (TimeMemberUtil.isTimeMirror(rs, j, service)) {
                         break;


Input:
public boolean canProcessExecutionFailure(Exception e) {
    if (e.getCause() != null && e.getCause() instanceof CloudbreakOrchestratorException) {
        return !((CloudbreakOrchestratorException) e.getCause()).getNodesWithErrors().isEmpty();
    } else if (e.getCause() != null && e.getCause().getCause() != null && e.getCause().getCause() instanceof CloudbreakOrchestratorException) {
        return !((CloudbreakOrchestratorException) e.getCause().getCause()).getNodesWithErrors().isEmpty();
    }
    return false;
}

Output:
 public boolean canProcessExecutionFailure(Exception e) {
-    if (e.getCause() != null && e.getCause() instanceof CloudbreakOrchestratorException) {
-        return !((CloudbreakOrchestratorException) e.getCause()).getNodesWithErrors().isEmpty();
-    } else if (e.getCause() != null && e.getCause().getCause() != null && e.getCause().getCause() instanceof CloudbreakOrchestratorException) {
-        return !((CloudbreakOrchestratorException) e.getCause().getCause()).getNodesWithErrors().isEmpty();
-    }
-    return false;
+    return getNodesWithErrors(e).isPresent() && e.getMessage().contains("String_Node_Str");
 }


Input:
default boolean isBrowser() {
    Object browserName = getSessionDetail("String_Node_Str");
    return ofNullable(browserName != null ? String.valueOf(browserName) : null).orElse(null) != null;
}

Output:
     Object browserName = getSessionDetail("String_Node_Str");
-    return ofNullable(browserName != null ? String.valueOf(browserName) : null).orElse(null) != null;
+    return browserName != null && !isBlank(String.valueOf(browserName));
 }


Input:
private static void postEvent(Event e) {
    try {
        eventPhase.set(e, null);
    } catch (IllegalArgumentException | IllegalAccessException e1) {
        throw (new RuntimeException(e1));
    }
    RiMRegistry.blockMoveBus.post(e);
}

Output:
         eventPhase.set(e, null);
-    } catch (IllegalArgumentException | IllegalAccessException e1) {
+    } catch (IllegalArgumentException e1) {
+        throw (new RuntimeException(e1));
+    } catch (IllegalAccessException e1) {
         throw (new RuntimeException(e1));


Input:
private void updateKeyCount() {
    int keyCount;
    long timestamp = clock.getTicks();
    while (true) {
        long seq = this.keyMem.getLong(BitmapIndexUtils.KEY_RESERVED_OFFSET_SEQUENCE);
        Unsafe.getUnsafe().loadFence();
        keyCount = this.keyMem.getInt(BitmapIndexUtils.KEY_RESERVED_OFFSET_KEY_COUNT);
        Unsafe.getUnsafe().loadFence();
        if (this.keyMem.getLong(BitmapIndexUtils.KEY_RESERVED_OFFSET_SEQUENCE_CHECK) == seq) {
            break;
        }
        if (clock.getTicks() - timestamp > spinLockTimeoutUs) {
            this.keyCount = 0;
            LOG.error().$("String_Node_Str").$(spinLockTimeoutUs).utf8("String_Node_Str").$();
            throw CairoException.instance(0).put("String_Node_Str");
        }
    }
    if (keyCount > this.keyCount) {
        this.keyCount = keyCount;
    }
}

Output:
     int keyCount;
-    long timestamp = clock.getTicks();
+    final long deadline = clock.getTicks() + spinLockTimeoutUs;
     while (true) {


Input:
public void customize() {
    Map<String, Object> ports = new HashMap<String, Object>();
    ports.put("String_Node_Str", entity.getAttribute(BindDnsServer.DNS_PORT));
    NetworkUtils.checkPortsValid(ports);
    newScript(MutableMap.of("String_Node_Str", "String_Node_Str"), CUSTOMIZING).body.append(CommonCommands.sudo("String_Node_Str"), CommonCommands.sudo("String_Node_Str"), CommonCommands.sudo("String_Node_Str")).execute();
}

Output:
 public void customize() {
-    Map<String, Object> ports = new HashMap<String, Object>();
-    ports.put("String_Node_Str", entity.getAttribute(BindDnsServer.DNS_PORT));
+    Integer dnsPort = getEntity().getDnsPort();
+    Map<String, Object> ports = MutableMap.<String, Object>of("String_Node_Str", dnsPort);
     NetworkUtils.checkPortsValid(ports);


Input:
public static void main(String[] args) {
    Class type = ImageUInt8.class;
    VideoPolygonDetectionApp app = new VideoPolygonDetectionApp(type);
    app.setBaseDirectory("String_Node_Str");
    app.loadInputData("String_Node_Str");
    while (!app.getHasProcessedImage()) {
        Thread.yield();
    }
    ShowImages.showWindow(app, "String_Node_Str");
}

Output:
     }
-    ShowImages.showWindow(app, "String_Node_Str");
+    ShowImages.showWindow(app, "String_Node_Str", true);
 }


Input:
String getZkRequestStatePath(final String sidelineIdentifierStr, final int partitionId) {
    return getZkRoot() + "String_Node_Str" + sidelineIdentifierStr + "String_Node_Str" + partitionId;
}

Output:
 String getZkRequestStatePath(final String sidelineIdentifierStr, final int partitionId) {
-    return getZkRoot() + "String_Node_Str" + sidelineIdentifierStr + "String_Node_Str" + partitionId;
+    return getZkRequestStatePath(sidelineIdentifierStr) + "String_Node_Str" + partitionId;
 }


Input:
protected void initSocialize() {
    SocializeUI.getInstance().initSocialize(context);
}

Output:
 protected void initSocialize() {
-    SocializeUI.getInstance().initSocialize(context);
+    SocializeUI.getInstance().initSocialize(getContext());
 }


Input:
protected BluetoothAdapter getBluetoothAdapter() {
    if (mBluetoothAdapter == null) {
        final BluetoothManager bluetoothManager = (BluetoothManager) mContext.getApplicationContext().getSystemService(Context.BLUETOOTH_SERVICE);
        mBluetoothAdapter = bluetoothManager.getAdapter();
        if (mBluetoothAdapter == null) {
            LogManager.w(TAG, "String_Node_Str");
        }
    }
    return mBluetoothAdapter;
}

Output:
 protected BluetoothAdapter getBluetoothAdapter() {
-    if (mBluetoothAdapter == null) {
-        final BluetoothManager bluetoothManager = (BluetoothManager) mContext.getApplicationContext().getSystemService(Context.BLUETOOTH_SERVICE);
-        mBluetoothAdapter = bluetoothManager.getAdapter();
+    try {
         if (mBluetoothAdapter == null) {


Input:
public void wakeEvents(final int count, final ProcedureEvent... events) {
    final boolean traceEnabled = LOG.isTraceEnabled();
    schedLock();
    try {
        int waitingCount = 0;
        for (int i = 0; i < count; ++i) {
            final ProcedureEvent event = events[i];
            synchronized (event) {
                if (!event.isReady()) {
                    event.setReady(true);
                    if (traceEnabled) {
                        LOG.trace("String_Node_Str" + event);
                    }
                    waitingCount += wakeWaitingProcedures(event.getSuspendedProcedures());
                } else {
                    ProcedureDeque q = event.getSuspendedProcedures();
                    if (q != null && !q.isEmpty()) {
                        LOG.warn("String_Node_Str" + q.size() + "String_Node_Str");
                        waitingCount += wakeWaitingProcedures(event.getSuspendedProcedures());
                    }
                }
            }
        }
        wakePollIfNeeded(waitingCount);
    } finally {
        schedUnlock();
    }
}

Output:
     try {
-        int waitingCount = 0;
-        for (int i = 0; i < count; ++i) {
-            final ProcedureEvent event = events[i];
-            synchronized (event) {
-                if (!event.isReady()) {
-                    event.setReady(true);
-                    if (traceEnabled) {
-                        LOG.trace("String_Node_Str" + event);
-                    }
-                    waitingCount += wakeWaitingProcedures(event.getSuspendedProcedures());
-                } else {
-                    ProcedureDeque q = event.getSuspendedProcedures();
-                    if (q != null && !q.isEmpty()) {
-                        LOG.warn("String_Node_Str" + q.size() + "String_Node_Str");
-                        waitingCount += wakeWaitingProcedures(event.getSuspendedProcedures());
-                    }
-                }
+        for (ProcedureEvent event : events) {
+            if (event == null) {
+                continue;
             }


Input:
public final boolean zoomOut() {
    if (info.bStepFixed || this.getTickCordinates().size() < 3) {
        return false;
    }
    Object oStep = context.getStep();
    if (((Number) oStep).doubleValue() >= Double.MAX_VALUE) {
        return false;
    }
    if ((info.type & NUMERICAL) == NUMERICAL) {
        if ((info.type & LOGARITHMIC) == LOGARITHMIC) {
            final double dStep = asDouble(oStep).doubleValue();
            if ((Math.log(dStep) / LOG_10) >= 1) {
                setStep(new Double(dStep * 10));
            } else {
                final int n = iaLogarithmicDeltas.length;
                for (int i = 0; i < n; i++) {
                    if ((int) dStep == iaLogarithmicDeltas[i]) {
                        setStep(new Double(iaLogarithmicDeltas[i + 1]));
                        return true;
                    }
                }
                return false;
            }
        } else if ((info.type & LINEAR) == LINEAR) {
            if (asDouble(context.getMin()).doubleValue() * asDouble(context.getMax()).doubleValue() < 0 && this.getTickCordinates().size() <= 3) {
                return false;
            }
            double dStep = asDouble(oStep).doubleValue();
            double dPower = Math.log10(dStep);
            if (dPower < 0) {
                dPower = Math.floor(dPower);
                dPower = Math.pow(10, dPower);
            } else {
                dPower = dStep;
            }
            dStep /= dPower;
            dStep = Math.round(dStep);
            int n = iaLinearDeltas.length;
            int i = 0;
            for (; i < n; i++) {
                if (dStep < iaLinearDeltas[i]) {
                    dStep = iaLinearDeltas[i] * dPower;
                    break;
                }
            }
            if (i == n) {
                dPower *= 20;
                dStep = iaLinearDeltas[0] * dPower;
            }
            if (((Number) oStep).doubleValue() == dStep) {
                return false;
            }
            dStep = ChartUtil.alignWithInt(dStep, false);
            setStep(new Double(dStep));
        }
    } else if ((info.type & DATE_TIME) == DATE_TIME) {
        int[] ia = null;
        int iStep = asInteger(oStep);
        int iUnit = asInteger(context.getUnit());
        for (int icu = 0; icu < iaCalendarUnits.length; icu++) {
            if (iUnit == iaCalendarUnits[icu]) {
                ia = iaCalendarDeltas[icu];
                if (ia == null) {
                    iStep++;
                    setStep(Integer.valueOf(iStep));
                } else {
                    int i = 0, n = ia.length;
                    for (; i < n; i++) {
                        if (ia[i] == iStep) {
                            break;
                        }
                    }
                    if (i == n - 1) {
                        ia = iaCalendarDeltas[icu + 1];
                        context.setUnit(Integer.valueOf(iaCalendarUnits[icu + 1]));
                        if (ia == null) {
                            setStep(Integer.valueOf(1));
                            return true;
                        }
                        i = -1;
                    }
                    setStep(Integer.valueOf(ia[i + 1]));
                    break;
                }
            }
        }
    }
    return true;
}

Output:
             }
-            if (((Number) oStep).doubleValue() == dStep) {
+            if (ChartUtil.mathEqual(((Number) oStep).doubleValue(), dStep)) {
                 return false;