Input:
public void creatPart(Map<String, String[]> attrsValuesAvailableMap, Map<String, String> attrsToolTipsMap) {
    GridData gd = null;
    if ((!nodeData.isHasTreeAttr()) && (!nodeData.isHasChildTreeNode())) {
        Label label = new Label(this, SWT.NONE);
        label.setText(nodeData.getXMLNode().getNodeName() + MARK);
        gd = new GridData();
        gd.horizontalSpan = 2;
        label.setLayoutData(gd);
        final Text nodeText = new Text(this, SWT.BORDER | SWT.MULTI | SWT.WRAP);
        gd = new GridData(GridData.FILL_BOTH);
        gd.horizontalSpan = 2;
        nodeText.setLayoutData(gd);
        nodeText.setText(nodeData.getBodayText());
        nodeText.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                nodeData.getXMLNode().setTextContent(nodeText.getText());
                nodeData.setBodayText(nodeText.getText());
            }
        });
    } else {
        for (Object attrName : nodeData.getTreeAttrNames()) {
            final Label attrLabel = new Label(this, SWT.NONE);
            attrLabel.setText(attrName + MARK);
            attrLabel.setLayoutData(new GridData());
            String[] valuesArray = attrsValuesAvailableMap.get(attrName);
            String tooTipsText = attrsToolTipsMap.get(attrName);
            if (valuesArray == null) {
                final Text attrText = new Text(this, SWT.BORDER);
                gd = new GridData(GridData.FILL_HORIZONTAL);
                attrText.setLayoutData(gd);
                if (nodeData.getAttrValue((String) attrName) != null) {
                    attrText.setText(nodeData.getAttrValue((String) attrName));
                }
                if (tooTipsText != null) {
                    attrText.setToolTipText(tooTipsText);
                }
                attrText.addModifyListener(new ModifyListener() {
                    public void modifyText(ModifyEvent e) {
                        String attrName = attrLabel.getText().split(MARK)[0];
                        if (attrText.getText().equals(PluginConstant.EMPTY_STRING)) {
                            ((Element) nodeData.getXMLNode()).removeAttribute(attrName);
                            nodeData.removeAttrValue(attrName);
                        } else {
                            ((Element) nodeData.getXMLNode()).setAttribute(attrName, attrText.getText());
                            nodeData.putAttrValue(attrName, attrText.getText());
                        }
                    }
                });
            } else {
                final Combo attrCombo = new Combo(this, SWT.BORDER);
                gd = new GridData(GridData.FILL_HORIZONTAL);
                attrCombo.setLayoutData(gd);
                attrCombo.setItems(valuesArray);
                String attrValue = nodeData.getAttrValue((String) attrName);
                if (attrValue != null) {
                    int index = -1;
                    for (int i = 0; i < valuesArray.length; i++) {
                        if (valuesArray[i].equals(attrValue)) {
                            index = i;
                            break;
                        }
                    }
                    if (index == -1) {
                        attrCombo.setText(attrValue);
                    } else {
                        attrCombo.select(index);
                    }
                }
                if (tooTipsText != null) {
                    attrCombo.setToolTipText(tooTipsText);
                }
                attrCombo.addModifyListener(new ModifyListener() {
                    public void modifyText(ModifyEvent e) {
                        String attrName = attrLabel.getText().split(MARK)[0];
                        if (attrCombo.getText().equals(PluginConstant.EMPTY_STRING)) {
                            ((Element) nodeData.getXMLNode()).removeAttribute(attrName);
                            nodeData.removeAttrValue(attrName);
                        } else {
                            ((Element) nodeData.getXMLNode()).setAttribute(attrName, attrCombo.getText());
                            nodeData.putAttrValue(attrName, attrCombo.getText());
                        }
                    }
                });
            }
        }
    }
}

Output:
         label.setLayoutData(gd);
-        final Text nodeText = new Text(this, SWT.BORDER | SWT.MULTI | SWT.WRAP);
+        final Text nodeText = new Text(this, SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
         gd = new GridData(GridData.FILL_BOTH);


Input:
private final void renderHorizontalText(IChartComputation cComp, GC gc, Label la, double dX, double dY) {
    final FontDefinition fd = la.getCaption().getFont();
    final Color clrText = (Color) _sxs.getColor(la.getCaption().getColor());
    final ITextMetrics itm = cComp.getTextMetrics(_sxs, la, 0);
    final double dFW = itm.getFullWidth();
    final double dH = itm.getHeight();
    final double dFH = itm.getFullHeight();
    double dXOffset = 0;
    double dW = 0;
    final Insets ins = goFactory.scaleInsets(la.getInsets(), _sxs.getDpiResolution() / 72d);
    final HorizontalAlignment ha = la.getCaption().getFont().getAlignment().getHorizontalAlignment();
    final boolean bRightAligned = ha.getValue() == HorizontalAlignment.RIGHT;
    final boolean bCenterAligned = ha.getValue() == HorizontalAlignment.CENTER;
    final Rectangle r;
    Object tr = null;
    Object rtr = null;
    Region previousClipping = null;
    if (R31Enhance.isR31Available()) {
        r = new Rectangle(0, 0, (int) dFW, (int) dFH);
        tr = R31Enhance.newTransform(getDevice());
        rtr = R31Enhance.newTransform(getDevice());
        if (la.getCaption().getFont().getRotation() != 0) {
            float rotate = (float) la.getCaption().getFont().getRotation();
            double dAngleInRadians = ((-rotate * Math.PI) / 180.0);
            double dSineTheta = Math.sin(dAngleInRadians);
            float tTx = (float) (dX - dFW / 2);
            float tTy = (float) (dY - dFH / 2);
            if (rotate > 0)
                tTy += dFW * Math.abs(dSineTheta);
            else
                tTx += dFH * Math.abs(dSineTheta);
            R31Enhance.translate(gc, tr, (float) (dFW / 2), (float) (dFH / 2));
            R31Enhance.translate(gc, tr, tTx, tTy);
            R31Enhance.rotate(gc, tr, -rotate);
            R31Enhance.rotate(gc, rtr, rotate);
            R31Enhance.translate(gc, rtr, -tTx, -tTy);
            R31Enhance.translate(gc, rtr, (float) (-dFW / 2), (float) (-dFH / 2));
        } else {
            R31Enhance.translate(gc, tr, (float) dX, (float) dY);
            R31Enhance.translate(gc, rtr, (float) -dX, (float) -dY);
        }
        previousClipping = new Region();
        gc.getClipping(previousClipping);
        R31Enhance.setTransform(gc, tr);
    } else {
        r = new Rectangle((int) dX, (int) dY, (int) dFW, (int) dFH);
    }
    boolean bFullyTransparent = true;
    if (la.getBackground() != null) {
        bFullyTransparent = (((ColorDefinition) la.getBackground()).getTransparency() == 0);
        R31Enhance.setAlpha(gc, 255);
    }
    if (!bFullyTransparent) {
        final Color clrBackground = (Color) _sxs.getColor((ColorDefinition) la.getBackground());
        final Color clrPreviousBackground = gc.getBackground();
        if (((ColorDefinition) la.getBackground()).isSetTransparency()) {
            R31Enhance.setAlpha(gc, (ColorDefinition) la.getBackground());
        }
        gc.setBackground(clrBackground);
        gc.fillRectangle(r);
        clrBackground.dispose();
        gc.setBackground(clrPreviousBackground);
    }
    gc.setForeground(clrText);
    R31Enhance.setAlpha(gc, la.getCaption().getColor());
    final Font f = (Font) _sxs.createFont(fd);
    gc.setFont(f);
    if (fd.isUnderline() || fd.isStrikethrough()) {
        int lineWidth = (int) (fd.getSize() / 12);
        gc.setLineWidth(lineWidth);
    }
    if (R31Enhance.isR31Available()) {
        for (int i = 0; i < itm.getLineCount(); i++) {
            String oText = itm.getLine(i);
            dW = gc.textExtent(oText).x;
            if (bRightAligned) {
                dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
            } else if (bCenterAligned) {
                dXOffset = -ins.getLeft() + (dFW - dW) / 2;
            }
            gc.drawText(oText, (int) (dXOffset + ins.getLeft()), (int) (dH * i + ins.getTop()), true);
            if (fd.isUnderline()) {
                gc.drawLine((int) (dXOffset + ins.getLeft()), (int) (dH * (i + 1) + ins.getTop()), (int) (dXOffset + ins.getLeft() + dW), (int) (dH * (i + 1) + ins.getTop()));
            }
            if (fd.isStrikethrough()) {
                gc.drawLine((int) (dXOffset + ins.getLeft()), (int) (dH * (i + 0.5) + ins.getTop()), (int) (dXOffset + ins.getLeft() + dW), (int) (dH * (i + 0.5) + ins.getTop()));
            }
        }
    } else {
        for (int i = 0; i < itm.getLineCount(); i++) {
            String oText = itm.getLine(i);
            dW = gc.textExtent(oText).x;
            if (bRightAligned) {
                dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
            } else if (bCenterAligned) {
                dXOffset = -ins.getLeft() + (dFW - dW) / 2;
            }
            gc.drawText(oText, (int) (dX + dXOffset + ins.getLeft()), (int) (dY + dH * i + ins.getTop()), true);
            if (fd.isUnderline()) {
                gc.drawLine((int) (dX + dXOffset + ins.getLeft()), (int) (dY + dH * (i + 1) + ins.getTop()), (int) (dX + dXOffset + ins.getLeft() + dW), (int) (dY + dH * (i + 1) + ins.getTop()));
            }
            if (fd.isStrikethrough()) {
                gc.drawLine((int) (dX + dXOffset + ins.getLeft()), (int) (dY + dH * (i + 0.5) + ins.getTop()), (int) (dX + dXOffset + ins.getLeft() + dW), (int) (dY + dH * (i + 0.5) + ins.getTop()));
            }
        }
    }
    R31Enhance.setTransform(gc, rtr);
    R31Enhance.setTransform(gc, null);
    if (previousClipping != null) {
        gc.setClipping(previousClipping);
        previousClipping.dispose();
    }
    R31Enhance.disposeTransform(rtr);
    R31Enhance.disposeTransform(tr);
    f.dispose();
    clrText.dispose();
    cComp.recycleTextMetrics(itm);
}

Output:
     final Rectangle r;
-    Object tr = null;
-    Object rtr = null;
+    Transform tr = null;
+    Transform trOld = new Transform(getDevice());
+    gc.getTransform(trOld);
     Region previousClipping = null;


Input:
public void testAllocateAndClear() throws Exception {
    assertWithPool(pool -> {
        int n = 2;
        final CyclicBarrier barrier = new CyclicBarrier(n);
        final CountDownLatch halt = new CountDownLatch(n);
        final AtomicInteger errors1 = new AtomicInteger();
        final AtomicInteger errors2 = new AtomicInteger();
        final AtomicInteger writerCount = new AtomicInteger();
        new Thread(() -> {
            try {
                for (int i = 0; i < 1000; i++) {
                    try (TableWriter ignored = pool.get("String_Node_Str")) {
                        writerCount.incrementAndGet();
                    } catch (EntryUnavailableException ignored) {
                    }
                    if (i == 1) {
                        barrier.await();
                    } else {
                        LockSupport.parkNanos(1L);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                errors1.incrementAndGet();
            } finally {
                halt.countDown();
            }
        }).start();
        new Thread(() -> {
            try {
                barrier.await();
                for (int i = 0; i < 1000; i++) {
                    pool.releaseInactive();
                    LockSupport.parkNanos(1L);
                }
            } catch (Exception e) {
                e.printStackTrace();
                errors2.incrementAndGet();
            } finally {
                halt.countDown();
            }
        }).start();
        halt.await();
        Assert.assertTrue(writerCount.get() > 0);
        Assert.assertEquals(0, errors1.get());
        Assert.assertEquals(0, errors2.get());
    });
}

Output:
             try {
-                for (int i = 0; i < 1000; i++) {
+                for (int i = 0; i < 1000000; i++) {
                     try (TableWriter ignored = pool.get("String_Node_Str")) {


Input:
public void testVersion(String type) {
    ValidatableResponse vr = callEndpoint(type);
    vr.body("String_Node_Str", equalTo("String_Node_Str"));
}

Output:
     ValidatableResponse vr = callEndpoint(type);
-    vr.body("String_Node_Str", equalTo("String_Node_Str"));
+    vr.body("String_Node_Str", startsWith("String_Node_Str"));
 }


Input:
void doRun() throws EngineException {
    doValidateParameters();
    setupRenderOption();
    loadDesign();
    prepareDesign();
    startFactory();
    startRender();
    try {
        IContentEmitter emitter = createContentEmitter();
        IReportExecutor executor = new ReportExecutor(executionContext);
        executor = new SuppressDuplciateReportExecutor(executor);
        executor = new LocalizedReportExecutor(executionContext, executor);
        executionContext.setExecutor(executor);
        initializeContentEmitter(emitter, executor);
        String format = executionContext.getOutputFormat();
        boolean paginate = true;
        if (FORMAT_HTML.equalsIgnoreCase(format)) {
            HTMLRenderOption htmlOption = new HTMLRenderOption(renderOptions);
            paginate = htmlOption.getHtmlPagination();
        }
        if (ExtensionManager.NO_PAGINATION.equals(pagination)) {
            paginate = false;
        }
        synchronized (this) {
            if (!executionContext.isCanceled()) {
                layoutEngine = createReportLayoutEngine(pagination, renderOptions);
            }
        }
        if (layoutEngine != null) {
            layoutEngine.setLocale(executionContext.getLocale());
            CompositeLayoutPageHandler layoutPageHandler = new CompositeLayoutPageHandler();
            OnPageBreakLayoutPageHandle handle = new OnPageBreakLayoutPageHandle(executionContext);
            layoutPageHandler.addPageHandler(handle);
            layoutPageHandler.addPageHandler(new ContextPageBreakHandler(executionContext));
            layoutEngine.setPageHandler(layoutPageHandler);
            CompositeContentEmitter outputEmitters = new CompositeContentEmitter(format);
            outputEmitters.addEmitter(emitter);
            outputEmitters.addEmitter(handle.getEmitter());
            IReportContent report = executor.execute();
            outputEmitters.start(report);
            layoutEngine.layout(executor, report, outputEmitters, paginate);
            layoutEngine.close();
            outputEmitters.end(report);
        }
        closeRender();
        executionContext.closeDataEngine();
        closeFactory();
    } catch (EngineException e) {
        throw e;
    } catch (Exception ex) {
        log.log(Level.SEVERE, "String_Node_Str", ex);
        throw new EngineException("String_Node_Str", ex);
    } catch (OutOfMemoryError err) {
        log.log(Level.SEVERE, "String_Node_Str");
        throw err;
    } catch (Throwable t) {
        log.log(Level.SEVERE, "String_Node_Str", t);
        throw new EngineException("String_Node_Str", t);
    }
}

Output:
         log.log(Level.SEVERE, "String_Node_Str", ex);
-        throw new EngineException("String_Node_Str", ex);
+        throw new EngineException(MessageConstants.REPORT_RUN_ERROR, ex);
     } catch (OutOfMemoryError err) {


Input:
public String toString() {
    if (eIsProxy())
        return super.toString();
    StringBuffer result = new StringBuffer(super.toString());
    result.append("String_Node_Str");
    result.append(name);
    result.append("String_Node_Str");
    result.append(extension);
    result.append(')');
    return result.toString();
}

Output:
 public String toString() {
-    if (eIsProxy())
+    if (eIsProxy()) {
         return super.toString();


Input:
public String toCSVString(boolean isFullLog) {
    StringBuilder result = new StringBuilder();
    LogTableColumnModel columnModel = LoggerPlusPlus.getInstance().getLogTable().getColumnModel();
    ArrayList<LogTableColumn> columns = columnModel.getAllColumns();
    Collections.sort(columns);
    short count = 0;
    for (LogTableColumn logTableColumn : columns) {
        if (logTableColumn.isVisible() && logTableColumn.isEnabled()) {
            result.append(StringEscapeUtils.escapeCsv(getValue(logTableColumn.getIdentifier()).toString()));
            if (count < columnModel.getColumnCount() - 1)
                result.append("String_Node_Str");
        }
        count++;
    }
    if (isFullLog) {
        result.append("String_Node_Str");
        if (requestResponse != null && requestResponse.getRequest() != null)
            result.append(StringEscapeUtils.escapeCsv(new String(requestResponse.getRequest())));
        result.append("String_Node_Str");
        if (requestResponse != null && requestResponse.getResponse() != null)
            result.append(StringEscapeUtils.escapeCsv(new String(requestResponse.getResponse())));
    }
    return result.toString();
}

Output:
     Collections.sort(columns);
-    short count = 0;
+    boolean firstDone = false;
     for (LogTableColumn logTableColumn : columns) {


Input:
public byte[] toKey(IdService idService) throws IOException {
    List<Dimension<?>> dimensions = cube.getDimensions();
    boolean sawOnlyWildcardsSoFar = true;
    List<byte[]> reversedKeyElems = Lists.newArrayListWithCapacity(dimensions.size());
    for (int i = dimensions.size() - 1; i >= 0; i--) {
        Dimension<?> dimension = dimensions.get(i);
        BucketTypeAndBucket bucketAndCoord = buckets.get(dimension);
        int thisDimBucketLen = dimension.getNumFieldBytes();
        int thisDimBucketTypeLen = dimension.getBucketPrefixSize();
        if (bucketAndCoord == BucketTypeAndBucket.WILDCARD || bucketAndCoord == null) {
            if (sawOnlyWildcardsSoFar) {
                continue;
            }
            reversedKeyElems.add(new byte[thisDimBucketTypeLen + thisDimBucketLen]);
            reversedKeyElems.add(WILDCARD_FIELD);
        } else {
            sawOnlyWildcardsSoFar = false;
            byte[] elem;
            if (idService == null || !dimension.getDoIdSubstitution()) {
                elem = bucketAndCoord.bucket;
            } else {
                int dimensionNum = cube.getDimensions().indexOf(dimension);
                elem = idService.getId(dimensionNum, bucketAndCoord.bucket, dimension.getNumFieldBytes());
            }
            if (elem.length != thisDimBucketLen) {
                throw new IllegalArgumentException("String_Node_Str" + "String_Node_Str" + dimension + "String_Node_Str" + dimension.getNumFieldBytes() + "String_Node_Str" + bucketAndCoord.bucket.length);
            }
            byte[] bucketTypeId = bucketAndCoord.bucketType.getUniqueId();
            if (bucketTypeId.length != thisDimBucketTypeLen) {
                throw new RuntimeException("String_Node_Str" + dimension + "String_Node_Str" + dimension.getBucketPrefixSize() + "String_Node_Str" + Arrays.toString(bucketTypeId) + "String_Node_Str" + bucketTypeId.length);
            }
            reversedKeyElems.add(bucketAndCoord.bucket);
            reversedKeyElems.add(bucketTypeId);
            reversedKeyElems.add(NON_WILDCARD_FIELD);
        }
    }
    List<byte[]> keyElemsInOrder = Lists.reverse(reversedKeyElems);
    int totalKeySize = 0;
    for (byte[] keyElement : keyElemsInOrder) {
        totalKeySize += keyElement.length;
    }
    ByteBuffer bb = ByteBuffer.allocate(totalKeySize);
    for (byte[] keyElement : keyElemsInOrder) {
        bb.put(keyElement);
    }
    if (bb.remaining() != 0) {
        throw new AssertionError("String_Node_Str" + bb.remaining() + "String_Node_Str");
    }
    return bb.array();
}

Output:
             }
-            reversedKeyElems.add(bucketAndCoord.bucket);
+            reversedKeyElems.add(elem);
             reversedKeyElems.add(bucketTypeId);


Input:
protected void setColumnList(DesignElementHandle handle) {
    try {
        DataSetHandle dataset = null;
        if (handle instanceof TabularCubeHandle) {
            dataset = ((TabularCubeHandle) handle).getDataSet();
        } else if (handle instanceof TabularDimensionHandle) {
            TabularHierarchyHandle hierarchy = (TabularHierarchyHandle) ((TabularDimensionHandle) handle).getDefaultHierarchy();
            if (hierarchy.getDataSet() != null)
                dataset = hierarchy.getDataSet();
            else
                dataset = ((TabularHierarchyHandle) handle).getDataSet();
        } else if (handle instanceof TabularHierarchyHandle) {
            TabularHierarchyHandle hierarchy = (TabularHierarchyHandle) handle;
            if (hierarchy.getDataSet() != null)
                dataset = hierarchy.getDataSet();
            else
                dataset = ((TabularHierarchyHandle) handle).getDataSet();
        }
        if (dataset != null)
            columnList = DataUtil.getColumnList(dataset);
        else
            columnList = Collections.EMPTY_LIST;
    } catch (SemanticException e) {
        ExceptionHandler.handle(e);
    }
}

Output:
             TabularHierarchyHandle hierarchy = (TabularHierarchyHandle) ((TabularDimensionHandle) handle).getDefaultHierarchy();
-            if (hierarchy.getDataSet() != null)
+            if (hierarchy != null)
                 dataset = hierarchy.getDataSet();


Input:
private void switchToQuickTextKeyboard() {
    abortCorrectionAndResetPredictionState(false);
    setCandidatesViewShown(false);
    cleanUpQuickTextKeyboard(false);
    View standardKeyboardView = (View) getInputView();
    final int height = standardKeyboardView.getHeight();
    standardKeyboardView.setVisibility(View.GONE);
    QuickTextPagerView quickTextsLayout = QuickTextViewFactory.createQuickTextView(getApplicationContext(), getInputViewContainer(), height);
    quickTextsLayout.setThemeValues(((AnyKeyboardView) getInputView()).getLabelTextSize(), ((AnyKeyboardView) getInputView()).getKeyTextColor(), ((AnyKeyboardView) getInputView()).getDrawableForKeyCode(KeyCodes.CANCEL), ((AnyKeyboardView) getInputView()).getDrawableForKeyCode(KeyCodes.DELETE), ((AnyKeyboardView) getInputView()).getDrawableForKeyCode(KeyCodes.SETTINGS));
    getInputViewContainer().addView(quickTextsLayout);
}

Output:
     QuickTextPagerView quickTextsLayout = QuickTextViewFactory.createQuickTextView(getApplicationContext(), getInputViewContainer(), height);
-    quickTextsLayout.setThemeValues(((AnyKeyboardView) getInputView()).getLabelTextSize(), ((AnyKeyboardView) getInputView()).getKeyTextColor(), ((AnyKeyboardView) getInputView()).getDrawableForKeyCode(KeyCodes.CANCEL), ((AnyKeyboardView) getInputView()).getDrawableForKeyCode(KeyCodes.DELETE), ((AnyKeyboardView) getInputView()).getDrawableForKeyCode(KeyCodes.SETTINGS));
+    AnyKeyboardView actualInputView = (AnyKeyboardView) getInputView();
+    quickTextsLayout.setThemeValues(actualInputView.getLabelTextSize(), actualInputView.getKeyTextColor(), actualInputView.getDrawableForKeyCode(KeyCodes.CANCEL), actualInputView.getDrawableForKeyCode(KeyCodes.DELETE), actualInputView.getDrawableForKeyCode(KeyCodes.SETTINGS), actualInputView.getBackground());
     getInputViewContainer().addView(quickTextsLayout);


Input:
public void testInvalidConfigure() {
    final String invalidPuName = "String_Node_Str";
    PersistenceUnitMetadata puMetadata = null;
    try {
        Configurator configurator = new Configurator(null, invalidPuName);
        configurator.configure();
        puMetadata = KunderaMetadata.INSTANCE.getApplicationMetadata().getPersistenceUnitMetadata(invalidPuName);
    } catch (IllegalArgumentException iex) {
        Assert.assertNull(puMetadata);
    }
}

Output:
         puMetadata = KunderaMetadata.INSTANCE.getApplicationMetadata().getPersistenceUnitMetadata(invalidPuName);
-    } catch (IllegalArgumentException iex) {
+    } catch (PersistenceUnitConfigurationException iex) {
         Assert.assertNull(puMetadata);


Input:
public RegExpMatcher match(final String str) {
    if (pattern == null) {
        return null;
    }
    RegExpMatcher matcher = this.matcher;
    if (matcher == null || matcher.getInput() != str) {
        matcher = new DefaultMatcher(str);
        this.matcher = matcher;
    }
    return matcher;
}

Output:
     }
-    RegExpMatcher matcher = this.matcher;
-    if (matcher == null || matcher.getInput() != str) {
-        matcher = new DefaultMatcher(str);
-        this.matcher = matcher;
+    RegExpMatcher currentMatcher = this.matcher;
+    if (currentMatcher == null || matcher.getInput() != str) {
+        currentMatcher = new DefaultMatcher(str);
+        this.matcher = currentMatcher;
     }


Input:
private void swap(Class<?> clazz, Long here, Long there) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaUpdate<Object> update = (CriteriaUpdate<Object>) cb.createCriteriaUpdate(clazz);
    Root<?> e = update.from((Class<Object>) clazz);
    Path<Long> path = e.get(POSITION_COLUMN_NAME);
    update.set(path, there);
    update.where(cb.equal(e.get(POSITION_COLUMN_NAME), here));
    entityManager.createQuery(update).executeUpdate();
}

Output:
     update.set(path, there);
-    update.where(cb.equal(e.get(POSITION_COLUMN_NAME), here));
+    List<Predicate> predicates = new ArrayList<Predicate>();
+    predicates.add(cb.equal(e.get(POSITION_COLUMN_NAME), here));
+    if (whereProp != null && whereVal != null) {
+        predicates.add(cb.equal(e.get(whereProp), whereVal));
+    }
+    update.where(predicates.toArray(new Predicate[] {}));
     entityManager.createQuery(update).executeUpdate();


Input:
private boolean createSqlQuery(String dataFilterAsString, Indicator indicator) throws ParseException, AnalysisExecutionException {
    ModelElement analyzedElement = indicator.getAnalyzedElement();
    if (analyzedElement == null) {
        return traceError("String_Node_Str" + indicator.getName());
    }
    TdColumn tdColumn = SwitchHelpers.COLUMN_SWITCH.doSwitch(indicator.getAnalyzedElement());
    if (tdColumn == null) {
        return traceError("String_Node_Str" + indicator.getName());
    }
    String colName = getQuotedColumnName(tdColumn);
    if (!belongToSameSchemata(tdColumn)) {
        StringBuffer buf = new StringBuffer();
        for (orgomg.cwm.objectmodel.core.Package schema : schemata.values()) {
            buf.append(schema.getName() + "String_Node_Str");
        }
        log.error("String_Node_Str" + colName + "String_Node_Str" + buf.toString().trim() + "String_Node_Str");
        return false;
    }
    colName = castColumn(indicator, tdColumn, colName);
    String language = dbms().getDbmsName();
    Expression sqlGenericExpression = null;
    IndicatorDefinition indicatorDefinition;
    String label = indicator.getIndicatorDefinition().getLabel();
    if (label == null || "String_Node_Str".equals(label)) {
        indicatorDefinition = indicator.getIndicatorDefinition();
    } else {
        indicatorDefinition = DefinitionHandler.getInstance().getIndicatorDefinition(label);
    }
    if (indicatorDefinition == null) {
        return traceError("String_Node_Str" + indicator.getName() + "String_Node_Str");
    }
    sqlGenericExpression = dbms().getSqlExpression(indicatorDefinition);
    final EClass indicatorEclass = indicator.eClass();
    if (sqlGenericExpression == null || sqlGenericExpression.getBody() == null) {
        if (IndicatorsPackage.eINSTANCE.getRegexpMatchingIndicator().equals(indicatorEclass)) {
            return traceError("String_Node_Str" + language + "String_Node_Str");
        }
        return traceError("String_Node_Str" + (indicator.getName() != null ? indicator.getName() : indicatorEclass.getName()) + "String_Node_Str" + ResourceHelper.getUUID(indicatorDefinition) + "String_Node_Str");
    }
    List<String> whereExpression = new ArrayList<String>();
    if (StringUtils.isNotBlank(dataFilterAsString)) {
        whereExpression.add(dataFilterAsString);
    }
    List<String> rangeStrings = null;
    DateGrain dateAggregationType = null;
    IndicatorParameters parameters = indicator.getParameters();
    if (parameters != null) {
        Domain bins = parameters.getBins();
        if (bins != null) {
            rangeStrings = getBinsAsGenericString(bins.getRanges(), colName);
        }
        DateParameters dateParameters = parameters.getDateParameters();
        if (dateParameters != null) {
            dateAggregationType = dateParameters.getDateAggregationType();
        }
        TextParameters textParameter = parameters.getTextParameter();
        if (textParameter != null) {
            if (textParameter.isUseNulls()) {
                colName = dbms().replaceNullsWithString(colName, "String_Node_Str");
            }
            if (textParameter.isIgnoreCase()) {
                colName = dbms().toUpperCase(colName);
            }
            if (!textParameter.isUseBlank() && IndicatorsPackage.eINSTANCE.getTextIndicator().isSuperTypeOf(indicatorEclass)) {
                whereExpression.add(dbms().isNotBlank(colName));
            } else if (textParameter.isUseBlank() && IndicatorsPackage.eINSTANCE.getFrequencyIndicator().isSuperTypeOf(indicatorEclass)) {
                colName = dbms().trim(colName);
            }
        }
    }
    final ColumnSet columnSetOwner = ColumnHelper.getColumnSetOwner(tdColumn);
    String schemaName = getQuotedSchemaName(columnSetOwner);
    String table = getQuotedTableName(tdColumn);
    String catalogName = getQuotedCatalogName(columnSetOwner);
    if (catalogName == null && schemaName != null) {
        final TdSchema parentSchema = SchemaHelper.getParentSchema(columnSetOwner);
        final TdCatalog parentCatalog = CatalogHelper.getParentCatalog(parentSchema);
        catalogName = parentCatalog != null ? parentCatalog.getName() : null;
    }
    if (dbms().getDbmsName().equals(SupportDBUrlType.SYBASEDEFAULTURL.getLanguage())) {
        schemaName = ColumnSetHelper.getTableOwner(columnSetOwner);
    }
    table = dbms().toQualifiedName(catalogName, schemaName, table);
    String completedSqlString = null;
    if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getMedianIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getLowerQuartileIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getUpperQuartileIndicator())) {
        completedSqlString = getCompletedStringForQuantiles(indicator, sqlGenericExpression, colName, table, whereExpression);
        if (completedSqlString != null) {
            whereExpression = duplicateForCrossJoin(completedSqlString, whereExpression, tdColumn);
            completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
        }
    } else if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || IndicatorsPackage.eINSTANCE.getFrequencyIndicator().isSuperTypeOf(indicatorEclass) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator()) || UDIHelper.isFrequency(indicator)) {
        int topN = indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator()) ? 1 : getTopN(indicator);
        if (topN <= 0) {
            topN = TOP_N;
        }
        if (rangeStrings != null) {
            completedSqlString = getUnionCompletedString(indicator, sqlGenericExpression, colName, table, whereExpression, rangeStrings);
            if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator())) {
                completedSqlString = dbms().getTopNQuery(completedSqlString, topN);
            }
        } else if (dateAggregationType != null && !dateAggregationType.equals(DateGrain.NONE) && Java2SqlType.isDateInSQL(tdColumn.getJavaType())) {
            completedSqlString = getDateAggregatedCompletedString(sqlGenericExpression, colName, table, dateAggregationType);
            completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
            completedSqlString = dbms().getTopNQuery(completedSqlString, topN);
        } else {
            if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getPatternFreqIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getPatternLowFreqIndicator())) {
                if (!Java2SqlType.isNumbericInSQL(tdColumn.getJavaType())) {
                    final EList<CharactersMapping> charactersMapping = indicatorDefinition.getCharactersMapping();
                    colName = dbms().getPatternFinderFunction(colName, charactersMapping);
                    if (colName == null) {
                        colName = dbms().getPatternFinderDefaultFunction(colName);
                    }
                }
            } else if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getSoundexFreqIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getSoundexLowFreqIndicator())) {
                table = dbms().getSoundexFunction(table, colName);
            }
            completedSqlString = dbms().fillGenericQueryWithColumnTableAndAlias(sqlGenericExpression.getBody(), colName, table, colName);
            completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
            completedSqlString = dbms().getTopNQuery(completedSqlString, topN);
        }
    } else if (IndicatorsPackage.eINSTANCE.getPatternMatchingIndicator().isSuperTypeOf(indicatorEclass)) {
        List<String> patterns = getPatterns(indicator);
        if (patterns.isEmpty()) {
            return traceError("String_Node_Str" + language + "String_Node_Str" + indicator.getName());
        }
        completedSqlString = replaceVariables(sqlGenericExpression.getBody(), colName, table, patterns);
        completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
    } else {
        if (IndicatorsPackage.eINSTANCE.getDefValueCountIndicator().equals(indicatorEclass)) {
            String defValue = ColumnHelper.getDefaultValue(tdColumn);
            if (defValue == null) {
                return traceError("String_Node_Str" + colName + "String_Node_Str" + indicator.getName() + "String_Node_Str");
            }
            int javaType = tdColumn.getJavaType();
            if (!Java2SqlType.isNumbericInSQL(javaType)) {
                defValue = "String_Node_Str" + defValue + "String_Node_Str";
            }
            whereExpression.add(colName + dbms().equal() + defValue);
        }
        completedSqlString = dbms().fillGenericQueryWithColumnsAndTable(sqlGenericExpression.getBody(), colName, table);
        completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
    }
    String finalQuery = completedSqlString;
    if (finalQuery != null) {
        Expression instantiateSqlExpression = BooleanExpressionHelper.createExpression(language, finalQuery);
        indicator.setInstantiatedExpression(instantiateSqlExpression);
        return true;
    }
    return false;
}

Output:
             }
-            if (!textParameter.isUseBlank() && IndicatorsPackage.eINSTANCE.getTextIndicator().isSuperTypeOf(indicatorEclass)) {
+            if (!textParameter.isUseBlank() && IndicatorsPackage.eINSTANCE.getLengthIndicator().isSuperTypeOf(indicatorEclass)) {
                 whereExpression.add(dbms().isNotBlank(colName));


Input:
public void endTable(ITableContent table) {
    if (enableMetadata) {
        metadataEmitter.endTable(table);
    }
    writer.closeTag(HTMLTags.TAG_TABLE);
    if (enableMetadata) {
        metadataEmitter.endWrapTable(table);
    }
    if (needImplementAlignTable(table)) {
        writer.closeTag(HTMLTags.TAG_DIV);
    }
    logger.log(Level.FINE, "String_Node_Str");
}

Output:
     }
-    if (needImplementAlignTable(table)) {
+    boolean DIVWrap = ((Boolean) tableDIVWrapedFlagStack.pop()).booleanValue();
+    if (DIVWrap) {
         writer.closeTag(HTMLTags.TAG_DIV);


Input:
protected void handlePollStateResult(int what, AsyncResult ar) {
    int[] ints;
    String[] states;
    if (ar.userObj != pollingContext)
        return;
    if (ar.exception != null) {
        CommandException.Error err = null;
        if (ar.exception instanceof CommandException) {
            err = ((CommandException) (ar.exception)).getCommandError();
        }
        if (err == CommandException.Error.RADIO_NOT_AVAILABLE) {
            cancelPollState();
            return;
        }
        if (!cm.getRadioState().isOn()) {
            cancelPollState();
            return;
        }
        if (err != CommandException.Error.OP_NOT_ALLOWED_BEFORE_REG_NW && err != CommandException.Error.OP_NOT_ALLOWED_BEFORE_REG_NW) {
            Log.e(LOG_TAG, "String_Node_Str", ar.exception);
        }
    } else
        try {
            switch(what) {
                case EVENT_POLL_STATE_REGISTRATION_CDMA:
                    states = (String[]) ar.result;
                    int registrationState = 4;
                    int radioTechnology = -1;
                    int baseStationId = -1;
                    int baseStationLatitude = -1;
                    int baseStationLongitude = -1;
                    int cssIndicator = 0;
                    int systemId = 0;
                    int networkId = 0;
                    int roamingIndicator = -1;
                    int systemIsInPrl = 0;
                    int defaultRoamingIndicator = 0;
                    int reasonForDenial = 0;
                    if (states.length == 14) {
                        try {
                            registrationState = Integer.parseInt(states[0]);
                            radioTechnology = Integer.parseInt(states[3]);
                            baseStationId = Integer.parseInt(states[4]);
                            baseStationLatitude = Integer.parseInt(states[5], 16);
                            baseStationLongitude = Integer.parseInt(states[6], 16);
                            cssIndicator = Integer.parseInt(states[7]);
                            systemId = Integer.parseInt(states[8]);
                            networkId = Integer.parseInt(states[9]);
                            roamingIndicator = Integer.parseInt(states[10]);
                            systemIsInPrl = Integer.parseInt(states[11]);
                            defaultRoamingIndicator = Integer.parseInt(states[12]);
                            reasonForDenial = Integer.parseInt(states[13]);
                        } catch (NumberFormatException ex) {
                            Log.w(LOG_TAG, "String_Node_Str" + ex);
                        }
                    } else {
                        throw new RuntimeException("String_Node_Str" + "String_Node_Str" + states.length);
                    }
                    mRegistrationState = registrationState;
                    mCdmaRoaming = regCodeIsRoaming(registrationState) && !isRoamIndForHomeSystem(states[10]);
                    newSS.setState(regCodeToServiceState(registrationState));
                    this.newCdmaDataConnectionState = radioTechnologyToDataServiceState(radioTechnology);
                    newSS.setRadioTechnology(radioTechnology);
                    newNetworkType = radioTechnology;
                    newSS.setCssIndicator(cssIndicator);
                    newSS.setSystemAndNetworkId(systemId, networkId);
                    mRoamingIndicator = roamingIndicator;
                    mIsInPrl = (systemIsInPrl == 0) ? false : true;
                    mDefaultRoamingIndicator = defaultRoamingIndicator;
                    newCellLoc.setCellLocationData(baseStationId, baseStationLatitude, baseStationLongitude, systemId, networkId);
                    if (reasonForDenial == 0) {
                        mRegistrationDeniedReason = ServiceStateTracker.REGISTRATION_DENIED_GEN;
                    } else if (reasonForDenial == 1) {
                        mRegistrationDeniedReason = ServiceStateTracker.REGISTRATION_DENIED_AUTH;
                    } else {
                        mRegistrationDeniedReason = "String_Node_Str";
                    }
                    if (mRegistrationState == 3) {
                        if (DBG)
                            log("String_Node_Str" + mRegistrationDeniedReason);
                    }
                    break;
                case EVENT_POLL_STATE_OPERATOR_CDMA:
                    String[] opNames = (String[]) ar.result;
                    if (opNames != null && opNames.length >= 3) {
                        if (cm.getRadioState().isNVReady()) {
                            newSS.setOperatorName(null, opNames[1], opNames[2]);
                        } else {
                            newSS.setOperatorName(opNames[0], opNames[1], opNames[2]);
                        }
                    } else {
                        Log.w(LOG_TAG, "String_Node_Str");
                    }
                    break;
                default:
                    Log.e(LOG_TAG, "String_Node_Str" + "String_Node_Str");
                    break;
            }
        } catch (RuntimeException ex) {
            Log.e(LOG_TAG, "String_Node_Str" + "String_Node_Str", ex);
        }
    pollingContext[0]--;
    if (pollingContext[0] == 0) {
        boolean namMatch = false;
        if ((mHomeSystemId != 0) && (mHomeSystemId == newSS.getSystemId())) {
            namMatch = true;
        }
        if (isSubscriptionFromRuim) {
            newSS.setRoaming(isRoamingBetweenOperators(mCdmaRoaming, newSS));
        } else {
            newSS.setRoaming(mCdmaRoaming);
        }
        if (mIsInPrl) {
            if (namMatch && (mRoamingIndicator <= 2)) {
                newSS.setCdmaRoamingIndicator(EriInfo.ROAMING_INDICATOR_OFF);
            } else {
                newSS.setCdmaRoamingIndicator(mRoamingIndicator);
            }
        } else {
            if (mRegistrationState == 5) {
                newSS.setCdmaRoamingIndicator(EriInfo.ROAMING_INDICATOR_FLASH);
            } else {
            }
        }
        newSS.setCdmaDefaultRoamingIndicator(mDefaultRoamingIndicator);
        if (DBG) {
            log("String_Node_Str" + newSS.getCdmaRoamingIndicator() + "String_Node_Str" + mCdmaRoaming + "String_Node_Str" + namMatch + "String_Node_Str" + mIsInPrl + "String_Node_Str" + mRoamingIndicator + "String_Node_Str" + mDefaultRoamingIndicator);
        }
        pollStateDone();
    }
}

Output:
         boolean namMatch = false;
-        if ((mHomeSystemId != 0) && (mHomeSystemId == newSS.getSystemId())) {
+        if (!isSidsAllZeros() && isHomeSid(newSS.getSystemId())) {
             namMatch = true;


Input:
public void GameOverScreen() {
    if (GameOverScene == null) {
        GameOverScene = new Scene(1);
        Text gameOverText = new Text(base.getCameraWidth() / 2, base.getCameraHeight() / 2, base.mFont, "String_Node_Str", HorizontalAlign.CENTER) {
            public boolean onAreaTouched(TouchEvent pSceneTouchEvent, float pTouchAreaLocalX, float pTouchAreaLocalY) {
                base.ButtonPress(9);
                return super.onAreaTouched(pSceneTouchEvent, pTouchAreaLocalX, pTouchAreaLocalY);
            }
        };
        scorebits = new ChangeableText(gameOverText.getX() - gameOverText.getWidth(), gameOverText.getY() + gameOverText.getHeight(), base.mFont, "String_Node_Str" + base.sKillCount + "String_Node_Str" + base.mMoneyEarned);
        GameOverScene.attachChild(gameOverText);
        GameOverScene.attachChild(scorebits);
        GameOverScene.registerTouchArea(gameOverText);
    }
    scorebits.setText("String_Node_Str" + base.sKillCount + "String_Node_Str" + base.mMoneyEarned);
    checkHud();
    base.game_over.play();
    base.getEngine().setScene(GameOverScene);
    long scoreValue = base.theWave.getWaveNumber();
    Score s = new Score(scoreValue, null);
    Leaderboard l = new Leaderboard("String_Node_Str");
    s.submitTo(l, new Score.SubmitToCB() {
        public void onSuccess(boolean newHighScore) {
            base.setResult(Activity.RESULT_OK);
        }
        public void onFailure(final String exceptionMessage) {
            base.CustomNotifications.addNotification("String_Node_Str" + exceptionMessage + "String_Node_Str");
            base.setResult(Activity.RESULT_CANCELED);
        }
    });
    CameraCheck();
}

Output:
     if (GameOverScene == null) {
-        GameOverScene = new Scene(1);
+        GameOverScene = new Scene();
         Text gameOverText = new Text(base.getCameraWidth() / 2, base.getCameraHeight() / 2, base.mFont, "String_Node_Str", HorizontalAlign.CENTER) {


Input:
int invokeNewDataSet() {
    DataService.getInstance().createDataSet();
    return Window.OK;
}

Output:
     DataService.getInstance().createDataSet();
-    return Window.OK;
+    if (getDataServiceProvider().getAllDataSets().length == count) {
+        return Window.CANCEL;
+    } else {
+        return Window.OK;
+    }
 }


Input:
private void storeDataSet() {
    EMap<Indicator, AnalyzedDataSet> indicToRowMap = analysis.getResults().getIndicToRowMap();
    for (Indicator indicator : analysis.getResults().getIndicators()) {
        if (indicator instanceof SimpleStatIndicator) {
            SimpleStatIndicator simpleIndicator = (SimpleStatIndicator) indicator;
            if (!analysis.getParameters().isStoreData()) {
                break;
            }
            if (simpleIndicator.isUsedMapDBMode()) {
            } else {
                List<Object[]> listRows = simpleIndicator.getListRows();
                if (listRows == null || listRows.isEmpty()) {
                    break;
                }
                for (Indicator leafIndicator : simpleIndicator.getLeafIndicators()) {
                    if (leafIndicator instanceof RowCountIndicator) {
                        continue;
                    }
                    List<Object[]> dataList = new ArrayList<Object[]>();
                    AnalyzedDataSet analyzedDataSet = indicToRowMap.get(leafIndicator);
                    if (analyzedDataSet == null) {
                        analyzedDataSet = AnalysisFactory.eINSTANCE.createAnalyzedDataSet();
                        indicToRowMap.put(leafIndicator, analyzedDataSet);
                        analyzedDataSet.setDataCount(analysis.getParameters().getMaxNumberRows());
                        analyzedDataSet.setRecordSize(0);
                    }
                    for (int i = 0; i < listRows.size(); i++) {
                        Object[] object = listRows.get(i);
                        Object count = object[object.length > 0 ? object.length - 1 : 0];
                        if (leafIndicator instanceof DistinctCountIndicator) {
                            dataList.add(object);
                        } else if (leafIndicator instanceof UniqueCountIndicator) {
                            if (count != null && NumberUtils.isNumber(count + PluginConstant.EMPTY_STRING)) {
                                if (Long.valueOf(count + PluginConstant.EMPTY_STRING).longValue() == 1) {
                                    dataList.add(object);
                                }
                            }
                        } else if (leafIndicator instanceof DuplicateCountIndicator) {
                            if (count != null && NumberUtils.isNumber(count + PluginConstant.EMPTY_STRING)) {
                                if (Long.valueOf(count + PluginConstant.EMPTY_STRING).longValue() > 1) {
                                    dataList.add(object);
                                }
                            }
                        }
                    }
                    analyzedDataSet.setData(dataList);
                }
                if (!simpleIndicator.isStoreData()) {
                    simpleIndicator.setListRows(new ArrayList<Object[]>());
                }
            }
        }
        if (indicator instanceof AllMatchIndicator) {
            AllMatchIndicator allMatchIndicator = (AllMatchIndicator) indicator;
            if (!allMatchIndicator.isStoreData()) {
                allMatchIndicator.setListRows(new ArrayList<Object[]>());
            }
        }
    }
}

Output:
             }
-            if (simpleIndicator.isUsedMapDBMode()) {
+            if (simpleIndicator.isUsedMapDBMode() && AnalysisHelper.isJavaExecutionEngine(analysis)) {
             } else {


Input:
void closeNodeScope(Node n, boolean condition) {
    if (condition) {
        int a = nodeArity();
        mk = ((Integer) marks.pop()).intValue();
        while (a-- > 0) {
            Node c = popNode();
            c.jjtSetParent(n);
            n.jjtAddChild(c, a);
        }
        n.jjtClose();
        pushNode(n);
        node_created = true;
    } else {
        mk = ((Integer) marks.pop()).intValue();
        node_created = false;
    }
}

Output:
         int a = nodeArity();
-        mk = ((Integer) marks.pop()).intValue();
+        mk = marks.remove(marks.size() - 1);
         while (a-- > 0) {


Input:
public static ViewDB getInstance() {
    if (instance == null)
        instance = new ViewDB();
    websocketdb = WebSocketDB.getInstance();
    websocketdb.setObserver(instance);
    return instance;
}

Output:
 public static ViewDB getInstance() {
-    if (instance == null)
+    if (instance == null) {
         instance = new ViewDB();


Input:
public void execute() {
    if (comboContent.size() > 0) {
        List<IElementParameter> tableInput = getTableViewerCreator().getInputList();
        IElementParameter parameter = comboContent.get(0);
        tableInput.add(parameter);
        ((IElementParameter) parameter).setContextMode(true);
        List<IElementParameter> associateParams = findRadioParamInSameGroup(comboContent, parameter);
        for (IElementParameter param : associateParams) {
            param.setContextMode(true);
            tableInput.add(param);
        }
        refreshComboContent(AdvancedContextTableView.this, legalParameters);
        getExtendedToolbar().updateEnabledStateOfButtons();
        getTableViewerCreator().refresh();
        if (parameter.getName().equals("String_Node_Str")) {
            parameter.setReadOnly(false);
        }
    }
}

Output:
         tableInput.add(parameter);
-        ((IElementParameter) parameter).setContextMode(true);
+        parameter.setContextMode(true);
         List<IElementParameter> associateParams = findRadioParamInSameGroup(comboContent, parameter);


Input:
public void testSha1SignatureVerification() throws Exception {
    test(mockerSha1);
}

Output:
 public void testSha1SignatureVerification() throws Exception {
-    test(mockerSha1);
+    runTest(mockerSha1);
 }


Input:
private void addExtensionPointItems(XNavigateItem parentItem, List<XNavigateItem> items) {
    IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint("String_Node_Str");
    if (point == null) {
        OseeLog.log(Activator.class, OseeLevel.SEVERE_POPUP, "String_Node_Str");
        return;
    }
    IExtension[] extensions = point.getExtensions();
    Map<String, XNavigateItem> nameToNavItem = new TreeMap<>();
    for (IExtension extension : extensions) {
        IConfigurationElement[] elements = extension.getConfigurationElements();
        String classname = null;
        String bundleName = null;
        for (IConfigurationElement el : elements) {
            if (el.getName().equals("String_Node_Str")) {
                classname = el.getAttribute("String_Node_Str");
                bundleName = el.getContributor().getName();
            }
        }
        if (classname != null && bundleName != null) {
            Bundle bundle = Platform.getBundle(bundleName);
            try {
                Object obj = bundle.loadClass(classname).newInstance();
                IAtsNavigateItem task = (IAtsNavigateItem) obj;
                for (XNavigateItem navItem : task.getNavigateItems(parentItem)) {
                    nameToNavItem.put(navItem.getName(), navItem);
                }
            } catch (Exception ex) {
                OseeLog.log(Activator.class, Level.SEVERE, "String_Node_Str", ex);
            }
        }
    }
    items.addAll(nameToNavItem.values());
}

Output:
                 IAtsNavigateItem task = (IAtsNavigateItem) obj;
-                for (XNavigateItem navItem : task.getNavigateItems(parentItem)) {
-                    nameToNavItem.put(navItem.getName(), navItem);
+                if (task != null) {
+                    for (XNavigateItem navItem : task.getNavigateItems(parentItem)) {
+                        nameToNavItem.put(navItem.getName(), navItem);
+                    }
                 }


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    View rowView = inflater.inflate(R.layout.invitation_item_list, parent, false);
    TextView nameTextView = (TextView) rowView.findViewById(R.id.EventName);
    TextView text1TextView = (TextView) rowView.findViewById(R.id.EventText1);
    TextView text2TextView = (TextView) rowView.findViewById(R.id.EventText2);
    nameTextView.setText(values.get(position).getOrder().getRestaurant().getName());
    try {
        Date date = (new SimpleDateFormat("String_Node_Str")).parse(values.get(position).getOrder().getRequest_date().replaceAll("String_Node_Str", "String_Node_Str"));
        String dateString = new SimpleDateFormat("String_Node_Str").format(date);
        text1TextView.setText(dateString);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    String userList = "String_Node_Str";
    List<User> ul = values.get(position).getParticipants();
    for (int i = 0; i < ul.size(); ++i) {
        userList += ul.get(i).getName();
        if (i < ul.size() - 1) {
            userList += "String_Node_Str";
        }
    }
    text2TextView.setText(userList);
    return rowView;
}

Output:
     nameTextView.setText(values.get(position).getOrder().getRestaurant().getName());
-    try {
-        Date date = (new SimpleDateFormat("String_Node_Str")).parse(values.get(position).getOrder().getRequest_date().replaceAll("String_Node_Str", "String_Node_Str"));
-        String dateString = new SimpleDateFormat("String_Node_Str").format(date);
-        text1TextView.setText(dateString);
-    } catch (ParseException e) {
-        e.printStackTrace();
-    }
+    text1TextView.setText(values.get(position).getOrder().getRequest_date());
     String userList = "String_Node_Str";


Input:
protected Animator disappear(ViewGroup sceneRoot, TransitionValues startValues, int startVisibility, TransitionValues endValues, int endVisibility) {
    if ((mFadingMode & OUT) != OUT) {
        return null;
    }
    View view;
    View startView = (startValues != null) ? startValues.view : null;
    View endView = (endValues != null) ? endValues.view : null;
    if (Transition.DBG) {
        Log.d(LOG_TAG, "String_Node_Str" + startView + "String_Node_Str" + startVisibility + "String_Node_Str" + endView + "String_Node_Str" + endVisibility);
    }
    View overlayView = null;
    View viewToKeep = null;
    if (endView == null) {
        view = startView;
        overlayView = view;
    } else {
        if (endVisibility == View.INVISIBLE) {
            view = endView;
            viewToKeep = view;
        } else {
            if (startView == endView) {
                view = endView;
                viewToKeep = view;
            } else {
                view = startView;
                overlayView = view;
            }
        }
    }
    final int finalVisibility = endVisibility;
    if (overlayView != null) {
        int screenX = (Integer) startValues.values.get(PROPNAME_SCREEN_X);
        int screenY = (Integer) startValues.values.get(PROPNAME_SCREEN_Y);
        int[] loc = new int[2];
        sceneRoot.getLocationOnScreen(loc);
        overlayView.offsetLeftAndRight((screenX - loc[0]) - overlayView.getLeft());
        overlayView.offsetTopAndBottom((screenY - loc[1]) - overlayView.getTop());
        sceneRoot.getOverlay().add(overlayView);
        final float startAlpha = view.getAlpha();
        float endAlpha = 0;
        final View finalView = view;
        final View finalOverlayView = overlayView;
        final View finalViewToKeep = viewToKeep;
        final ViewGroup finalSceneRoot = sceneRoot;
        final Animator.AnimatorListener endListener = new AnimatorListenerAdapter() {
            public void onAnimationEnd(Animator animation) {
                finalView.setAlpha(startAlpha);
                if (finalViewToKeep != null) {
                    finalViewToKeep.setVisibility(finalVisibility);
                }
                if (finalOverlayView != null) {
                    finalSceneRoot.getOverlay().remove(finalOverlayView);
                }
            }
        };
        return runAnimation(view, startAlpha, endAlpha, endListener);
    }
    if (viewToKeep != null) {
        viewToKeep.setVisibility((View.VISIBLE));
        final float startAlpha = view.getAlpha();
        float endAlpha = 0;
        final View finalView = view;
        final View finalOverlayView = overlayView;
        final View finalViewToKeep = viewToKeep;
        final ViewGroup finalSceneRoot = sceneRoot;
        final Animator.AnimatorListener endListener = new AnimatorListenerAdapter() {
            public void onAnimationEnd(Animator animation) {
                finalView.setAlpha(startAlpha);
                if (finalViewToKeep != null) {
                    finalViewToKeep.setVisibility(finalVisibility);
                }
                if (finalOverlayView != null) {
                    finalSceneRoot.getOverlay().remove(finalOverlayView);
                }
            }
        };
        return runAnimation(view, startAlpha, endAlpha, endListener);
    }
    return null;
}

Output:
     View endView = (endValues != null) ? endValues.view : null;
-    if (Transition.DBG) {
+    if (DBG) {
         Log.d(LOG_TAG, "String_Node_Str" + startView + "String_Node_Str" + startVisibility + "String_Node_Str" + endView + "String_Node_Str" + endVisibility);


Input:
public NavigationResult next(UIContext context) throws Exception {
    ScaffoldProvider selectedProvider = provider.getValue();
    Project project = getSelectedProject(context);
    context.setAttribute(Project.class, project);
    context.setAttribute(ScaffoldProvider.class, selectedProvider);
    context.setAttribute(ScaffoldGenerationContext.class, populateGenerationContext(context));
    ((AbstractFacet) selectedProvider).setFaceted(project);
    List<Class<? extends UICommand>> generationFlow = selectedProvider.getGenerationFlow();
    generationFlow.add(ExecuteGenerationStep.class);
    Class<? extends UICommand> next = generationFlow.remove(0);
    Class<?>[] additional = generationFlow.toArray(new Class<?>[generationFlow.size()]);
    return Results.navigateTo(next, (Class<? extends UICommand>[]) additional);
}

Output:
     ScaffoldProvider selectedProvider = provider.getValue();
-    Project project = getSelectedProject(context);
-    context.setAttribute(Project.class, project);
-    context.setAttribute(ScaffoldProvider.class, selectedProvider);
-    context.setAttribute(ScaffoldGenerationContext.class, populateGenerationContext(context));
+    UIContext uiContext = context.getUIContext();
+    Project project = getSelectedProject(uiContext);
+    uiContext.setAttribute(Project.class, project);
+    uiContext.setAttribute(ScaffoldProvider.class, selectedProvider);
+    uiContext.setAttribute(ScaffoldGenerationContext.class, populateGenerationContext(uiContext));
     ((AbstractFacet) selectedProvider).setFaceted(project);


Input:
public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
    int left = parent.getPaddingLeft();
    int right = parent.getWidth() - parent.getPaddingRight();
    int childCount = parent.getChildCount();
    for (int i = 0; i < childCount; i++) {
        View child = parent.getChildAt(i);
        RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) child.getLayoutParams();
        int top = child.getBottom() + params.bottomMargin;
        int bottom = top + mDivider.getIntrinsicHeight();
        mDivider.setBounds(left, top, right, bottom);
        mDivider.draw(c);
    }
}

Output:
 public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
-    int left = parent.getPaddingLeft();
-    int right = parent.getWidth() - parent.getPaddingRight();
+    int left = ViewCompat.getPaddingStart(parent);
+    int right = parent.getWidth() - ViewCompat.getPaddingEnd(parent);
     int childCount = parent.getChildCount();


Input:
public void exportGroups(List<BusinessGroup> groups, List<BGArea> areas, File fExportFile, BusinessGroupEnvironment env, boolean runtimeDatas, boolean backwardsCompatible) {
    businessGroupImportExport.exportGroups(groups, areas, fExportFile, env, runtimeDatas, backwardsCompatible);
}

Output:
 public void exportGroups(List<BusinessGroup> groups, List<BGArea> areas, File fExportFile, BusinessGroupEnvironment env, boolean runtimeDatas, boolean backwardsCompatible) {
-    businessGroupImportExport.exportGroups(groups, areas, fExportFile, env, runtimeDatas, backwardsCompatible);
+    BusinessGroupImportExport exporter = new BusinessGroupImportExport(dbInstance, areaManager, this, groupModule);
+    exporter.exportGroups(groups, areas, fExportFile, env, runtimeDatas, backwardsCompatible);
 }


Input:
public Branch visitChild(Stack stack) {
    RexProgram program = CalcProjectUtil.createRexProgram(this);
    return CalcProjectUtil.resolveBranch(stack, this, program);
}

Output:
 public Branch visitChild(Stack stack) {
-    RexProgram program = CalcProjectUtil.createRexProgram(this);
+    RexProgram program = RexProgram.create(getChild().getRowType(), exps, null, getRowType(), getCluster().getRexBuilder());
     return CalcProjectUtil.resolveBranch(stack, this, program);


Input:
private void doRunOperation(final Operation op) {
    RemoteCallKey callKey = null;
    try {
        if (isCallTimedOut(op)) {
            Object response = new CallTimeoutException("String_Node_Str" + op.getClass().getName() + "String_Node_Str" + op.getInvocationTime() + "String_Node_Str" + op.getCallTimeout());
            op.getResponseHandler().sendResponse(response);
            return;
        }
        callKey = beforeCallExecution(op);
        final int partitionId = op.getPartitionId();
        if (op instanceof PartitionAwareOperation) {
            if (partitionId < 0) {
                throw new IllegalArgumentException("String_Node_Str" + partitionId);
            }
            final PartitionView partitionView = nodeEngine.getPartitionService().getPartition(partitionId);
            if (partitionView == null) {
                throw new PartitionMigratingException(node.getThisAddress(), partitionId, op.getClass().getName(), op.getServiceName());
            }
            if (retryDuringMigration(op) && node.partitionService.isPartitionMigrating(partitionId)) {
                throw new PartitionMigratingException(node.getThisAddress(), partitionId, op.getClass().getName(), op.getServiceName());
            }
            final Address owner = partitionView.getReplicaAddress(op.getReplicaIndex());
            if (op.validatesTarget() && !node.getThisAddress().equals(owner)) {
                throw new WrongTargetException(node.getThisAddress(), owner, partitionId, op.getReplicaIndex(), op.getClass().getName(), op.getServiceName());
            }
        }
        OperationAccessor.setStartTime(op, Clock.currentTimeMillis());
        op.beforeRun();
        if (op instanceof WaitSupport) {
            WaitSupport waitSupport = (WaitSupport) op;
            if (waitSupport.shouldWait()) {
                nodeEngine.waitNotifyService.await(waitSupport);
                return;
            }
        }
        op.run();
        final boolean returnsResponse = op.returnsResponse();
        Object response = null;
        if (op instanceof BackupAwareOperation) {
            final BackupAwareOperation backupAwareOp = (BackupAwareOperation) op;
            int syncBackupCount = 0;
            if (backupAwareOp.shouldBackup()) {
                syncBackupCount = sendBackups(backupAwareOp);
            }
            if (returnsResponse) {
                response = new Response(op.getResponse(), op.getCallId(), syncBackupCount);
            }
        }
        if (returnsResponse) {
            if (response == null) {
                response = op.getResponse();
            }
            final ResponseHandler responseHandler = op.getResponseHandler();
            if (responseHandler == null) {
                throw new IllegalStateException("String_Node_Str");
            }
            responseHandler.sendResponse(response);
        }
        op.afterRun();
        if (op instanceof Notifier) {
            final Notifier notifier = (Notifier) op;
            if (notifier.shouldNotify()) {
                nodeEngine.waitNotifyService.notify(notifier);
            }
        }
    } catch (Throwable e) {
        handleOperationError(op, e);
    } finally {
        afterCallExecution(op, callKey);
    }
}

Output:
         if (isCallTimedOut(op)) {
-            Object response = new CallTimeoutException("String_Node_Str" + op.getClass().getName() + "String_Node_Str" + op.getInvocationTime() + "String_Node_Str" + op.getCallTimeout());
+            Object response = new CallTimeoutException(op.getClass().getName(), op.getInvocationTime(), op.getCallTimeout());
             op.getResponseHandler().sendResponse(response);


Input:
void acquireExclusive() throws InterruptedException {
    if (getThread().isInterrupted())
        throw new InterruptedException();
    monitor.lockInterruptibly();
    final long tid = getThread().getId();
    if (writeLockedBy == tid) {
        holds.get().count++;
    } else {
        writersWaiting.incrementAndGet();
        while (numberOfThreads > 0) {
            try {
                lockAvailable.await();
            } catch (InterruptedException e) {
                writersWaiting.decrementAndGet();
                throw e;
            }
        }
        writersWaiting.decrementAndGet();
        holds.get().count = 1;
        writeLockedBy = tid;
        isWriteLocked.set(TRUE);
        numberOfThreads++;
    }
    monitor.unlock();
}

Output:
         writersWaiting.incrementAndGet();
-        while (numberOfThreads > 0) {
+        while (numberOfThreads.get() > 0) {
             try {


Input:
public static ChannelID getBaMonForLocation(String location) throws ArgumentNotValid {
    ArgumentNotValid.checkNotNullOrEmpty(location, "String_Node_Str");
    ChannelID[] bamons = getAllArchives_BAMONs();
    for (ChannelID bamon : bamons) {
        if ((bamon.getName().split("String_Node_Str")[1]).equals(location)) {
            return bamon;
        }
    }
    throw new ArgumentNotValid("String_Node_Str" + location);
}

Output:
     for (ChannelID bamon : bamons) {
-        if ((bamon.getName().split("String_Node_Str")[1]).equals(location)) {
+        if (bamon.getName().equals(Settings.get(Settings.ENVIRONMENT_NAME) + "String_Node_Str" + location + "String_Node_Str")) {
             return bamon;


Input:
public SolutionSet execute() throws JMetalException, ClassNotFoundException {
    population = new SolutionSet(populationSize);
    neighborhood = new Neighborhood(populationSize);
    neighbors = new SolutionSet[populationSize];
    evaluations = 0;
    createInitialPopulation();
    population = evaluatePopulation(population);
    evaluations += population.size();
    while (!stoppingCondition()) {
        for (int ind = 0; ind < population.size(); ind++) {
            Solution individual = new Solution(population.get(ind));
            Solution[] parents = new Solution[2];
            Solution[] offSpring;
            neighbors[ind] = neighborhood.getEightNeighbors(population, ind);
            neighbors[ind].add(individual);
            parents[0] = (Solution) selectionOperator.execute(neighbors[ind]);
            parents[1] = (Solution) selectionOperator.execute(neighbors[ind]);
            offSpring = (Solution[]) crossoverOperator.execute(parents);
            mutationOperator.execute(offSpring[0]);
            problem_.evaluate(offSpring[0]);
            problem_.evaluateConstraints(offSpring[0]);
            evaluations++;
            int flag = dominanceComparator.compare(individual, offSpring[0]);
            if (flag == 1) {
                offSpring[0].setLocation(individual.getLocation());
                population.replace(offSpring[0].getLocation(), offSpring[0]);
                archive.add(new Solution(offSpring[0]));
            } else if (flag == 0) {
                neighbors[ind].add(offSpring[0]);
                Ranking rank = new Ranking(neighbors[ind]);
                for (int j = 0; j < rank.getNumberOfSubfronts(); j++) {
                    Distance.crowdingDistance(rank.getSubfront(j));
                }
                int compareResult = densityEstimatorComparator.compare(individual, offSpring[0]);
                if (compareResult == 1) {
                    offSpring[0].setLocation(individual.getLocation());
                    population.replace(offSpring[0].getLocation(), offSpring[0]);
                    archive.add(new Solution(offSpring[0]));
                } else {
                    archive.add(new Solution(offSpring[0]));
                }
            }
        }
        archiveFeedback();
    }
    return archive;
}

Output:
     neighbors = new SolutionSet[populationSize];
-    evaluations = 0;
+    archive = new CrowdingArchive(archiveSize, problem_.getNumberOfObjectives());
     createInitialPopulation();


Input:
private static void watch() {
    try {
        while (true) {
            Thread.sleep(1000);
            synchronized (beingWatched) {
                long curTime = System.currentTimeMillis();
                int nRunaways = 0;
                Iterator iter = beingWatched.values().iterator();
                while (iter.hasNext()) {
                    Entry e = (Entry) iter.next();
                    if (curTime < e.nextCheckTime) {
                        if (e.runaway)
                            ++nRunaways;
                        continue;
                    }
                    e.runaway = true;
                    ++nRunaways;
                    long nextTime = Math.min(5000, e.maxTime);
                    e.nextCheckTime = curTime + nextTime;
                    e.needPrint = true;
                }
                int count = 0;
                iter = beingWatched.values().iterator();
                while (iter.hasNext()) {
                    Entry e = (Entry) iter.next();
                    if (e.runaway)
                        ++count;
                    if (!e.needPrint)
                        continue;
                    String id = Trace.getThreadId(e.thread);
                    if (id == null)
                        id = "String_Node_Str";
                    double secs = (curTime - e.startTime) / 1000.0;
                    String secStr = DecimalFormat.getInstance().format(secs);
                    Trace.warning("String_Node_Str" + id + "String_Node_Str" + "String_Node_Str" + secStr + "String_Node_Str" + count + "String_Node_Str" + nRunaways + "String_Node_Str" + "String_Node_Str" + e.descrip);
                    try {
                        Class c = e.thread.getClass();
                        Method m = c.getMethod("String_Node_Str", new Class[0]);
                        StackTraceElement[] stackTrace = (StackTraceElement[]) m.invoke(e.thread, new Object[0]);
                        StringBuffer buf = new StringBuffer();
                        for (int i = 0; i < stackTrace.length; i++) {
                            buf.append("String_Node_Str");
                            buf.append(stackTrace[i].toString());
                            buf.append("String_Node_Str");
                        }
                        Trace.warning("String_Node_Str" + buf.toString());
                    } catch (Exception exc) {
                    }
                }
            }
        }
    } catch (InterruptedException e) {
    }
}

Output:
         while (true) {
-            Thread.sleep(1000);
+            Thread.sleep(5100);
             synchronized (beingWatched) {


Input:
public Triggerable addTriggerable(Triggerable t) {
    int existingIx = triggerables.indexOf(t);
    if (existingIx >= 0) {
        Triggerable existingTriggerable = (Triggerable) triggerables.elementAt(existingIx);
        existingTriggerable.contextRef = existingTriggerable.contextRef.intersect(t.contextRef);
        return existingTriggerable;
    } else {
        triggerables.addElement(t);
        triggerablesInOrder = false;
        Vector triggers = t.getTriggers();
        for (int i = 0; i < triggers.size(); i++) {
            TreeReference trigger = (TreeReference) triggers.elementAt(i);
            if (!triggerIndex.containsKey(trigger)) {
                triggerIndex.put(trigger, new Vector());
            }
            Vector triggered = (Vector) triggerIndex.get(trigger);
            if (!triggered.contains(t)) {
                triggered.addElement(t);
            }
        }
        return t;
    }
}

Output:
             if (!triggerIndex.containsKey(trigger)) {
-                triggerIndex.put(trigger, new Vector());
+                triggerIndex.put(trigger.clone(), new Vector());
             }


Input:
public void propertyChange(PropertyChangeEvent event) {
    if (event.getPropertyName().equals(PreviewLabel.BACKGROUND_COLOR_PROPERTY_NAME))
        getViewport().setBackground(data.getColor(isActive ? Theme.FILE_TABLE_BACKGROUND_COLOR : Theme.FILE_TABLE_INACTIVE_BACKGROUND_COLOR));
    else if (event.getPropertyName().equals(PreviewLabel.BORDER_COLOR_PROPERTY_NAME))
        ((MutableLineBorder) getBorder()).setLineColor(data.getColor(isActive ? Theme.FILE_TABLE_BORDER_COLOR : Theme.FILE_TABLE_INACTIVE_BORDER_COLOR));
    else if (!event.getPropertyName().equals(PreviewLabel.FOREGROUND_COLOR_PROPERTY_NAME))
        return;
    repaint();
}

Output:
         getViewport().setBackground(data.getColor(isActive ? Theme.FILE_TABLE_BACKGROUND_COLOR : Theme.FILE_TABLE_INACTIVE_BACKGROUND_COLOR));
-    else if (event.getPropertyName().equals(PreviewLabel.BORDER_COLOR_PROPERTY_NAME))
-        ((MutableLineBorder) getBorder()).setLineColor(data.getColor(isActive ? Theme.FILE_TABLE_BORDER_COLOR : Theme.FILE_TABLE_INACTIVE_BORDER_COLOR));
-    else if (!event.getPropertyName().equals(PreviewLabel.FOREGROUND_COLOR_PROPERTY_NAME))
+    else if (event.getPropertyName().equals(PreviewLabel.BORDER_COLOR_PROPERTY_NAME)) {
+        if (getBorder() instanceof MutableLineBorder)
+            ((MutableLineBorder) getBorder()).setLineColor(data.getColor(isActive ? Theme.FILE_TABLE_BORDER_COLOR : Theme.FILE_TABLE_INACTIVE_BORDER_COLOR));
+    } else if (!event.getPropertyName().equals(PreviewLabel.FOREGROUND_COLOR_PROPERTY_NAME))
         return;


Input:
public static void wavePlot(String fileName) {
    double[] fileArray = read(fileName);
    ArrayList<Double> fileArrayList = ArrayUtil.doubleVectorFromArray(fileArray);
    DrawingPanel panel = new DrawingPanel(500, 500, "String_Node_Str" + fileName);
    Plot.linePlot(panel, -1.0, 1.0, fileArrayList, Color.black);
}

Output:
     DrawingPanel panel = new DrawingPanel(500, 500, "String_Node_Str" + fileName);
-    Plot.linePlot(panel, -1.0, 1.0, fileArrayList, Color.black);
+    GraphicsUtil.linePlot(panel, -1.0, 1.0, fileArrayList, Color.black);
 }


Input:
private float getRatio(Sound[] subsound) {
    return subsound[0].getSamples().length * 1.0f / (this.attack[0].getSamples().length + this.decay[0].getSamples().length + this.sustain[0].getSamples().length + this.release[0].getSamples().length);
}

Output:
 private float getRatio(Sound[] subsound) {
-    return subsound[0].getSamples().length * 1.0f / (this.attack[0].getSamples().length + this.decay[0].getSamples().length + this.sustain[0].getSamples().length + this.release[0].getSamples().length);
+    int lengthOfSubsound = subsound[0].getSamples().length;
+    int lengthOfSound = (this.attack[0].getSamples().length + this.decay[0].getSamples().length + this.sustain[0].getSamples().length + this.release[0].getSamples().length);
+    return lengthOfSubsound * 1.0f / lengthOfSound;
 }


Input:
public static UniqueId generateId(SharedStreetsReference ssr) {
    String hashString = new String();
    hashString = "String_Node_Str" + ssr.formOfWay.value;
    for (SharedStreetsLocationReference lr : ssr.locationReferences) {
        hashString += String.format("String_Node_Str", lr.point.getX(), lr.point.getY());
        if (lr.outboundBearing != null) {
            hashString += String.format("String_Node_Str", Math.round(lr.outboundBearing));
            hashString += String.format("String_Node_Str", Math.round(lr.distanceToNextRef * 100));
        }
        if (lr.inboundBearing != null) {
            hashString += String.format("String_Node_Str", Math.round(lr.inboundBearing));
        }
    }
    UniqueId id = UniqueId.generateHash(hashString);
    return id;
}

Output:
     }
-    UniqueId id = UniqueId.generateHash(hashString);
-    return id;
+    return UniqueId.generateHash(hashString);
 }


Input:
public void testReturnColumns4reCreateConnection() throws Exception {
    Assert.assertNotNull(getExtractManger());
    Connection conn = mockConnection4ReturnColumns4reCreateConnection();
    extractMeta.setConn(conn);
    IMetadataConnection metadataConn = mockMetadataConnection4ReturnColumns4reCreateConnection();
    DatabaseMetaData dbMetadata = mockDatabaseMetaData4ReturnColumns4reCreateConnection();
    when(conn.getMetaData()).thenReturn(dbMetadata);
    ResultSet getColumnsResultSet = mockGetColumnsResultSet4ReturnColumns4reCreateConnection();
    doReturn(getColumnsResultSet).when(dbMetadata).getColumns(anyString(), anyString(), anyString(), anyString());
    TableNode tableNode = mockTableNode4ReturnColumns4reCreateConnection();
    TdTable tdTable = mockTable4ReturnColumns4reCreateConnection();
    when(tableNode.getTable()).thenReturn(tdTable);
    List conList = new ArrayList();
    conList.add(conn);
    DriverShim wapperDriver = mock(DriverShim.class);
    conList.add(wapperDriver);
    when(extractMeta.getConnection(anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(conList);
    when(extractMeta.getDatabaseMetaData(conn, metadataConn.getDbType(), metadataConn.isSqlMode(), metadataConn.getDatabase())).thenReturn(dbMetadata);
    List<TdColumn> columns = getExtractManger().returnColumns(metadataConn, tableNode, false);
    Assert.assertNotNull(columns);
    Assert.assertTrue(columns.isEmpty());
    extractMeta.setConn(null);
}

Output:
     when(tableNode.getTable()).thenReturn(tdTable);
-    List conList = new ArrayList();
-    conList.add(conn);
+    List list = extractMeta.getConnection(metadataConn.getDbType(), metadataConn.getUrl(), metadataConn.getUsername(), metadataConn.getPassword(), metadataConn.getDatabase(), metadataConn.getSchema(), metadataConn.getDriverClass(), metadataConn.getDriverJarPath(), metadataConn.getDbVersionString(), metadataConn.getAdditionalParams());
+    assertTrue(list.size() == 0);
+    list.add(conn);
+    assertTrue(list.size() != 0);
+    List conMockList = mock(List.class);
+    conMockList.add(conn);
     DriverShim wapperDriver = mock(DriverShim.class);


Input:
public void fillRectangle(RectangleRenderEvent rre) throws ChartException {
    if (iv != null) {
        iv.modifyEvent(rre);
    }
    final Fill flBackground = validateMultipleFill(rre.getBackground());
    if (isFullTransparent(flBackground)) {
        return;
    }
    final Bounds bo = normalizeBounds(rre.getBounds());
    final Rectangle2D.Double r2d = new Rectangle2D.Double(bo.getLeft(), bo.getTop(), bo.getWidth(), bo.getHeight());
    if (flBackground instanceof ColorDefinition) {
        final ColorDefinition cd = (ColorDefinition) flBackground;
        _g2d.setColor((Color) _ids.getColor(cd));
        _g2d.fill(r2d);
    } else if (flBackground instanceof Gradient) {
        final Gradient g = (Gradient) flBackground;
        final ColorDefinition cdStart = g.getStartColor();
        final ColorDefinition cdEnd = g.getEndColor();
        double dAngleInDegrees = g.getDirection();
        final double dAngleInRadians = ((-dAngleInDegrees * Math.PI) / 180.0);
        if (dAngleInDegrees < -90 || dAngleInDegrees > 90) {
            throw new ChartException(ChartDeviceExtensionPlugin.ID, ChartException.RENDERING, "String_Node_Str", new Object[] { new Double(dAngleInDegrees) }, Messages.getResourceBundle(getULocale()));
        }
        Point2D.Double p2dStart, p2dEnd;
        if (dAngleInDegrees == 90) {
            p2dStart = new Point2D.Double(bo.getLeft(), bo.getTop() + bo.getHeight());
            p2dEnd = new Point2D.Double(bo.getLeft(), bo.getTop());
        } else if (dAngleInDegrees == -90) {
            p2dEnd = new Point2D.Double(bo.getLeft(), bo.getTop() + bo.getHeight());
            p2dStart = new Point2D.Double(bo.getLeft(), bo.getTop());
        } else if (dAngleInDegrees > 0) {
            p2dStart = new Point2D.Double(bo.getLeft(), bo.getTop() + bo.getHeight());
            p2dEnd = new Point2D.Double(bo.getLeft() + bo.getWidth(), bo.getTop() + bo.getHeight() - bo.getWidth() * Math.abs(Math.tan(dAngleInRadians)));
        } else if (dAngleInDegrees < 0) {
            p2dStart = new Point2D.Double(bo.getLeft(), bo.getTop());
            p2dEnd = new Point2D.Double(bo.getLeft() + bo.getWidth(), bo.getTop() + bo.getWidth() * Math.abs(Math.tan(dAngleInRadians)));
        } else {
            p2dStart = new Point2D.Double(bo.getLeft(), bo.getTop());
            p2dEnd = new Point2D.Double(bo.getLeft() + bo.getWidth(), bo.getTop());
        }
        _g2d.setPaint(new GradientPaint(p2dStart, (Color) _ids.getColor(cdStart), p2dEnd, (Color) _ids.getColor(cdEnd)));
        _g2d.fill(r2d);
    } else if (flBackground instanceof org.eclipse.birt.chart.model.attribute.Image) {
        if (flBackground instanceof PatternImage) {
            fillWithPatternImage(new Area(r2d), flBackground);
            return;
        }
        java.awt.Image img = createImageFromModel(flBackground);
        if (img != null) {
            final Shape shClip = _g2d.getClip();
            Area ar2 = new Area(r2d);
            if (shClip != null) {
                Area ar1 = new Area(shClip);
                ar2.intersect(ar1);
            }
            _g2d.setClip(ar2);
            final Size szImage = _ids.getSize(img);
            int iXRepeat = (int) (Math.ceil(r2d.width / szImage.getWidth()));
            int iYRepeat = (int) (Math.ceil(r2d.height / szImage.getHeight()));
            ImageObserver io = (ImageObserver) _ids.getObserver();
            for (int i = 0; i < iXRepeat; i++) {
                for (int j = 0; j < iYRepeat; j++) {
                    _g2d.drawImage(img, (int) (r2d.x + i * szImage.getWidth()), (int) (r2d.y + j * szImage.getHeight()), io);
                }
            }
            _g2d.setClip(shClip);
        }
    }
}

Output:
             _g2d.setClip(ar2);
-            final Size szImage = _ids.getSize(img);
+            final Size szImage = computeImageSize(img);
             int iXRepeat = (int) (Math.ceil(r2d.width / szImage.getWidth()));


Input:
public void onPinRequest(LedgerManager.OnPinRequest event) {
    LedgerPinDialog pin = new LedgerPinDialog(this, true, MbwManager.getInstance(this).isRandomizePin());
    pin.setTitle(R.string.ledger_enter_pin);
    pin.setOnPinValid(new PinDialog.OnPinEntered() {
        public void pinEntered(PinDialog dialog, Pin pin) {
            ((LedgerManager) masterseedScanManager).enterPin(pin.getPin());
            dialog.dismiss();
        }
    });
    pin.show();
}

Output:
 public void onPinRequest(LedgerManager.OnPinRequest event) {
-    LedgerPinDialog pin = new LedgerPinDialog(this, true, MbwManager.getInstance(this).isRandomizePin());
+    LedgerPinDialog pin = new LedgerPinDialog(this, true);
     pin.setTitle(R.string.ledger_enter_pin);


Input:
public Node loadDeployedModel(DeployedModel model) {
    try {
        load(AssetUtils.getAssetURL(model.getModelURL()));
    } catch (IOException ex) {
        Logger.getLogger(JmeColladaLoader.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
}

Output:
     }
-    return null;
+    return new Node("String_Node_Str");
 }


Input:
private static TreeSet<Operator> importOperators(Set<URL> operatorURLs) throws IntrospectionException {
    logger.finer("String_Node_Str" + operatorURLs.size() + "String_Node_Str");
    TreeSet<Operator> operators = new TreeSet<Operator>();
    for (URL operatorURL : operatorURLs) {
        try {
            DefaultOperator operator = new DefaultOperator(operatorURL);
            if (Config.compareProgramVersions(Config.getLatestVersion(), operator.getMinProgramVersion()) >= 0) {
                operators.add(operator);
            } else {
                logger.info("String_Node_Str" + operator.getName() + "String_Node_Str" + operator.getMinProgramVersion() + "String_Node_Str");
            }
        } catch (IOException ex) {
            logger.log(Level.WARNING, "String_Node_Str" + operatorURL.toExternalForm(), ex);
        } catch (IntrospectionException ex) {
            throw ex;
        } catch (Exception ex) {
            logger.log(Level.WARNING, "String_Node_Str" + operatorURL.toExternalForm(), ex);
        }
    }
    logger.finer("String_Node_Str" + operators.size() + "String_Node_Str");
    return operators;
}

Output:
             DefaultOperator operator = new DefaultOperator(operatorURL);
-            if (Config.compareProgramVersions(Config.getLatestVersion(), operator.getMinProgramVersion()) >= 0) {
-                operators.add(operator);
-            } else {
+            if (Config.compareProgramVersions(Config.getLatestVersion(), operator.getMinProgramVersion()) < 0) {
                 logger.info("String_Node_Str" + operator.getName() + "String_Node_Str" + operator.getMinProgramVersion() + "String_Node_Str");


Input:
public static boolean register(final Component component, String part, String name, String hostName, Integer port) throws ServiceRegistrationException {
    final ServiceBuilder builder = component.getBuilder();
    String partition = part;
    if (!component.getComponentId().isPartitioned()) {
        partition = name;
    } else if (component.getComponentId().isCloudLocal()) {
        partition = Components.lookup(Eucalyptus.class).getComponentId().name();
    } else if (partition == null) {
        LOG.error("String_Node_Str");
        partition = name;
    }
    InetAddress addr;
    try {
        addr = InetAddress.getByName(hostName);
    } catch (UnknownHostException ex1) {
        LOG.error("String_Node_Str" + hostName + "String_Node_Str" + ex1.getMessage(), ex1);
        throw new ServiceRegistrationException(builder.getClass().getSimpleName() + "String_Node_Str" + hostName + "String_Node_Str" + ex1.getMessage(), ex1);
    }
    LOG.info("String_Node_Str" + builder.getClass().getSimpleName() + "String_Node_Str" + partition + "String_Node_Str" + name + "String_Node_Str" + hostName + "String_Node_Str" + port);
    if (!builder.checkAdd(partition, name, hostName, port)) {
        LOG.info(builder.getClass().getSimpleName() + "String_Node_Str");
        return false;
    }
    try {
        final ServiceConfiguration newComponent = builder.add(partition, name, hostName, port);
        try {
            Runnable followRunner = new Runnable() {
                public void run() {
                    try {
                        try {
                            component.startTransition(newComponent).get();
                        } catch (Exception ex) {
                            LOG.error(ex, ex);
                        }
                        component.enableTransition(newComponent).get();
                    } catch (ServiceRegistrationException ex1) {
                        LOG.error(ex1, ex1);
                    } catch (IllegalStateException ex1) {
                        LOG.error(ex1, ex1);
                    } catch (ExecutionException ex) {
                        LOG.error(ex, ex);
                    } catch (InterruptedException ex) {
                        Thread.currentThread().interrupt();
                    }
                }
            };
            try {
                Threads.lookup(ConfigurationService.class, ComponentRegistrationHandler.class).submit(followRunner).get(5000, TimeUnit.MILLISECONDS);
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            } catch (TimeoutException ex) {
                LOG.error(ex, ex);
            }
        } catch (Throwable ex) {
            builder.remove(newComponent);
            LOG.info(builder.getClass().getSimpleName() + "String_Node_Str" + ex.getMessage());
        }
        return true;
    } catch (Throwable e) {
        e = Exceptions.filterStackTrace(e);
        LOG.info(builder.getClass().getSimpleName() + "String_Node_Str" + e.getMessage());
        LOG.error(e, e);
        throw new ServiceRegistrationException(builder.getClass().getSimpleName() + "String_Node_Str" + e.getMessage(), e);
    }
}

Output:
         try {
-            Runnable followRunner = new Runnable() {
-                public void run() {
-                    try {
-                        try {
-                            component.startTransition(newComponent).get();
-                        } catch (Exception ex) {
-                            LOG.error(ex, ex);
-                        }
-                        component.enableTransition(newComponent).get();
-                    } catch (ServiceRegistrationException ex1) {
-                        LOG.error(ex1, ex1);
-                    } catch (IllegalStateException ex1) {
-                        LOG.error(ex1, ex1);
-                    } catch (ExecutionException ex) {
-                        LOG.error(ex, ex);
-                    } catch (InterruptedException ex) {
-                        Thread.currentThread().interrupt();
-                    }
-                }
-            };
-            try {
-                Threads.lookup(ConfigurationService.class, ComponentRegistrationHandler.class).submit(followRunner).get(5000, TimeUnit.MILLISECONDS);
-            } catch (InterruptedException ex) {
-                Thread.currentThread().interrupt();
-            } catch (TimeoutException ex) {
-                LOG.error(ex, ex);
-            }
+            doServiceStart(newComponent);
         } catch (Throwable ex) {


Input:
public void execute(RequestHandler handler, FtpRequestImpl request, FtpWriter out) throws IOException, FtpException {
    try {
        request.resetState();
        IFtpConfig fconfig = handler.getConfig();
        Ftplet ftpletContainer = fconfig.getFtpletContainer();
        FtpletEnum ftpletRet = ftpletContainer.onUploadUniqueStart(request, out);
        if (ftpletRet == FtpletEnum.RET_SKIP) {
            return;
        } else if (ftpletRet == FtpletEnum.RET_DISCONNECT) {
            fconfig.getConnectionManager().closeConnection(handler);
            return;
        }
        FileObject file = null;
        try {
            file = request.getFileSystemView().getFileObject("String_Node_Str");
            file = getUniqueFile(handler, file);
        } catch (Exception ex) {
        }
        if (file == null) {
            out.send(550, "String_Node_Str", null);
            return;
        }
        String fileName = file.getFullName();
        if (!file.hasWritePermission()) {
            out.send(550, "String_Node_Str", fileName);
            return;
        }
        out.send(150, "String_Node_Str", null);
        InputStream is = null;
        try {
            is = request.getDataInputStream();
        } catch (IOException ex) {
            out.send(425, "String_Node_Str", fileName);
            return;
        }
        boolean failure = false;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        out.send(250, "String_Node_Str", fileName);
        try {
            bis = IoUtils.getBufferedInputStream(is);
            bos = IoUtils.getBufferedOutputStream(file.createOutputStream(false));
            int maxRate = handler.getRequest().getUser().getMaxUploadRate();
            long transSz = handler.transfer(bis, bos, maxRate);
            String userName = request.getUser().getName();
            Log log = fconfig.getLogFactory().getInstance(getClass());
            log.info("String_Node_Str" + userName + "String_Node_Str" + fileName);
            IFtpStatistics ftpStat = (IFtpStatistics) fconfig.getFtpStatistics();
            ftpStat.setUpload(handler, file, transSz);
        } catch (SocketException ex) {
            failure = true;
            out.send(426, "String_Node_Str", fileName);
        } catch (IOException ex) {
            failure = true;
            out.send(551, "String_Node_Str", fileName);
        } finally {
            IoUtils.close(bis);
            IoUtils.close(bos);
        }
        if (!failure) {
            out.send(226, "String_Node_Str", fileName);
            ftpletRet = ftpletContainer.onUploadUniqueEnd(request, out);
            if (ftpletRet == FtpletEnum.RET_DISCONNECT) {
                fconfig.getConnectionManager().closeConnection(handler);
                return;
            }
        }
    } finally {
        request.getFtpDataConnection().closeDataSocket();
    }
}

Output:
             file = request.getFileSystemView().getFileObject("String_Node_Str");
-            file = getUniqueFile(handler, file);
+            if (file != null) {
+                file = getUniqueFile(handler, file);
+            }
         } catch (Exception ex) {


Input:
private static OkHttpClient createClientWithCache(Config config) {
    File httpCacheDirectory;
    try {
        httpCacheDirectory = Files.createTempFile(config.getCacheConfig().getName(), "String_Node_Str").toFile();
        httpCacheDirectory.deleteOnExit();
    } catch (IOException e) {
        throw new IllegalStateException("String_Node_Str", e);
    }
    Cache cache = new Cache(httpCacheDirectory, config.getCacheConfig().getSize());
    return new OkHttpClient.Builder().connectTimeout(config.getTimeout(), TimeUnit.SECONDS).readTimeout(config.getTimeout(), TimeUnit.SECONDS).cache(cache).build();
}

Output:
     try {
-        httpCacheDirectory = Files.createTempFile(config.getCacheConfig().getName(), "String_Node_Str").toFile();
-        httpCacheDirectory.deleteOnExit();
+        httpCacheDirectory = Files.createTempDirectory(config.getCacheConfig().getName()).toFile();
+        LOG.info("String_Node_Str", httpCacheDirectory.getAbsolutePath());
     } catch (IOException e) {


Input:
public List<Var> usedVar() {
    LinkedList<Var> registers = new LinkedList<>();
    appendUsedVar(val, registers);
    if (super.dst() instanceof Memory)
        registers.addAll(((Memory) super.dst()).usedVar());
    return registers;
}

Output:
     LinkedList<Var> registers = new LinkedList<>();
-    appendUsedVar(val, registers);
+    appendUsedVar(src, registers);
     if (super.dst() instanceof Memory)


Input:
public void addInstanceContext(String instanceId, Cluster cluster, boolean hasScalingDependents, boolean groupScalingEnabledSubtree) throws PolicyValidationException, PartitionValidationException {
    ClusterLevelNetworkPartitionContext networkPartitionContext = null;
    ClusterInstance clusterInstance = cluster.getInstanceContexts(instanceId);
    String deploymentPolicyName = AutoscalerUtil.getDeploymentPolicyIdByAlias(cluster.getAppId(), AutoscalerUtil.getAliasFromClusterId(clusterId));
    DeploymentPolicy deploymentPolicy;
    try {
        deploymentPolicy = CloudControllerServiceClient.getInstance().getDeploymentPolicy(deploymentPolicyName);
    } catch (Exception e) {
        String msg = String.format("String_Node_Str", deploymentPolicyName);
        log.error(msg, e);
        throw new AutoScalerException(msg, e);
    }
    if (networkPartitionCtxts.containsKey(clusterInstance.getNetworkPartitionId())) {
        networkPartitionContext = this.networkPartitionCtxts.get(clusterInstance.getNetworkPartitionId());
    } else {
        NetworkPartitionRef[] networkPartitionRefs = deploymentPolicy.getNetworkPartitionsRef();
        NetworkPartitionRef networkPartitionRef = null;
        if (networkPartitionRefs != null && networkPartitionRefs.length != 0) {
            for (NetworkPartitionRef i : networkPartitionRefs) {
                if (i.getId().equals(clusterInstance.getNetworkPartitionId())) {
                    networkPartitionRef = i;
                }
            }
        }
        networkPartitionContext = new ClusterLevelNetworkPartitionContext(networkPartitionRef.getId(), networkPartitionRef.getPartitionAlgo(), 0);
    }
    if (clusterInstance.getPartitionId() != null) {
        networkPartitionContext = addPartition(clusterInstance, cluster, networkPartitionContext, null, hasScalingDependents, groupScalingEnabledSubtree);
    } else {
        networkPartitionContext = parseDeploymentPolicy(clusterInstance, cluster, networkPartitionContext, hasScalingDependents, groupScalingEnabledSubtree);
    }
    if (!networkPartitionCtxts.containsKey(clusterInstance.getNetworkPartitionId())) {
        this.networkPartitionCtxts.put(clusterInstance.getNetworkPartitionId(), networkPartitionContext);
        if (log.isInfoEnabled()) {
            log.info(String.format("String_Node_Str" + "String_Node_Str", clusterInstance.getInstanceId(), clusterInstance.getNetworkPartitionId()));
        }
    }
}

Output:
         }
-        networkPartitionContext = new ClusterLevelNetworkPartitionContext(networkPartitionRef.getId(), networkPartitionRef.getPartitionAlgo(), 0);
+        if (networkPartitionRef == null) {
+            networkPartitionContext = new ClusterLevelNetworkPartitionContext(clusterInstance.getNetworkPartitionId());
+        } else {
+            networkPartitionContext = new ClusterLevelNetworkPartitionContext(networkPartitionRef.getId(), networkPartitionRef.getPartitionAlgo(), 0);
+        }
     }


Input:
protected void drawGuiContainerForegroundLayer(int x, int y) {
    if (drawPlayerInv)
        drawString(StatCollector.translateToLocal("String_Node_Str"), 5, ySize + 6, textColor);
    String name = Utils.localize(String.format("String_Node_Str", getInventoryName()));
    drawString(name, centerTitle ? getXSize() / 2 - (name.length() * 2) : titleXoffset, titleYoffset, textColor);
    drawForegroundExtra(x, y);
}

Output:
     if (drawPlayerInv)
-        drawString(StatCollector.translateToLocal("String_Node_Str"), 5, ySize + 6, textColor);
+        drawString(StatCollector.translateToLocal("String_Node_Str"), 5, tileGuiYSize + 6, textColor);
     String name = Utils.localize(String.format("String_Node_Str", getInventoryName()));