Input:
private void createAttributeArea(Composite parent) {
    grpAttributes = new Group(parent, SWT.NONE);
    {
        grpAttributes.setLayoutData(new GridData(GridData.FILL_BOTH));
        grpAttributes.setLayout(new GridLayout(2, false));
        grpAttributes.setText(Messages.getString("String_Node_Str"));
    }
    lblPosition = new Label(grpAttributes, SWT.NONE);
    GridData gdLBLPosition = new GridData();
    lblPosition.setLayoutData(gdLBLPosition);
    lblPosition.setText(Messages.getString("String_Node_Str"));
    cmbPosition = new Combo(grpAttributes, SWT.DROP_DOWN | SWT.READ_ONLY);
    GridData gdCMBPosition = new GridData(GridData.FILL_BOTH);
    cmbPosition.setLayoutData(gdCMBPosition);
    cmbPosition.addSelectionListener(this);
    lblFont = new Label(grpAttributes, SWT.NONE);
    GridData gdLFont = new GridData();
    lblFont.setLayoutData(gdLFont);
    lblFont.setText(Messages.getString("String_Node_Str"));
    fdcFont = new FontDefinitionComposite(grpAttributes, SWT.NONE, getContext(), getSeriesForProcessing().getLabel().getCaption().getFont(), getSeriesForProcessing().getLabel().getCaption().getColor(), false);
    GridData gdFDCFont = new GridData(GridData.FILL_BOTH);
    gdFDCFont.heightHint = fdcFont.getPreferredSize().y;
    gdFDCFont.widthHint = 96;
    gdFDCFont.grabExcessVerticalSpace = false;
    fdcFont.setLayoutData(gdFDCFont);
    fdcFont.addListener(this);
    lblFill = new Label(grpAttributes, SWT.NONE);
    GridData gdLFill = new GridData();
    lblFill.setLayoutData(gdLFill);
    lblFill.setText(Messages.getString("String_Node_Str"));
    fccBackground = new FillChooserComposite(grpAttributes, SWT.NONE, getContext(), getSeriesForProcessing().getLabel().getBackground(), false, false);
    GridData gdFCCBackground = new GridData(GridData.FILL_BOTH);
    gdFCCBackground.heightHint = fccBackground.getPreferredSize().y;
    fccBackground.setLayoutData(gdFCCBackground);
    fccBackground.addListener(this);
    lblShadow = new Label(grpAttributes, SWT.NONE);
    GridData gdLBLShadow = new GridData();
    lblShadow.setLayoutData(gdLBLShadow);
    lblShadow.setText(Messages.getString("String_Node_Str"));
    fccShadow = new FillChooserComposite(grpAttributes, SWT.NONE, getContext(), getSeriesForProcessing().getLabel().getShadowColor(), false, false);
    GridData gdFCCShadow = new GridData(GridData.FILL_BOTH);
    fccShadow.setLayoutData(gdFCCShadow);
    fccShadow.addListener(this);
}

Output:
     GridData gdFDCFont = new GridData(GridData.FILL_BOTH);
-    gdFDCFont.heightHint = fdcFont.getPreferredSize().y;
-    gdFDCFont.widthHint = 96;
+    gdFDCFont.widthHint = fdcFont.getPreferredSize().x;
     gdFDCFont.grabExcessVerticalSpace = false;


Input:
public void addListenerToChartComp(Object chartComposite, final String referenceLink, final String menuText) {
    final ChartComposite chartComp = (ChartComposite) chartComposite;
    ChartMouseListener listener = new ChartMouseListener() {

        public void chartMouseClicked(ChartMouseEvent event) {
            if (event.getTrigger().getButton() == 1 && referenceLink != null) {
                Menu menu = new Menu(chartComp.getShell(), SWT.POP_UP);
                chartComp.setMenu(menu);
                MenuItem item = new MenuItem(menu, SWT.PUSH);
                item.setText(menuText);
                item.addSelectionListener(new SelectionAdapter() {
                    public void widgetSelected(SelectionEvent e) {
                        ChartUtils.openReferenceLink(referenceLink);
                    }
                });
                menu.setVisible(true);
            }
        }
        public void chartMouseMoved(ChartMouseEvent event) {
        }
    };
    chartComp.addChartMouseListener(listener);
    chartComp.addDisposeListener(new DisposeListener() {
        public void widgetDisposed(DisposeEvent e) {
            chartComp.removeChartMouseListener(listener);
            chartComp.dispose();
        }
    });
}

Output:
     final ChartComposite chartComp = (ChartComposite) chartComposite;
-    ChartMouseListener listener = new ChartMouseListener() {
+    final ChartMouseListener listener = new ChartMouseListener() {


Input:
private static Response transformResponsePerson(Response r) {
    if (r.role().equalTo(VEHICLE_ROLE)) {
        r = r.copyWithSwappedRole(INSTRUMENT_ROLE);
    }
    if (r.role().equalTo(ARTIFACT_ROLE)) {
        r = r.copyWithSwappedRole(PERSON_ROLE);
    }
    if (r.type().equalTo(MOVEMENT_TRANSPORT)) {
        return r.copyWithSwappedRole(MOVEMENT_TRANSPORT_PERSON);
    } else {
        return r;
    }
}

Output:
     if (r.type().equalTo(MOVEMENT_TRANSPORT)) {
-        return r.copyWithSwappedRole(MOVEMENT_TRANSPORT_PERSON);
+        return r.copyWithSwappedType(MOVEMENT_TRANSPORT_PERSON);
     } else {


Input:
private void create(final Composite root) {
    root.setLayout(new FillLayout());
    Tree tree = new Tree(root, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
    tree.setHeaderVisible(true);
    treeViewer = new TreeViewer(tree);
    tree.setMenu(new ClipboardHandlerTree(treeViewer).getMenu());
    final TreeColumn column1 = new TreeColumn(tree, SWT.LEFT);
    tree.setLinesVisible(true);
    column1.setAlignment(SWT.LEFT);
    column1.setText(Resources.getMessage("String_Node_Str"));
    column1.setWidth(160);
    final TreeColumn column2 = new TreeColumn(tree, SWT.RIGHT);
    column2.setAlignment(SWT.LEFT);
    column2.setText(Resources.getMessage("String_Node_Str"));
    column2.setWidth(100);
    final TreeColumn column6 = new TreeColumn(tree, SWT.RIGHT);
    column6.setAlignment(SWT.LEFT);
    column6.setText(Resources.getMessage("String_Node_Str"));
    column6.setWidth(100);
    final TreeColumn column7 = new TreeColumn(tree, SWT.RIGHT);
    column7.setAlignment(SWT.LEFT);
    column7.setText(Resources.getMessage("String_Node_Str"));
    column7.setWidth(80);
    final TreeColumn column3 = new TreeColumn(tree, SWT.RIGHT);
    column3.setAlignment(SWT.LEFT);
    column3.setText(Resources.getMessage("String_Node_Str"));
    column3.setWidth(50);
    final TreeColumn column4 = new TreeColumn(tree, SWT.RIGHT);
    column4.setAlignment(SWT.LEFT);
    column4.setText(Resources.getMessage("String_Node_Str"));
    column4.setWidth(50);
    final TreeColumn column5 = new TreeColumn(tree, SWT.RIGHT);
    column5.setAlignment(SWT.LEFT);
    column5.setText(Resources.getMessage("String_Node_Str"));
    column5.setWidth(50);
    final TreeColumn column8 = new TreeColumn(tree, SWT.RIGHT);
    column8.setAlignment(SWT.LEFT);
    column8.setText(Resources.getMessage("String_Node_Str"));
    column8.setWidth(50);
    final TreeColumn column9 = new TreeColumn(tree, SWT.RIGHT);
    column9.setAlignment(SWT.LEFT);
    column9.setText(Resources.getMessage("String_Node_Str"));
    column9.setWidth(50);
    treeViewer.setContentProvider(new InputContentProvider());
    treeViewer.setLabelProvider(new InputLabelProvider());
    treeViewer.setInput(roots);
    treeViewer.expandAll();
}

Output:
     root.setLayout(new FillLayout());
-    Tree tree = new Tree(root, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
+    Tree tree = new Tree(root, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
     tree.setHeaderVisible(true);


Input:
public Vector<Node> expand(TypedSparqlQuery tsq, Manipulator m) {
    Set<Tupel> s = tsq.query(this.uri);
    Vector<Node> Nodes = new Vector<Node>();
    Iterator<Tupel> it = s.iterator();
    while (it.hasNext()) {
        Tupel t = (Tupel) it.next();
        try {
            if (t.a.equals(m.type)) {
                specialTypes.add(t.b);
            }
        } catch (Exception e) {
            System.out.println(t);
            e.printStackTrace();
        }
    }
    return Nodes;
}

Output:
 public Vector<Node> expand(TypedSparqlQuery tsq, Manipulator m) {
-    Set<Tupel> s = tsq.query(this.uri);
+    Set<Tupel> s = tsq.query(uri);
     Vector<Node> Nodes = new Vector<Node>();


Input:
private AgentStatPoint<Integer> createPoint(long timestamp, List<Integer> values) {
    if (values.isEmpty()) {
        return SampledDataSource.UNCOLLECTED_POINT_CREATER.createUnCollectedPoint(timestamp);
    } else {
        return new AgentStatPoint<>(timestamp, INTEGER_DOWN_SAMPLER.sampleMin(values), INTEGER_DOWN_SAMPLER.sampleMax(values), INTEGER_DOWN_SAMPLER.sampleAvg(values, 3), INTEGER_DOWN_SAMPLER.sampleSum(values));
    }
}

Output:
     if (values.isEmpty()) {
-        return SampledDataSource.UNCOLLECTED_POINT_CREATER.createUnCollectedPoint(timestamp);
+        return SampledDataSource.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp);
     } else {


Input:
public void testModifyAndUpdateRollbacked() {
    CriteriaBuilder<Document> criteria = cbf.create(em, Document.class, "String_Node_Str").orderByAsc("String_Node_Str");
    CriteriaBuilder<T> cb = evm.applySetting(EntityViewSetting.create(viewType), criteria);
    List<T> results = cb.getResultList();
    T docView = results.get(0);
    EntityTransaction tx = em.getTransaction();
    try {
        tx.begin();
        docView.setName("String_Node_Str");
        evm.update(em, docView);
        em.flush();
        tx.rollback();
        docView.setName("String_Node_Str");
        docView.setLastModified(new Date());
        tx.begin();
        evm.update(em, docView);
        em.flush();
        tx.commit();
    } catch (Exception e) {
        tx.rollback();
        throw new RuntimeException(e);
    }
    em.clear();
    doc = em.find(Document.class, doc.getId());
    assertEquals(doc.getName(), docView.getName());
    assertEquals(doc.getLastModified().getTime(), docView.getLastModified().getTime());
}

Output:
         docView.setName("String_Node_Str");
-        docView.setLastModified(new Date());
+        Date date = new Date();
+        date.setTime(1000 * (date.getTime() / 1000));
+        docView.setLastModified(date);
         tx.begin();


Input:
public synchronized void updateMediaItem(String path, mediaColumn col, Object object) {
    ContentValues values = new ContentValues();
    switch(col) {
        case MEDIA_THUMBNAIL:
            Bitmap thumbnail = (Bitmap) object;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            thumbnail.compress(Bitmap.CompressFormat.PNG, 100, out);
            values.put(MEDIA_THUMBNAIL, out.toByteArray());
            break;
        default:
            return;
    }
    mDb.update(MEDIA_TABLE_NAME, values, MEDIA_PATH + "String_Node_Str" + path + "String_Node_Str", null);
}

Output:
     }
-    mDb.update(MEDIA_TABLE_NAME, values, MEDIA_PATH + "String_Node_Str" + path + "String_Node_Str", null);
+    mDb.update(MEDIA_TABLE_NAME, values, MEDIA_PATH + "String_Node_Str", new String[] { path });
 }


Input:
private Statement renderCallNode(Label parametersReattachPoint, CallNode node, Expression calleeExpression) {
    Statement initAppendable = Statement.NULL_STATEMENT;
    Statement clearAppendable = Statement.NULL_STATEMENT;
    Expression appendable;
    FieldRef currentCalleeField = variables.getCurrentCalleeField();
    if (!areAllPrintDirectivesStreamable(node)) {
        calleeExpression = MethodRef.RUNTIME_APPLY_ESCAPERS.invoke(calleeExpression, getEscapingDirectivesList(node));
        appendable = appendableExpression;
    } else {
        AppendableAndOptions wrappedAppendable = applyStreamingEscapingDirectives(node.getEscapingDirectives(), appendableExpression, parameterLookup.getRenderContext());
        FieldRef currentAppendableField = variables.getCurrentAppendable();
        initAppendable = currentAppendableField.putInstanceField(thisVar, wrappedAppendable.appendable());
        appendable = currentAppendableField.accessor(thisVar);
        clearAppendable = currentAppendableField.putInstanceField(thisVar, constantNull(LOGGING_ADVISING_APPENDABLE_TYPE));
        if (wrappedAppendable.closeable()) {
            clearAppendable = Statement.concat(currentAppendableField.accessor(thisVar).checkedCast(BytecodeUtils.CLOSEABLE_TYPE).invokeVoid(MethodRef.CLOSEABLE_CLOSE), clearAppendable);
        }
    }
    Statement initCallee = currentCalleeField.putInstanceField(thisVar, calleeExpression).labelStart(parametersReattachPoint);
    Expression callRender = currentCalleeField.accessor(thisVar).invoke(MethodRef.COMPILED_TEMPLATE_RENDER, appendable, parameterLookup.getRenderContext());
    Statement callCallee = detachState.detachForRender(callRender);
    Statement clearCallee = currentCalleeField.putInstanceField(thisVar, BytecodeUtils.constantNull(COMPILED_TEMPLATE_TYPE));
    return Statement.concat(initAppendable, initCallee, callCallee, clearCallee, clearAppendable);
}

Output:
     } else {
-        AppendableAndOptions wrappedAppendable = applyStreamingEscapingDirectives(node.getEscapingDirectives(), appendableExpression, parameterLookup.getRenderContext());
+        AppendableAndOptions wrappedAppendable = applyStreamingEscapingDirectives(node.getEscapingDirectives(), appendableExpression, parameterLookup.getRenderContext(), variables);
         FieldRef currentAppendableField = variables.getCurrentAppendable();


Input:
private boolean addFile(File file) {
    repOk();
    if (!hasExtension(file.getName())) {
        return false;
    }
    long fileLength = file.length();
    if (fileLength > Integer.MAX_VALUE || fileLength < 0)
        return false;
    Set urns = FileDesc.calculateAndCacheURN(file);
    if (_loadThreadInterrupted)
        return false;
    synchronized (this) {
        _size += fileLength;
        int fileIndex = _files.size();
        FileDesc fileDesc = new FileDesc(file, urns, fileIndex);
        _files.add(fileDesc);
        _numFiles++;
        File parent = getParentFile(file);
        Assert.that(parent != null, "String_Node_Str" + file + "String_Node_Str");
        IntSet siblings = (IntSet) _sharedDirectories.get(parent);
        Assert.that(siblings != null, "String_Node_Str" + parent + "String_Node_Str" + _sharedDirectories);
        boolean added = siblings.add(fileIndex);
        Assert.that(added, "String_Node_Str" + fileIndex + "String_Node_Str" + siblings);
        if (_callback != null)
            _callback.addSharedFile(file, parent);
        String path = file.getAbsolutePath();
        String[] keywords = StringUtils.split(path, DELIMETERS);
        for (int i = 0; i < keywords.length; i++) {
            String keyword = keywords[i];
            IntSet indices = (IntSet) _index.get(keyword);
            if (indices == null) {
                indices = new IntSet();
                _index.add(keyword, indices);
            }
            indices.add(fileIndex);
        }
        this.updateUrnIndex(fileDesc);
        repOk();
        return true;
    }
}

Output:
     Set urns = FileDesc.calculateAndCacheURN(file);
-    if (_loadThreadInterrupted)
+    if (loadThreadInterrupted())
         return false;


Input:
private static TypedReturnCode<TdDataProvider> readFromFile(File file) {
    TypedReturnCode<TdDataProvider> rc = new TypedReturnCode<TdDataProvider>();
    EMFUtil util = new EMFUtil();
    ResourceSet rs = util.getResourceSet();
    Resource r = rs.getResource(URI.createFileURI(file.getAbsolutePath()), true);
    Collection<TdDataProvider> tdDataProviders = DataProviderHelper.getTdDataProviders(r.getContents());
    if (tdDataProviders.isEmpty()) {
        rc.setReturnCode("String_Node_Str" + file.getAbsolutePath(), false);
    }
    if (tdDataProviders.size() > 1) {
        rc.setReturnCode("String_Node_Str" + tdDataProviders.size() + "String_Node_Str" + file.getAbsolutePath(), false);
    }
    TdDataProvider prov = tdDataProviders.iterator().next();
    rc.setObject(prov);
    return rc;
}

Output:
     TypedReturnCode<TdDataProvider> rc = new TypedReturnCode<TdDataProvider>();
-    EMFUtil util = new EMFUtil();
+    EMFUtil util = EMFUtil.getInstance();
     ResourceSet rs = util.getResourceSet();


Input:
public void addMapObjectAt(short x, short y, AbstractHexMapObject mapObject) {
    AbstractHexMapObject mapObjectHead = objectsGrid[x][y];
    if (mapObjectHead == null) {
        mapObjectHead = mapObject;
    } else {
        mapObjectHead.addMapObject(mapObject);
    }
}

Output:
     if (mapObjectHead == null) {
-        mapObjectHead = mapObject;
+        objectsGrid[x][y] = mapObject;
     } else {


Input:
protected final void constructionFinishedEvent() {
    for (RelativePoint curr : super.getBuildingType().getAttackers()) {
        super.getGrid().getMapObjectsManager().addSimpleMapObject(curr.calculatePoint(super.getPos()), EMapObjectType.ATTACKABLE_TOWER, false, super.getPlayer());
    }
}

Output:
 protected final void constructionFinishedEvent() {
-    for (RelativePoint curr : super.getBuildingType().getAttackers()) {
-        super.getGrid().getMapObjectsManager().addSimpleMapObject(curr.calculatePoint(super.getPos()), EMapObjectType.ATTACKABLE_TOWER, false, super.getPlayer());
-    }
+    super.getGrid().getMapObjectsManager().addAttackableTowerObject(super.getDoor(), this);
 }


Input:
private void solveAndCheck(Object M, int sizeM, SparseBlockMatrix GT, SparseBlockMatrix NT, VectorNd Rg, VectorNd Rn, VectorNd bm, VectorNd bg, VectorNd bn, VectorNd vel, VectorNd lam, VectorNd the, int typeM) {
    SparseBlockMatrix DT = null;
    VectorNd mu = null;
    VectorNd bet = null;
    int[] Dref = null;
    int numG = GT.colSize();
    int numN = 0;
    if (NT != null && NT.colSize() > 0) {
        numN = NT.colSize();
    }
    KKTSolver solver = new KKTSolver();
    if (M instanceof SparseBlockMatrix) {
        solver.analyze((SparseBlockMatrix) M, sizeM, GT, typeM);
    } else {
        solver.analyze((VectorNd) M, sizeM, GT);
    }
    Status status;
    if (numN == 0) {
        if (M instanceof SparseBlockMatrix) {
            solver.factor((SparseBlockMatrix) M, sizeM, GT, Rg);
        } else {
            solver.factor((VectorNd) M, sizeM, GT, Rg);
        }
        status = solver.solve(vel, lam, bm, bg);
    } else {
        if (M instanceof SparseBlockMatrix) {
            solver.factor((SparseBlockMatrix) M, sizeM, GT, Rg, NT, Rn);
        } else {
            solver.factor((VectorNd) M, sizeM, GT, Rg, NT, Rn);
        }
        status = solver.solve(vel, lam, the, bm, bg, bn);
    }
    if (status != Status.SOLVED) {
        throw new TestException("String_Node_Str" + status);
    }
    VectorNd bmCheck = new VectorNd(sizeM);
    VectorNd bgCheck = new VectorNd(numG);
    if (checkSolve(M, sizeM, GT, NT, vel, lam, the, bm, bmCheck) > 1e-8) {
        throw new TestException("String_Node_Str" + bm.toString("String_Node_Str") + "String_Node_Str" + bmCheck.toString("String_Node_Str"));
    }
    checkComplementarity(GT, NT, null, Rg, Rn, bg, bn, null, null, vel, lam, the, null);
}

Output:
     if (M instanceof SparseBlockMatrix) {
-        solver.analyze((SparseBlockMatrix) M, sizeM, GT, typeM);
+        solver.analyze((SparseBlockMatrix) M, sizeM, GT, Rg, typeM);
     } else {


Input:
public static void generateMakeFile(String classPath, String className, Collection requiredClasses) {
    StringBuffer code = new StringBuffer();
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str" + System.getProperty("String_Node_Str", "String_Node_Str") + "String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str" + className + "String_Node_Str");
    Iterator i = requiredClasses.iterator();
    code.append("String_Node_Str" + "String_Node_Str");
    while (i.hasNext()) {
        String name = _classNameToMakeFileName(((SootClass) i.next()).getName());
        code.append("String_Node_Str" + name + "String_Node_Str");
    }
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str" + InterfaceFileGenerator.interfaceFileNameSuffix() + "String_Node_Str");
    code.append(className + "String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str");
    code.append("String_Node_Str" + "String_Node_Str");
    FileHandler.write(className + "String_Node_Str", code.toString());
}

Output:
     code.append("String_Node_Str" + className + "String_Node_Str");
-    Iterator i = requiredClasses.iterator();
-    code.append("String_Node_Str" + "String_Node_Str");
+    code.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str");
+    Iterator i = RequiredFileGenerator.getRequiredClasses(classPath, className).iterator();
     while (i.hasNext()) {


Input:
public LoginResult<LoginInfo> login(User user, String tokenString) {
    LoginResult<LoginInfo> lr;
    if (tokenString != null) {
        Token token = new Token(tokenString);
        try {
            User u = loginService.checkToken(token);
            u.setUserId(-1);
            u.setPassWd(null);
            lr = new LoginResult<>(true, new LoginInfo(u, token));
        } catch (Exception e) {
            lr = new LoginResult<>(false, "String_Node_Str");
        }
    } else {
        try {
            System.out.print("String_Node_Str");
            if (user == null)
                return new LoginResult<>(false, "String_Node_Str");
            System.out.print("String_Node_Str");
            User u = loginService.checkLogin(user);
            System.out.print("String_Node_Str");
            System.out.print(u);
            if (u == null)
                return new LoginResult<>(false, "String_Node_Str");
            int userId = u.getUserId();
            Token t = new Token(jwtUtil.createToken(user));
            u.setUserId(-1);
            u.setPassWd(null);
            lr = new LoginResult<>(true, new LoginInfo(u, t));
        } catch (Exception e) {
            lr = new LoginResult<>(false, "String_Node_Str");
        }
    }
    return lr;
}

Output:
             int userId = u.getUserId();
-            Token t = new Token(jwtUtil.createToken(user));
+            Token t = new Token(jwtUtil.createToken(u));
+            loginService.insertToken(t, u);
             u.setUserId(-1);


Input:
public Connector getComponentConnector() {
    Set<? extends Connector> connectors = getParentNode().getComponentProperties().getPossibleConnectors(output);
    if (connectors != null) {
        for (Connector connector : connectors) {
            if (connector.getName().equals(genericConnectorType)) {
                return connector;
            }
        }
    }
    return null;
}

Output:
 public Connector getComponentConnector() {
-    Set<? extends Connector> connectors = getParentNode().getComponentProperties().getPossibleConnectors(output);
+    Set<? extends Connector> connectors = getComponentProperties().getPossibleConnectors(output);
     if (connectors != null) {


Input:
public void addNetworks(final NetworkAdd na) {
    if (CommonUtil.isBlank(na.getName()) || !CommonUtil.validateName(na.getName())) {
        throw BddException.INVALID_PARAMETER("String_Node_Str", na.getName());
    }
    if (CommonUtil.isBlank(na.getPortGroup()) || !CommonUtil.validateName(na.getPortGroup())) {
        throw BddException.INVALID_PARAMETER("String_Node_Str", na.getPortGroup());
    }
    if (na.isDhcp()) {
        networkManager.addDhcpNetwork(na.getName(), na.getPortGroup());
    } else {
        if (!IpAddressUtil.isValidNetmask(na.getNetmask())) {
            throw BddException.INVALID_PARAMETER("String_Node_Str", na.getNetmask());
        }
        long netmask = IpAddressUtil.getAddressAsLong(na.getNetmask());
        if (!IpAddressUtil.isValidIp(netmask, IpAddressUtil.getAddressAsLong(na.getGateway()))) {
            throw BddException.INVALID_PARAMETER("String_Node_Str", na.getGateway());
        }
        if (na.getDns1() != null && !IpAddressUtil.isValidIp(na.getDns1())) {
            throw BddException.INVALID_PARAMETER("String_Node_Str", na.getDns1());
        }
        if (na.getDns2() != null && !IpAddressUtil.isValidIp(na.getDns2())) {
            throw BddException.INVALID_PARAMETER("String_Node_Str", na.getDns2());
        }
        AuAssert.check(na.getIp() != null, "String_Node_Str");
        for (IpBlock blk : na.getIp()) {
            Long begin = IpAddressUtil.getAddressAsLong(blk.getBeginIp());
            Long end = IpAddressUtil.getAddressAsLong(blk.getEndIp());
            if (begin == null || end == null || begin > end || !IpAddressUtil.isValidIp(netmask, begin) || !IpAddressUtil.isValidIp(netmask, end)) {
                throw BddException.INVALID_PARAMETER("String_Node_Str", "String_Node_Str" + blk.getBeginIp() + "String_Node_Str" + blk.getEndIp() + "String_Node_Str");
            }
        }
        networkManager.addIpPoolNetwork(na.getName(), na.getPortGroup(), na.getNetmask(), na.getGateway(), na.getDns1(), na.getDns2(), na.getIp());
    }
}

Output:
     }
-    if (CommonUtil.isBlank(na.getPortGroup()) || !CommonUtil.validateName(na.getPortGroup())) {
+    if (CommonUtil.isBlank(na.getPortGroup()) || !CommonUtil.validatePortGroupName(na.getPortGroup())) {
         throw BddException.INVALID_PARAMETER("String_Node_Str", na.getPortGroup());


Input:
public void stepMethodInvoked(Method paramMethod, List<Object> arguments, InvocationMode mode) {
    if (!isStepMethod(paramMethod))
        return;
    addStepMethod(paramMethod, arguments, mode);
}

Output:
 public void stepMethodInvoked(Method paramMethod, List<Object> arguments, InvocationMode mode) {
-    if (!isStepMethod(paramMethod))
+    if (!isStepMethod(paramMethod)) {
         return;


Input:
public void explode() {
    boolean explode = true;
    for (Block block : GeneralMethods.getBlocksAroundPoint(location, 3)) {
        if (GeneralMethods.isRegionProtectedFromBuild(player, "String_Node_Str", block.getLocation())) {
            explode = false;
            break;
        }
    }
    if (explode) {
        explosion = player.getWorld().spawn(location, TNTPrimed.class);
        explosion.setFuseTicks(0);
        float yield = (float) power;
        if (!AvatarState.isAvatarState(player)) {
            if (FireMethods.isDay(player.getWorld())) {
                FireMethods.getFirebendingDayAugment(yield, player.getWorld());
            } else {
                yield *= 1.;
            }
        } else {
            yield *= AvatarState.factor;
        }
        explosion.setYield(yield);
        explosions.put(explosion, this);
    }
    ignite(location);
    remove();
}

Output:
     if (explode) {
-        explosion = player.getWorld().spawn(location, TNTPrimed.class);
-        explosion.setFuseTicks(0);
-        float yield = (float) power;
-        if (!AvatarState.isAvatarState(player)) {
-            if (FireMethods.isDay(player.getWorld())) {
-                FireMethods.getFirebendingDayAugment(yield, player.getWorld());
+        if (damage_blocks && explosionradius > 0) {
+            explosion = player.getWorld().spawn(location, TNTPrimed.class);
+            explosion.setFuseTicks(0);
+            float yield = (float) explosionradius;
+            if (!AvatarState.isAvatarState(player)) {
+                if (FireMethods.isDay(player.getWorld())) {
+                    yield = (float) FireMethods.getFirebendingDayAugment(yield, player.getWorld());
+                }
             } else {


Input:
public static List<FoodListing> findFoodListings(Float longitude, Float latitude, Float distance) {
    List<FoodListing> result = new ArrayList<FoodListing>();
    Query q = new Query("String_Node_Str");
    q.addFilter(FoodListing.LAT_KEY, Query.FilterOperator.GREATER_THAN_OR_EQUAL, latitude - distance);
    q.addFilter(FoodListing.LAT_KEY, Query.FilterOperator.LESS_THAN_OR_EQUAL, latitude + distance);
    DatastoreService data = DatastoreServiceFactory.getDatastoreService();
    PreparedQuery prepQ = data.prepare(q);
    for (Entity found : prepQ.asIterable()) {
        FoodListing resultItem = new FoodListing(found);
        if (resultItem.getLongitude() >= (longitude - distance) && resultItem.getLongitude() <= (longitude + distance)) {
            result.add(resultItem);
        }
    }
    return result;
}

Output:
         FoodListing resultItem = new FoodListing(found);
-        if (resultItem.getLongitude() >= (longitude - distance) && resultItem.getLongitude() <= (longitude + distance)) {
+        if (!resultItem.expired() && resultItem.getLongitude() >= (longitude - distance) && resultItem.getLongitude() <= (longitude + distance)) {
             result.add(resultItem);


Input:
private void createCameraView() {
    cameraView = new CameraView(subScene);
    cameraView.setFitWidth(250);
    cameraView.setFitHeight(200);
    cameraView.setFirstPersonNavigationEabled(true);
    cameraView.setFocusTraversable(true);
    cameraView.getCamera().setTranslateZ(-2500);
    cameraView.getCamera().setTranslateX(500);
    StackPane.setAlignment(cameraView, Pos.BOTTOM_RIGHT);
    StackPane.setMargin(cameraView, new Insets(10));
    mainPane.getChildren().add(cameraView);
    cameraView.startViewing();
}

Output:
     StackPane.setAlignment(cameraView, Pos.BOTTOM_RIGHT);
-    StackPane.setMargin(cameraView, new Insets(10));
+    StackPane.setMargin(cameraView, new Insets(20));
     mainPane.getChildren().add(cameraView);


Input:
public DecodeQualification getDecodeQualification(Object input) {
    DecodeQualification qualification = DecodeQualification.UNABLE;
    File file = new File(input.toString());
    String fileName = file.getName().toLowerCase();
    if (fileName.endsWith("String_Node_Str")) {
        qualification = DecodeQualification.SUITABLE;
    } else if (fileName.endsWith(RapidEyeConstants.METADATA_FILE_SUFFIX)) {
        File folder = file.getParentFile();
        File[] files = folder.listFiles();
        if (files != null) {
            boolean consistentProduct = true;
            for (String namePattern : RapidEyeConstants.L3_FILENAME_PATTERNS) {
                if (!namePattern.endsWith("String_Node_Str")) {
                    boolean patternMatched = false;
                    for (File f : files) {
                        patternMatched |= f.getName().matches(namePattern);
                    }
                    consistentProduct &= patternMatched;
                }
            }
            if (consistentProduct)
                qualification = DecodeQualification.INTENDED;
        }
    }
    return qualification;
}

Output:
     if (fileName.endsWith("String_Node_Str")) {
-        qualification = DecodeQualification.SUITABLE;
+        try {
+            files = RapidEyeReader.getInput(input).list("String_Node_Str");
+        } catch (IOException e) {
+        }
     } else if (fileName.endsWith(RapidEyeConstants.METADATA_FILE_SUFFIX)) {


Input:
public void initialise() {
    WorldGeneratorInfo info = worldGeneratorManager.getWorldGeneratorInfo(config.getWorldGeneration().getDefaultGenerator());
    try {
        WorldGenerator worldGenerator = worldGeneratorManager.createGenerator(info.getUri());
        seedBinding.setWorldGenerator(worldGenerator);
        if (worldGenerator instanceof WorldGenerator2DPreview) {
            previewGenerator = (WorldGenerator2DPreview) worldGenerator;
        } else {
            logger.info(info.getUri().toString() + "String_Node_Str");
        }
    } catch (UnresolvedWorldGeneratorException e) {
        logger.error("String_Node_Str" + info.getUri().toString() + "String_Node_Str");
    }
    zoomSlider = find("String_Node_Str", UISlider.class);
    if (zoomSlider != null) {
        zoomSlider.setMinimum(1.0f);
        zoomSlider.setRange(99.f);
        zoomSlider.setIncrement(1.0f);
        zoomSlider.setValue(10f);
        zoomSlider.setPrecision(0);
    }
    UIText seed = find("String_Node_Str", UIText.class);
    if (seed != null) {
        seed.bindText(seedBinding);
    }
    if (previewGenerator != null) {
        layerDropdown = find("String_Node_Str", UIDropdown.class);
        layerDropdown.setOptions(Lists.newArrayList(previewGenerator.getLayers()));
        if (!layerDropdown.getOptions().isEmpty()) {
            layerDropdown.setSelection(layerDropdown.getOptions().get(0));
        }
    }
    WidgetUtil.trySubscribe(this, "String_Node_Str", new ActivateEventListener() {
        public void onActivated(UIWidget button) {
            getManager().popScreen();
        }
    });
}

Output:
     }
-    if (previewGenerator != null) {
-        layerDropdown = find("String_Node_Str", UIDropdown.class);
-        layerDropdown.setOptions(Lists.newArrayList(previewGenerator.getLayers()));
-        if (!layerDropdown.getOptions().isEmpty()) {
-            layerDropdown.setSelection(layerDropdown.getOptions().get(0));
+    layerDropdown = find("String_Node_Str", UIDropdown.class);
+    layerDropdown.bindOptions(new ReadOnlyBinding<List<String>>() {
+        public List<String> get() {
+            if (previewGenerator != null) {
+                return Lists.newArrayList(previewGenerator.getLayers());
+            } else {
+                return Lists.newArrayList();
+            }
         }


Input:
public int[] process(String line, HashMap<String, Integer> map) {
    int[] ret = new int[3];
    int numWords = 0;
    int sixltr = 0;
    int numerals = 0;
    Matcher matcher = pattern.matcher(line);
    if (doLower)
        line = line.toLowerCase();
    if (phraseDetect) {
        for (String key : phraseLookup.keySet()) {
            Pattern p, justp;
            if (key.endsWith("String_Node_Str")) {
                p = Pattern.compile("String_Node_Str" + key + "String_Node_Str");
                justp = Pattern.compile(key + "String_Node_Str");
                key = key.substring(0, key.length() - 1);
            } else {
                p = Pattern.compile("String_Node_Str" + key + "String_Node_Str");
                justp = Pattern.compile(key + "String_Node_Str");
            }
            int wordsInPhrase = key.split("String_Node_Str").length;
            Matcher m = p.matcher(line);
            ArrayList<Integer> indexes = new ArrayList<Integer>();
            while (m.find()) {
                String match = m.group();
                indexes.add(m.start() + 1);
                indexes.add(m.end());
                numWords = numWords + wordsInPhrase;
                sixltr = sixltr + bigWords(match);
                Object value = map.get(key);
                if (value != null) {
                    int i = ((Integer) value).intValue();
                    map.put(key, i + wordsInPhrase);
                } else {
                    map.put(key, wordsInPhrase);
                }
            }
            for (int i = 0; i < indexes.size(); i = i + 2) {
                line = line.substring(0, indexes.get(i)) + line.substring(indexes.get(i + 1));
                int diff = indexes.get(i + 1) - indexes.get(i);
                for (int j = 0; j < indexes.size(); j++) indexes.set(j, indexes.get(j) - diff);
            }
            indexes.clear();
            Matcher m2 = justp.matcher(line);
            while (m2.find()) {
                String match = m2.group();
                indexes.add(m2.start());
                indexes.add(m2.end());
                numWords = numWords + wordsInPhrase;
                sixltr = sixltr + bigWords(match);
                Object value = map.get(key);
                if (value != null) {
                    int i = ((Integer) value).intValue();
                    map.put(key, i + wordsInPhrase);
                } else {
                    map.put(key, wordsInPhrase);
                }
            }
            for (int i = 0; i < indexes.size(); i = i + 2) {
                line = line.substring(0, indexes.get(i)) + line.substring(indexes.get(i + 1));
                int diff = indexes.get(i + 1) - indexes.get(i);
                for (int j = 0; j < indexes.size(); j++) indexes.set(j, indexes.get(j) - diff);
            }
        }
    }
    StringTokenizer st = new StringTokenizer(line, delimiters);
    String currentWord = null;
    if (st.hasMoreTokens())
        currentWord = trimChars(st.nextToken(), punctuations);
    do {
        String nextWord = null;
        if (st.hasMoreTokens())
            nextWord = trimChars(st.nextToken(), punctuations);
        if (currentWord == null || currentWord.equals("String_Node_Str")) {
            currentWord = nextWord;
            continue;
        }
        matcher = pattern.matcher(currentWord);
        while (matcher.find()) {
            numerals++;
        }
        if (doSnowballStemming) {
            stemmer.setCurrent(currentWord);
            String stemmedWord = "String_Node_Str";
            if (stemmer.stem())
                stemmedWord = stemmer.getCurrent();
            if (!stemmedWord.equals("String_Node_Str"))
                currentWord = stemmedWord;
        }
        if (doStopWords)
            if (stopWordSet.contains(currentWord))
                continue;
        Matcher word = regularPattern.matcher(currentWord);
        if (word.find()) {
            numWords = numWords + 1;
            if (currentWord.length() > 6) {
                sixltr = sixltr + 1;
            }
        }
        boolean treatAsOne = true;
        Matcher dh = doubleHyphenPattern.matcher(currentWord);
        if (dh.find()) {
            currentWord = currentWord.replace("String_Node_Str", "String_Node_Str").toLowerCase();
            if (categorizer.query(currentWord) != null && !categorizer.checkHyphen(currentWord)) {
                Object value = map.get(currentWord);
                if (value != null) {
                    int i = ((Integer) value).intValue();
                    map.put(currentWord, i + 1);
                } else {
                    map.put(currentWord, 1);
                }
                String[] words = currentWord.split("String_Node_Str");
                int hyphened = 0;
                for (String s : words) {
                    hyphened++;
                }
                weirdDashCount = weirdDashCount + hyphened;
            } else {
                String[] words = currentWord.split("String_Node_Str");
                int hyphened = -1;
                for (String s : words) {
                    hyphened++;
                }
                if (categorizer.query(currentWord) != null) {
                    Object value = map.get(currentWord);
                    if (value != null) {
                        int i = ((Integer) value).intValue();
                        map.put(words[0], i + 1);
                    } else {
                        map.put(words[0], 1);
                    }
                    numWords = numWords + hyphened;
                    treatAsOne = true;
                } else {
                    numWords = numWords + hyphened;
                    if (categorizer.query(words[0]) != null) {
                        Object value = map.get(words[0]);
                        if (value != null) {
                            int i = ((Integer) value).intValue();
                            map.put(words[0], i + 1);
                        } else {
                            map.put(words[0], 1);
                        }
                    }
                    treatAsOne = false;
                }
                if (treatAsOne)
                    weirdDashCount++;
                else
                    weirdDashCount = weirdDashCount + hyphened;
            }
        } else {
            Matcher cm = compoundPattern.matcher(currentWord);
            if (cm.find()) {
                String[] words = currentWord.split("String_Node_Str");
                int hyphened = -1;
                for (String s : words) {
                    if (s == null || s.equals("String_Node_Str"))
                        continue;
                    hyphened++;
                }
                if (categorizer.query(currentWord.toLowerCase()) == null) {
                    numWords = numWords + hyphened;
                    treatAsOne = false;
                } else
                    weirdDashCount = weirdDashCount + 1;
            }
            if (treatAsOne) {
                Object value = map.get(currentWord);
                if (value != null) {
                    int i = ((Integer) value).intValue();
                    map.put(currentWord, i + 1);
                } else {
                    map.put(currentWord, 1);
                }
            } else {
                String[] parts = currentWord.split("String_Node_Str");
                for (String part : parts) {
                    if (part == null || part.equals("String_Node_Str"))
                        continue;
                    Object value = map.get(part);
                    if (value != null) {
                        int i = ((Integer) value).intValue();
                        map.put(part, i + 1);
                    } else {
                        map.put(part, 1);
                    }
                }
            }
        }
        currentWord = nextWord;
    } while (st.hasMoreTokens() || null != currentWord);
    ret[0] = numWords;
    ret[1] = sixltr;
    ret[2] = numerals;
    return ret;
}

Output:
         if (dh.find()) {
-            currentWord = currentWord.replace("String_Node_Str", "String_Node_Str").toLowerCase();
+            currentWord = currentWord.replaceFirst("String_Node_Str", "String_Node_Str").toLowerCase();
             if (categorizer.query(currentWord) != null && !categorizer.checkHyphen(currentWord)) {


Input:
private String[] handleEOF() {
    String[] row = null;
    try {
        boolean consumeValueOnEOF = consumeValueOnEOF();
        if (output.column != 0 || consumeValueOnEOF) {
            if (output.appender.length() > 0 || consumeValueOnEOF) {
                output.valueParsed();
            } else {
                output.emptyParsed();
            }
            row = output.rowParsed();
        } else if (output.appender.length() > 0) {
            output.valueParsed();
            row = output.rowParsed();
        }
    } catch (ArrayIndexOutOfBoundsException e) {
        throw handleException(e);
    }
    if (row != null && processor != NoopProcessor.instance) {
        rowProcessed(row);
    }
    return row;
}

Output:
         }
-    } catch (ArrayIndexOutOfBoundsException e) {
+    } catch (Throwable e) {
         throw handleException(e);


Input:
final void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges) {
    ActivityRecord top = topRunningActivityLocked(null);
    if (top == null) {
        return;
    }
    if (DEBUG_VISIBILITY)
        Slog.v(TAG_VISIBILITY, "String_Node_Str" + top + "String_Node_Str" + Integer.toHexString(configChanges));
    if (mTranslucentActivityWaiting != top) {
        mUndrawnActivitiesBelowTopTranslucent.clear();
        if (mTranslucentActivityWaiting != null) {
            notifyActivityDrawnLocked(null);
            mTranslucentActivityWaiting = null;
        }
        mHandler.removeMessages(TRANSLUCENT_TIMEOUT_MSG);
    }
    boolean aboveTop = true;
    boolean behindFullscreen = !isStackVisibleLocked();
    boolean noStackActivityResumed = (isInStackLocked(starting) == null);
    for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
        final TaskRecord task = mTaskHistory.get(taskNdx);
        final ArrayList<ActivityRecord> activities = task.mActivities;
        boolean behindFullscreenActivity = behindFullscreen;
        for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
            final ActivityRecord r = activities.get(activityNdx);
            if (r.finishing) {
                continue;
            }
            if (aboveTop && r != top) {
                continue;
            }
            aboveTop = false;
            if (!behindFullscreenActivity || r.mLaunchTaskBehind) {
                if (DEBUG_VISIBILITY)
                    Slog.v(TAG_VISIBILITY, "String_Node_Str" + r + "String_Node_Str" + r.finishing + "String_Node_Str" + r.state);
                if (r != starting) {
                    ensureActivityConfigurationLocked(r, 0);
                }
                if (r.app == null || r.app.thread == null) {
                    if (DEBUG_VISIBILITY)
                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                    if (r != starting) {
                        r.startFreezingScreenLocked(r.app, configChanges);
                    }
                    if (!r.visible || r.mLaunchTaskBehind) {
                        if (DEBUG_VISIBILITY)
                            Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                        setVisible(r, true);
                    }
                    if (r != starting) {
                        mStackSupervisor.startSpecificActivityLocked(r, noStackActivityResumed, false);
                        if (activityNdx >= activities.size()) {
                            activityNdx = activities.size() - 1;
                        } else {
                            noStackActivityResumed = false;
                        }
                    }
                } else if (r.visible) {
                    if (DEBUG_VISIBILITY)
                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                    r.stopFreezingScreenLocked(false);
                    try {
                        if (r.returningOptions != null) {
                            r.app.thread.scheduleOnNewActivityOptions(r.appToken, r.returningOptions);
                        }
                    } catch (RemoteException e) {
                    }
                    if (r.state == ActivityState.RESUMED) {
                        noStackActivityResumed = false;
                    }
                } else {
                    r.visible = true;
                    if (r.state != ActivityState.RESUMED && r != starting) {
                        if (DEBUG_VISIBILITY)
                            Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                        try {
                            if (mTranslucentActivityWaiting != null) {
                                r.updateOptionsLocked(r.returningOptions);
                                mUndrawnActivitiesBelowTopTranslucent.add(r);
                            }
                            setVisible(r, true);
                            r.sleeping = false;
                            r.app.pendingUiClean = true;
                            r.app.thread.scheduleWindowVisibility(r.appToken, true);
                            r.stopFreezingScreenLocked(false);
                        } catch (Exception e) {
                            Slog.w(TAG, "String_Node_Str" + r.intent.getComponent(), e);
                        }
                    }
                }
                configChanges |= r.configChangeFlags;
                if (r.fullscreen) {
                    behindFullscreenActivity = true;
                    if (DEBUG_VISIBILITY)
                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r + "String_Node_Str" + behindFullscreen + "String_Node_Str" + behindFullscreenActivity);
                } else if (!isHomeStack() && r.frontOfTask && task.isOverHomeStack()) {
                    behindFullscreenActivity = true;
                    if (DEBUG_VISIBILITY)
                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r + "String_Node_Str" + behindFullscreen + "String_Node_Str" + behindFullscreenActivity);
                }
            } else {
                if (DEBUG_VISIBILITY)
                    Slog.v(TAG_VISIBILITY, "String_Node_Str" + r + "String_Node_Str" + r.finishing + "String_Node_Str" + r.state + "String_Node_Str" + behindFullscreen + "String_Node_Str" + behindFullscreenActivity);
                if (r.visible) {
                    if (DEBUG_VISIBILITY)
                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                    try {
                        setVisible(r, false);
                        switch(r.state) {
                            case STOPPING:
                            case STOPPED:
                                if (r.app != null && r.app.thread != null) {
                                    if (DEBUG_VISIBILITY)
                                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                                    r.app.thread.scheduleWindowVisibility(r.appToken, false);
                                }
                                break;
                            case INITIALIZING:
                            case RESUMED:
                            case PAUSING:
                            case PAUSED:
                                if (getVisibleBehindActivity() == r) {
                                    releaseBackgroundResources(r);
                                } else {
                                    if (!mStackSupervisor.mStoppingActivities.contains(r)) {
                                        mStackSupervisor.mStoppingActivities.add(r);
                                    }
                                    mStackSupervisor.scheduleIdleLocked();
                                }
                                break;
                            default:
                                break;
                        }
                    } catch (Exception e) {
                        Slog.w(TAG, "String_Node_Str" + r.intent.getComponent(), e);
                    }
                } else {
                    if (DEBUG_VISIBILITY)
                        Slog.v(TAG_VISIBILITY, "String_Node_Str" + r);
                }
            }
        }
        behindFullscreen |= task.mFullscreen;
    }
    if (mTranslucentActivityWaiting != null && mUndrawnActivitiesBelowTopTranslucent.isEmpty()) {
        notifyActivityDrawnLocked(null);
    }
}

Output:
     boolean aboveTop = true;
-    boolean behindFullscreen = !isStackVisibleLocked();
+    final boolean stackInvisible = !isStackVisibleLocked();
+    boolean behindFullscreenActivity = stackInvisible;
     boolean noStackActivityResumed = (isInStackLocked(starting) == null);


Input:
static public String getID(String username) {
    Iterator<String> keys = activeUsersID.keySet().iterator();
    String key;
    while (keys.hasNext()) {
        key = activeUsersID.get(keys.next());
        if (key.equals(username)) {
            return key;
        }
    }
    return null;
}

Output:
     Iterator<String> keys = activeUsersID.keySet().iterator();
-    String key;
+    String key = null;
+    String temp_username;
     while (keys.hasNext()) {


Input:
public DesiredCapabilities getCapabilities(DesiredCapabilities capabilities) {
    MobileTestSession mobileSession = Grid.getMobileTestSession();
    capabilities = SelendroidCapabilities.android();
    if ((new File(mobileSession.getAppLocation()).exists()) && ((new File(mobileSession.getAppLocation() + File.separator + mobileSession.getAppName())).exists())) {
        capabilities.setBrowserName(SELENDROID);
    } else {
        capabilities.setBrowserName(ANDROID);
    }
    capabilities.setCapability(MOBILE_NODE_TYPE, mobileSession.getMobileNodeType().getAsString());
    capabilities.setCapability(SelendroidCapabilities.AUT, mobileSession.getAppName());
    capabilities.setCapability(SelendroidCapabilities.LOCALE, mobileSession.getAppLocale());
    if (StringUtils.isNotBlank(mobileSession.getDeviceType())) {
        capabilities.setCapability(SelendroidCapabilities.MODEL, mobileSession.getDeviceType());
    }
    if (StringUtils.isNotBlank(mobileSession.getPlatformVersion())) {
        capabilities.setCapability(SelendroidCapabilities.PLATFORM_VERSION, mobileSession.getPlatformVersion());
    }
    if (StringUtils.isNotBlank(mobileSession.getdeviceSerial())) {
        capabilities.setCapability(SelendroidCapabilities.SERIAL, mobileSession.getdeviceSerial());
    }
    return capabilities;
}

Output:
     MobileTestSession mobileSession = Grid.getMobileTestSession();
-    capabilities = SelendroidCapabilities.android();
+    DesiredCapabilities tempCapabilities = SelendroidCapabilities.android();
     if ((new File(mobileSession.getAppLocation()).exists()) && ((new File(mobileSession.getAppLocation() + File.separator + mobileSession.getAppName())).exists())) {


Input:
public void deleteController(DeleteOpenDaylightControllerCmd cmd) throws InvalidParameterValueException {
    OpenDaylightControllerVO controller = openDaylightControllerMappingDao.findById(cmd.getId());
    if (controller == null) {
        throw new InvalidParameterValueException("String_Node_Str" + cmd.getId());
    }
    Long physicalNetworkId = controller.getPhysicalNetworkId();
    PhysicalNetworkVO physicalNetwork = physicalNetworkDao.findById(physicalNetworkId);
    if (physicalNetwork != null) {
        List<NetworkVO> networkList = networkDao.listByPhysicalNetwork(physicalNetworkId);
        for (NetworkVO network : networkList) {
            if (network.getBroadcastDomainType() == Networks.BroadcastDomainType.OpenDaylight) {
                if ((network.getState() != Network.State.Shutdown) && (network.getState() != Network.State.Destroy)) {
                    throw new CloudRuntimeException("String_Node_Str");
                }
            }
        }
    }
    HostVO host = hostDao.findById(controller.getHostId());
    Long hostId = host.getId();
    host.setResourceState(ResourceState.Maintenance);
    hostDao.update(hostId, host);
    resourceManager.deleteHost(hostId, false, false);
    openDaylightControllerMappingDao.remove(cmd.getId());
}

Output:
         List<NetworkVO> networkList = networkDao.listByPhysicalNetwork(physicalNetworkId);
-        for (NetworkVO network : networkList) {
-            if (network.getBroadcastDomainType() == Networks.BroadcastDomainType.OpenDaylight) {
-                if ((network.getState() != Network.State.Shutdown) && (network.getState() != Network.State.Destroy)) {
-                    throw new CloudRuntimeException("String_Node_Str");
+        if (networkList != null) {
+            for (NetworkVO network : networkList) {
+                if (network.getBroadcastDomainType() == Networks.BroadcastDomainType.OpenDaylight) {
+                    if ((network.getState() != Network.State.Shutdown) && (network.getState() != Network.State.Destroy)) {
+                        throw new CloudRuntimeException("String_Node_Str");
+                    }
                 }


Input:
protected void setValue(Object element, Object value) {
    if (element instanceof Parameter) {
        String key = ((Parameter) element).getPropertyKey();
        if (columnID == 1) {
            String oldType = ((Parameter) element).getType().toString();
            String newType = (String) value;
            if (newType != null && newType.length() > 0 && !newType.equalsIgnoreCase(oldType)) {
                ((Parameter) element).setType(Parameter.Type.fromValue(newType));
                parameterMap.put(key, element);
                propertiesViewer.refresh();
            }
        } else if (columnID == 2) {
            String oldDefaultValue = ((Parameter) element).getDefaultValue();
            String newDefaultValue = (String) value;
            if (newDefaultValue != null && newDefaultValue.length() > 0 && !newDefaultValue.equalsIgnoreCase(oldDefaultValue)) {
                ((Parameter) element).setDefaultValue(newDefaultValue);
                parameterMap.put(key, element);
                propertiesViewer.refresh();
            }
        }
    }
}

Output:
                 parameterMap.put(key, element);
-                propertiesViewer.refresh();
+                propertiesViewer.refresh(element);
             }


Input:
public void afterProcess(Page page) {
    content = null;
}

Output:
 public void afterProcess(Page page) {
-    content = null;
+    System.out.println("String_Node_Str" + title);
+    System.out.println("String_Node_Str" + content);
+    System.out.println("String_Node_Str" + tags);
 }


Input:
private static GenericTopLevel parseGenericTopLevel(SBOLDocument SBOLDoc, IdentifiableDocument<QName> topLevel) throws SBOLValidationException {
    String displayId = null;
    String name = null;
    String description = null;
    URI persistentIdentity = null;
    String version = null;
    Set<URI> wasDerivedFroms = new HashSet<>();
    QName type = topLevel.getType();
    List<Annotation> annotations = new ArrayList<>();
    for (NamedProperty<QName> namedProperty : topLevel.getProperties()) {
        if (namedProperty.getName().equals(Sbol2Terms.Description.type)) {
            String typeStr = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
            String nameSpace = URIcompliance.extractNamespace(URI.create(typeStr));
            String localPart = URIcompliance.extractDisplayId(URI.create(typeStr));
            String prefix = null;
            if (nameSpace == null) {
                if (typeStr.lastIndexOf('/') > typeStr.lastIndexOf('#')) {
                    if (typeStr.lastIndexOf('/') > typeStr.lastIndexOf(':')) {
                        nameSpace = typeStr.substring(0, typeStr.lastIndexOf('/'));
                        localPart = typeStr.substring(typeStr.lastIndexOf('/') + 1);
                    } else {
                        nameSpace = typeStr.substring(0, typeStr.lastIndexOf(':'));
                        localPart = typeStr.substring(typeStr.lastIndexOf(':') + 1);
                    }
                } else if (typeStr.lastIndexOf('#') > typeStr.lastIndexOf(':')) {
                    nameSpace = typeStr.substring(0, typeStr.lastIndexOf('#'));
                    localPart = typeStr.substring(typeStr.lastIndexOf('#') + 1);
                } else {
                    nameSpace = typeStr.substring(0, typeStr.lastIndexOf(':'));
                    localPart = typeStr.substring(typeStr.lastIndexOf(':') + 1);
                }
                prefix = SBOLDoc.getNamespacePrefix(URI.create(nameSpace));
                if (prefix == null) {
                    prefix = "String_Node_Str";
                    int prefixCnt = 0;
                    while (SBOLDoc.getNamespace(prefix) != null) {
                        prefixCnt++;
                        prefix = "String_Node_Str" + prefixCnt;
                    }
                    SBOLDoc.addNamespace(new QName(nameSpace, localPart, prefix));
                }
            } else {
                prefix = SBOLDoc.getNamespacePrefix(URI.create(nameSpace));
            }
            type = new QName(nameSpace, localPart, prefix);
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.persistentIdentity)) {
            if (!(namedProperty.getValue() instanceof Literal) || persistentIdentity != null || (!(((Literal<QName>) namedProperty.getValue()).getValue() instanceof URI))) {
                throw new SBOLValidationException("String_Node_Str", topLevel.getIdentity());
            }
            persistentIdentity = URI.create(((Literal<QName>) namedProperty.getValue()).getValue().toString());
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.version)) {
            if (!(namedProperty.getValue() instanceof Literal) || version != null || (!(((Literal<QName>) namedProperty.getValue()).getValue() instanceof String))) {
                throw new SBOLValidationException("String_Node_Str", topLevel.getIdentity());
            }
            version = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.displayId)) {
            if (!(namedProperty.getValue() instanceof Literal) || displayId != null || (!(((Literal<QName>) namedProperty.getValue()).getValue() instanceof String))) {
                throw new SBOLValidationException("String_Node_Str", topLevel.getIdentity());
            }
            displayId = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.title)) {
            if (!(namedProperty.getValue() instanceof Literal) || name != null || (!(((Literal<QName>) namedProperty.getValue()).getValue() instanceof String))) {
                throw new SBOLValidationException("String_Node_Str", topLevel.getIdentity());
            }
            name = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.description)) {
            if (!(namedProperty.getValue() instanceof Literal) || description != null || (!(((Literal<QName>) namedProperty.getValue()).getValue() instanceof String))) {
                throw new SBOLValidationException("String_Node_Str", topLevel.getIdentity());
            }
            description = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.wasDerivedFrom)) {
            if (!(namedProperty.getValue() instanceof Literal) || (!(((Literal<QName>) namedProperty.getValue()).getValue() instanceof URI))) {
                throw new SBOLValidationException("String_Node_Str", topLevel.getIdentity());
            }
            wasDerivedFroms.add(URI.create(((Literal<QName>) namedProperty.getValue()).getValue().toString()));
        } else {
            annotations.add(new Annotation(namedProperty));
        }
    }
    GenericTopLevel t = new GenericTopLevel(topLevel.getIdentity(), type);
    if (persistentIdentity != null)
        t.setPersistentIdentity(persistentIdentity);
    if (version != null)
        t.setVersion(version);
    if (displayId != null)
        t.setDisplayId(displayId);
    if (name != null)
        t.setName(name);
    if (description != null)
        t.setDescription(description);
    t.setWasDerivedFroms(wasDerivedFroms);
    if (!annotations.isEmpty())
        t.setAnnotations(annotations);
    GenericTopLevel oldG = SBOLDoc.getGenericTopLevel(topLevel.getIdentity());
    if (oldG == null) {
        SBOLDoc.addGenericTopLevel(t);
    } else {
        if (!t.equals(oldG)) {
            throw new SBOLValidationException("String_Node_Str", t);
        }
    }
    return t;
}

Output:
                     if (typeStr.lastIndexOf('/') > typeStr.lastIndexOf(':')) {
-                        nameSpace = typeStr.substring(0, typeStr.lastIndexOf('/'));
+                        nameSpace = typeStr.substring(0, typeStr.lastIndexOf('/') + 1);
                         localPart = typeStr.substring(typeStr.lastIndexOf('/') + 1);


Input:
public void insert(Widget w, int beforeIndex) {
    Element trh = DOM.createTR();
    Element tdh = DOM.createTD();
    DOM.appendChild(trh, tdh);
    Element trb = DOM.createTR();
    Element tdb = DOM.createTD();
    DOM.appendChild(trb, tdb);
    beforeIndex = super.insert(w, tdb, beforeIndex);
    int effectiveIndex = beforeIndex * 2;
    DOM.insertChild(body, trb, effectiveIndex);
    DOM.insertChild(body, trh, effectiveIndex);
    setStyleName(tdh, "String_Node_Str", true);
    DOM.setElementPropertyInt(tdh, "String_Node_Str", hashCode());
    DOM.setElementProperty(tdh, "String_Node_Str", "String_Node_Str");
    DOM.setElementProperty(tdb, "String_Node_Str", "String_Node_Str");
    DOM.setElementProperty(tdb, "String_Node_Str", "String_Node_Str");
    updateIndicesFrom(beforeIndex);
    if (visibleStack == -1) {
        showStack(0);
    } else {
        setStackVisible(beforeIndex, false);
        if (visibleStack >= beforeIndex) {
            ++visibleStack;
        }
    }
}

Output:
     DOM.appendChild(trb, tdb);
-    beforeIndex = super.insert(w, tdb, beforeIndex);
+    beforeIndex = adjustIndex(w, beforeIndex);
     int effectiveIndex = beforeIndex * 2;


Input:
private void setQueryExpression(String expression, boolean isSharing) {
    if (ChartUIConstants.QUERY_VALUE.equals(queryType)) {
        if (!(context.getChartType() instanceof GanttChart) && !context.getDataServiceProvider().checkState(IDataServiceProvider.SHARE_QUERY) && context.getDataServiceProvider().checkState(IDataServiceProvider.HAS_DATA_SET)) {
            if (context.getDataServiceProvider().getDataType(expression) == DataType.DATE_TIME_LITERAL) {
                ChartAdapter.beginIgnoreNotifications();
                if (query.getGrouping() == null) {
                    query.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
                }
                SeriesGrouping group = query.getGrouping();
                group.setEnabled(true);
                group.setAggregateExpression("String_Node_Str");
                ChartAdapter.endIgnoreNotifications();
            }
        }
    } else if (ChartUIConstants.QUERY_CATEGORY.equals(queryType)) {
        DataType type = context.getDataServiceProvider().getDataType(expression);
        ChartAdapter.beginIgnoreNotifications();
        if (seriesdefinition.getGrouping() == null) {
            seriesdefinition.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
        }
        seriesdefinition.getGrouping().setGroupType(type);
        if (type == DataType.DATE_TIME_LITERAL) {
            seriesdefinition.getGrouping().setGroupingUnit(GroupingUnitType.YEARS_LITERAL);
        }
        ChartAdapter.endIgnoreNotifications();
    } else if (ChartUIConstants.QUERY_OPTIONAL.equals(queryType)) {
        if (seriesdefinition.getSortKey() != null && seriesdefinition.getSortKey().getDefinition() != null && seriesdefinition.getSortKey().getDefinition().equals(query.getDefinition())) {
            ChartAdapter.beginIgnoreNotifications();
            seriesdefinition.getSortKey().setDefinition(expression);
            ChartAdapter.endIgnoreNotifications();
        }
        DataType type = context.getDataServiceProvider().getDataType(expression);
        ChartAdapter.beginIgnoreNotifications();
        if (query.getGrouping() == null) {
            query.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
        }
        query.getGrouping().setGroupType(type);
        if (type == DataType.DATE_TIME_LITERAL) {
            query.getGrouping().setGroupingUnit(GroupingUnitType.YEARS_LITERAL);
        }
        ChartAdapter.endIgnoreNotifications();
    }
    if (query != null) {
        if (isSharing) {
            query.setDefinition(expression);
        } else {
            query.setDefinition(btnBuilder.getExpression());
        }
    } else {
        query = QueryImpl.create(expression);
        query.eAdapters().addAll(seriesdefinition.eAdapters());
        seriesdefinition.setQuery(query);
    }
}

Output:
         ChartAdapter.beginIgnoreNotifications();
-        if (query.getGrouping() == null) {
-            query.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
-        }
-        query.getGrouping().setGroupType(type);
-        if (type == DataType.DATE_TIME_LITERAL) {
-            query.getGrouping().setGroupingUnit(GroupingUnitType.YEARS_LITERAL);
+        if (expression == null || expression.trim().length() == 0) {
+            seriesdefinition.eUnset(DataPackage.eINSTANCE.getSeriesDefinition_Sorting());
+            seriesdefinition.getSortKey().setDefinition(null);
+        } else {
+            if (seriesdefinition.getSortKey() != null && seriesdefinition.getSortKey().getDefinition() != null && seriesdefinition.getSortKey().getDefinition().equals(query.getDefinition())) {
+                seriesdefinition.getSortKey().setDefinition(expression);
+            }
+            DataType type = context.getDataServiceProvider().getDataType(expression);
+            if (query.getGrouping() == null) {
+                query.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
+            }
+            query.getGrouping().setGroupType(type);
+            if (type == DataType.DATE_TIME_LITERAL) {
+                query.getGrouping().setGroupingUnit(GroupingUnitType.YEARS_LITERAL);
+            }
         }


Input:
private static boolean hasTransaction(final Object obj) {
    final String ctx = lookatPersistenceContext(obj);
    return txStateThreadLocal.get().containsKey(ctx);
}

Output:
     final String ctx = lookatPersistenceContext(obj);
-    return txStateThreadLocal.get().containsKey(ctx);
+    CascadingTx tx = txStateThreadLocal.get().get(ctx);
+    if (tx == null) {
+        return false;
+    } else if (tx.isActive()) {
+        return true;
+    } else {
+        txStateThreadLocal.get().remove(ctx);
+        return false;
+    }
 }


Input:
protected void onSecurityTokenPostExecute() {
    long tokenId = KeyFormattingUtils.getKeyIdFromFingerprint(mSecurityTokenFingerprints);
    try {
        CachedPublicKeyRing ring = mKeyRepository.getCachedPublicKeyRing(KeyRings.buildUnifiedKeyRingsFindBySubkeyUri(tokenId));
        byte[] candidateFp = ring.getFingerprint();
        if (KeyFormattingUtils.convertFingerprintToHex(candidateFp).equals(mFingerprintString)) {
            showSecurityTokenFragment(mSecurityTokenFingerprints, mSecurityTokenUserId, mSecurityTokenAid, mSecurityTokenVersion);
            return;
        }
        final long masterKeyId = KeyFormattingUtils.getKeyIdFromFingerprint(candidateFp);
        Notify.create(this, R.string.snack_security_token_other, Notify.LENGTH_LONG, Style.WARN, new ActionListener() {
            public void onAction() {
                Intent intent = new Intent(ViewKeyActivity.this, ViewKeyActivity.class);
                intent.setData(KeyRings.buildGenericKeyRingUri(masterKeyId));
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_AID, mSecurityTokenAid);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_VERSION, mSecurityTokenVersion);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_USER_ID, mSecurityTokenUserId);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_FINGERPRINTS, mSecurityTokenFingerprints);
                startActivity(intent);
                finish();
            }
        }, R.string.snack_security_token_view).show();
    } catch (PgpKeyNotFoundException e) {
        Notify.create(this, R.string.snack_security_token_other, Notify.LENGTH_LONG, Style.WARN, new ActionListener() {
            public void onAction() {
                Intent intent = new Intent(ViewKeyActivity.this, CreateKeyActivity.class);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_AID, mSecurityTokenAid);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_VERSION, mSecurityTokenVersion);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_USER_ID, mSecurityTokenUserId);
                intent.putExtra(ViewKeyActivity.EXTRA_SECURITY_TOKEN_FINGERPRINTS, mSecurityTokenFingerprints);
                startActivity(intent);
                finish();
            }
        }, R.string.snack_security_token_import).show();
    }
}

Output:
         byte[] candidateFp = ring.getFingerprint();
-        if (KeyFormattingUtils.convertFingerprintToHex(candidateFp).equals(mFingerprintString)) {
+        if (Arrays.equals(candidateFp, mFingerprint)) {
             showSecurityTokenFragment(mSecurityTokenFingerprints, mSecurityTokenUserId, mSecurityTokenAid, mSecurityTokenVersion);


Input:
private TranslatedLibrary translateLibrary(VersionedIdentifier libraryIdentifier, List<CqlTranslatorException> errors) {
    InputStream librarySource = librarySourceLoader.getLibrarySource(libraryIdentifier);
    if (librarySource == null) {
        throw new CqlTranslatorIncludeException(String.format("String_Node_Str", libraryIdentifier.getId(), libraryIdentifier.getVersion()), libraryIdentifier.getId(), libraryIdentifier.getVersion());
    }
    try {
        CqlTranslator translator = CqlTranslator.fromStream(librarySource, this);
        if (errors != null) {
            errors.addAll(translator.getErrors());
        }
        TranslatedLibrary result = translator.getTranslatedLibrary();
        if (libraryIdentifier.getVersion() != null && !libraryIdentifier.getVersion().equals(result.getIdentifier().getVersion())) {
            throw new CqlTranslatorIncludeException(String.format("String_Node_Str", libraryIdentifier.getId(), libraryIdentifier.getVersion(), result.getIdentifier().getVersion()), libraryIdentifier.getId(), libraryIdentifier.getVersion());
        }
        return result;
    } catch (IOException e) {
        throw new CqlTranslatorIncludeException(String.format("String_Node_Str", libraryIdentifier.getId(), libraryIdentifier.getVersion()), libraryIdentifier.getId(), libraryIdentifier.getVersion(), e);
    }
}

Output:
 private TranslatedLibrary translateLibrary(VersionedIdentifier libraryIdentifier, List<CqlTranslatorException> errors) {
-    InputStream librarySource = librarySourceLoader.getLibrarySource(libraryIdentifier);
+    InputStream librarySource = null;
+    try {
+        librarySource = librarySourceLoader.getLibrarySource(libraryIdentifier);
+    } catch (Exception e) {
+        throw new CqlTranslatorIncludeException(e.getMessage(), libraryIdentifier.getId(), libraryIdentifier.getVersion(), e);
+    }
     if (librarySource == null) {


Input:
public void pushSlice(Workspace workspace, String from, String to, Edge edge) {
    AttributeModel am = workspace.getLookup().lookup(AttributeModel.class);
    AttributeColumn col = null;
    if (am.getEdgeTable().hasColumn(COLUMN_KEY)) {
        col = am.getEdgeTable().getColumn(COLUMN_KEY);
    } else {
        col = am.getEdgeTable().addColumn(COLUMN_KEY, COLUMN_TYPE);
    }
    DateFormat formatter = new SimpleDateFormat(DATE_FORMAT);
    double f = Double.NEGATIVE_INFINITY, t = Double.POSITIVE_INFINITY;
    try {
        if (from != null && !from.isEmpty()) {
            f = ((Date) formatter.parse(from)).getTime();
        }
        if (to != null && !to.isEmpty()) {
            t = ((Date) formatter.parse(to)).getTime();
        }
    } catch (ParseException ex) {
        Exceptions.printStackTrace(ex);
    }
    edge.getEdgeData().getAttributes().setValue(col.getIndex(), new TimeInterval(f, t));
}

Output:
     try {
-        if (from != null && !from.isEmpty()) {
+        if (from != null && !from.isEmpty())
             f = ((Date) formatter.parse(from)).getTime();


Input:
private void init(boolean duringLogon) {
    removeOldComponentsUserFolder();
    long startTime = System.currentTimeMillis();
    needInstalledNewCFComponents = new JSONObject();
    componentList = Collections.synchronizedSet(new HashSet<IComponent>());
    customComponentList = new HashSet<IComponent>();
    skeletonList = new ArrayList<String>();
    userComponentList = new HashSet<IComponent>();
    String installLocation = new Path(Platform.getConfigurationLocation().getURL().getPath()).toFile().getAbsolutePath();
    componentToProviderMap = new HashMap<IComponent, AbstractComponentsProvider>();
    boolean isNeedClean = !cleanDone && TalendCacheUtils.isSetCleanComponentCache();
    cleanDone = true;
    isCreated = hasComponentFile(installLocation) && !isNeedClean;
    ComponentsCache cache = ComponentManager.getComponentCache();
    try {
        if (isCreated) {
            if (cache.getComponentEntryMap().isEmpty()) {
                ComponentsCache loadCache = loadComponentResource(installLocation);
                cache.getComponentEntryMap().putAll(loadCache.getComponentEntryMap());
            }
        } else {
            cache.getComponentEntryMap().clear();
        }
    } catch (IOException e) {
        ExceptionHandler.process(e);
        cache.getComponentEntryMap().clear();
        isCreated = false;
    }
    loadComponentsFromComponentsProviderExtension();
    loadComponentsFromExtensions();
    ComponentManager.saveResource();
    initComponentNameMap();
    installNewCFComponents();
    log.debug(componentList.size() + "String_Node_Str" + (System.currentTimeMillis() - startTime) + "String_Node_Str");
}

Output:
     long startTime = System.currentTimeMillis();
-    needInstalledNewCFComponents = new JSONObject();
+    resetNewComponentsCache();
     componentList = Collections.synchronizedSet(new HashSet<IComponent>());


Input:
protected void cleanupOldFiles() {
    LOG.debug("String_Node_Str");
    Set<Long> validFileIds = new HashSet<Long>(_fileNameToId.values());
    for (CacheKey key : _cacheMap.keySet()) {
        long fileId = key.getFileId();
        if (validFileIds.contains(fileId)) {
            CacheValue remove = _cacheMap.remove(key);
            if (remove != null) {
                _removals.mark();
                addToReleaseQueue(key, remove);
            }
        }
    }
}

Output:
         long fileId = key.getFileId();
-        if (validFileIds.contains(fileId)) {
+        if (!validFileIds.contains(fileId)) {
             CacheValue remove = _cacheMap.remove(key);


Input:
public FaunusGraph edgeLabelDistribution(final Direction direction) throws IOException {
    this.completeSequence();
    Configuration conf = new Configuration();
    conf.set(EdgeLabelDistribution.DIRECTION, direction.name());
    final Job job = new Job(conf, EdgeLabelDistribution.class.getCanonicalName());
    job.setMapperClass(EdgeLabelDistribution.Map.class);
    job.setReducerClass(EdgeLabelDistribution.Reduce.class);
    job.setCombinerClass(EdgeLabelDistribution.Reduce.class);
    job.setJarByClass(FaunusGraph.class);
    job.setMapOutputKeyClass(Text.class);
    job.setMapOutputValueClass(IntWritable.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputKeyClass(IntWritable.class);
    this.outputFormat = this.statisticsOutputFormat;
    this.jobs.add(job);
    return this;
}

Output:
     job.setMapOutputKeyClass(Text.class);
-    job.setMapOutputValueClass(IntWritable.class);
+    job.setMapOutputValueClass(LongWritable.class);
     job.setOutputKeyClass(Text.class);


Input:
private void moduleOutput(Module module) throws IOException {
    File file = new File(root, ReporterTools.safe(module.name()) + "String_Node_Str");
    CSVWriter writer = new CSVWriter(new BufferedWriter(new FileWriter(file)));
    Set<Input> allUniverse = new HashSet<Input>();
    for (ModuleInstance instance : module.instances()) {
        allUniverse.addAll(instance.universe().keySet());
    }
    List<Input> universeKeys = new ArrayList<Input>(allUniverse);
    Comparator<Input> inputNameComparator = new Comparator<Input>() {
        public int compare(Input o1, Input o2) {
            return (o1.module().name() + o1.name()).compareTo(o2.module().name() + o2.name());
        }
    };
    Collections.sort(universeKeys, inputNameComparator);
    int n = universeKeys.size() + module.inputs().size() + module.outputs().size() + 2;
    String[] line = new String[n];
    int i = 0;
    for (Input universeKey : universeKeys) {
        line[i++] = universeKey.module().name() + "String_Node_Str" + universeKey.name();
    }
    line[i++] = "String_Node_Str";
    for (Input input : module.inputs()) line[i++] = input.name();
    line[i++] = "String_Node_Str";
    for (Output output : module.outputs()) line[i++] = output.name();
    writer.writeNext(line);
    for (ModuleInstance instance : module.instances()) {
        i = 0;
        for (Input universeKey : universeKeys) {
            if (instance.universe().containsKey(universeKey))
                line[i++] = instance.universe().get(universeKey).value().toString();
            else
                line[i++] = "String_Node_Str";
        }
        line[i++] = "String_Node_Str";
        for (InstanceInput input : instance.inputs()) line[i++] = input.value().toString();
        line[i++] = "String_Node_Str";
        for (InstanceOutput output : instance.outputs()) line[i++] = output.value().toString();
        writer.writeNext(line);
    }
    writer.close();
}

Output:
         line[i++] = "String_Node_Str";
-        for (InstanceOutput output : instance.outputs()) line[i++] = output.value().toString();
+        for (InstanceOutput output : instance.outputs()) line[i++] = Functions.toString(output.value());
         writer.writeNext(line);


Input:
public static double solve(UnivariateRealFunction f, double x0, double x1, double absoluteAccuracy) throws ConvergenceException, FunctionEvaluationException {
    setup(f);
    UnivariateRealSolver solver = factory.newDefaultSolver();
    solver.setAbsoluteAccuracy(absoluteAccuracy);
    return solver.solve(f, x0, x1);
}

Output:
     setup(f);
-    UnivariateRealSolver solver = factory.newDefaultSolver();
+    UnivariateRealSolver solver = LazyHolder.FACTORY.newDefaultSolver();
     solver.setAbsoluteAccuracy(absoluteAccuracy);


Input:
public IEnderDestination getOutput(boolean onlyLoaded) {
    if (output == null || output.isNotValid()) {
        output = null;
        if (!DimensionManager.isDimensionRegistered(dimension)) {
            return null;
        }
        WorldServer world = DimensionManager.getWorld(dimension);
        if (world == null && !onlyLoaded) {
            DimensionManager.initDimension(dimension);
            world = DimensionManager.getWorld(dimension);
        } else {
            return null;
        }
        if (!onlyLoaded || world.blockExists(x, y, z)) {
            TileEntity te = world.getTileEntity(x, y, z);
            if (te instanceof IEnderDestination) {
                output = (IEnderDestination) te;
            } else {
                isInvalid = true;
            }
        }
    }
    return output;
}

Output:
         }
-        if (!onlyLoaded || world.blockExists(x, y, z)) {
+        if (world.blockExists(x, y, z)) {
             TileEntity te = world.getTileEntity(x, y, z);


Input:
public IBenchmark parseOptions(Map options) {
    super.parseOptions(options);
    spout = new KafkaPageViewSpout(partitions);
    return this;
}

Output:
     super.parseOptions(options);
-    spout = new KafkaPageViewSpout(partitions);
+    spout = new KafkaPageViewSpout();
     return this;


Input:
public void inferTypes(IType concrete, ITypeContext typeContext) {
    if (this.parameterCount == 0 && this.returnType.isSuperTypeOf(concrete)) {
        this.returnType.inferTypes(concrete, typeContext);
        return;
    }
    ITypeVariable typeVar;
    IType concreteType;
    IClass iclass = this.getTheClass();
    for (int i = 0; i < this.parameterCount; i++) {
        typeVar = iclass.getTypeVariable(i);
        concreteType = concrete.resolveType(typeVar);
        if (concreteType != null) {
            this.parameterTypes[i].inferTypes(concreteType, typeContext);
        }
    }
    typeVar = iclass.getTypeVariable(this.parameterCount);
    concreteType = concrete.resolveType(typeVar);
    if (concreteType != null) {
        this.returnType.inferTypes(concreteType, typeContext);
    }
}

Output:
 public void inferTypes(IType concrete, ITypeContext typeContext) {
-    if (this.parameterCount == 0 && this.returnType.isSuperTypeOf(concrete)) {
-        this.returnType.inferTypes(concrete, typeContext);
-        return;
-    }
+    boolean found = false;
     ITypeVariable typeVar;


Input:
private void sendRegisterPacket(OutputStream outputStream, Map<String, Object> properties) throws ProtocolException, IOException {
    byte[] payload = ControlMessageEncodingUtils.encode(properties);
    ControlHandshakePacket packet = new ControlHandshakePacket(1, payload);
    ByteBuffer bb = packet.toBuffer().toByteBuffer(0, packet.toBuffer().writerIndex());
    sendData(outputStream, bb.array());
}

Output:
     ByteBuffer bb = packet.toBuffer().toByteBuffer(0, packet.toBuffer().writerIndex());
-    sendData(outputStream, bb.array());
+    IOUtils.write(outputStream, bb.array());
 }


Input:
public void destroyVolume(VolumeVO volume) throws ConcurrentOperationException {
    Transaction txn = Transaction.currentTxn();
    txn.start();
    _volsDao.update(volume, Volume.Event.Destroy);
    long volumeId = volume.getId();
    _snapshotMgr.deletePoliciesForVolume(volumeId);
    VMInstanceVO vmInstance = _vmInstanceDao.findById(volume.getInstanceId());
    if (vmInstance.getType().equals(VirtualMachine.Type.User)) {
        _accountMgr.decrementResourceCount(volume.getAccountId(), ResourceType.volume);
    }
    txn.commit();
}

Output:
     _snapshotMgr.deletePoliciesForVolume(volumeId);
-    VMInstanceVO vmInstance = _vmInstanceDao.findById(volume.getInstanceId());
-    if (vmInstance.getType().equals(VirtualMachine.Type.User)) {
+    Long instanceId = volume.getInstanceId();
+    VMInstanceVO vmInstance = null;
+    if (instanceId != null) {
+        vmInstance = _vmInstanceDao.findById(instanceId);
+    }
+    if (instanceId == null || (vmInstance.getType().equals(VirtualMachine.Type.User))) {
         _accountMgr.decrementResourceCount(volume.getAccountId(), ResourceType.volume);


Input:
public boolean isShowProgress() {
    return defaultLogger.isShowProgress();
}

Output:
 public boolean isShowProgress() {
-    return defaultLogger.isShowProgress();
+    return getDefaultLogger().isShowProgress();
 }


Input:
private void writeDriverHttpEndPoint(final File driverFolder, final String applicationId, final Path dfsPath) throws IOException {
    final FileSystem fs = FileSystem.get(yarnConfiguration);
    final Path httpEndpointPath = new Path(dfsPath, fileNames.getDriverHttpEndpoint());
    String trackingUri = null;
    for (int i = 0; i < 60; i++) {
        try {
            LOG.log(Level.INFO, "String_Node_Str" + i + "String_Node_Str" + httpEndpointPath.toString());
            if (fs.exists(httpEndpointPath)) {
                FSDataInputStream input = fs.open(httpEndpointPath);
                BufferedReader reader = new BufferedReader(new InputStreamReader(input, "String_Node_Str"));
                trackingUri = reader.readLine();
                reader.close();
                break;
            }
        } catch (Exception ex) {
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex2) {
            break;
        }
    }
    if (null == trackingUri) {
        trackingUri = "String_Node_Str";
        LOG.log(Level.WARNING, "String_Node_Str" + httpEndpointPath.toString());
    }
    final File driverHttpEndpointFile = new File(driverFolder, fileNames.getDriverHttpEndpoint());
    BufferedWriter out = new BufferedWriter(new FileWriter(driverHttpEndpointFile));
    out.write(applicationId + "String_Node_Str");
    out.write(trackingUri + "String_Node_Str");
    String addr = yarnConfiguration.get("String_Node_Str");
    if (null == addr || addr.startsWith("String_Node_Str")) {
        String str2 = yarnConfiguration.get("String_Node_Str");
        if (null != str2) {
            for (String rm : str2.split("String_Node_Str")) {
                out.write(yarnConfiguration.get("String_Node_Str" + rm) + "String_Node_Str");
            }
        }
    } else {
        out.write(addr + "String_Node_Str");
    }
    out.close();
}

Output:
                 FSDataInputStream input = fs.open(httpEndpointPath);
-                BufferedReader reader = new BufferedReader(new InputStreamReader(input, "String_Node_Str"));
+                BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
                 trackingUri = reader.readLine();


Input:
public void register(final ExecutionVertexID vertexID, final Environment environment) {
    final TaskContext taskContext = new TaskContext();
    for (int i = 0; i < environment.getNumberOfOutputGates(); ++i) {
        final OutputGate<?> outputGate = environment.getOutputGate(i);
        final OutputGateContext outputGateContext = new OutputGateContext(taskContext, outputGate, this, this.fileBufferManager);
        for (int j = 0; j < outputGate.getNumberOfOutputChannels(); ++j) {
            final AbstractOutputChannel<?> outputChannel = outputGate.getOutputChannel(j);
            if (outputChannel instanceof AbstractByteBufferedOutputChannel) {
                LOG.error("String_Node_Str" + outputChannel.getID() + "String_Node_Str" + environment.getJobID() + "String_Node_Str");
                continue;
            }
            final AbstractByteBufferedOutputChannel<?> bboc = (AbstractByteBufferedOutputChannel<?>) outputChannel;
            if (this.registeredChannels.containsKey(bboc.getID())) {
                LOG.error("String_Node_Str" + bboc.getID() + "String_Node_Str");
                continue;
            }
            LOG.info("String_Node_Str" + bboc.getID());
            final OutputChannelContext outputChannelContext = new OutputChannelContext(outputGateContext, bboc);
            this.registeredChannels.put(bboc.getID(), outputChannelContext);
        }
    }
    for (int i = 0; i < environment.getNumberOfInputGates(); ++i) {
        final InputGate<?> inputGate = environment.getInputGate(i);
        final InputGateContext inputGateContext = new InputGateContext(taskContext);
        for (int j = 0; j < inputGate.getNumberOfInputChannels(); ++j) {
            final AbstractInputChannel<?> inputChannel = inputGate.getInputChannel(j);
            if (inputChannel instanceof AbstractByteBufferedInputChannel) {
                LOG.error("String_Node_Str" + inputChannel.getID() + "String_Node_Str" + environment.getJobID() + "String_Node_Str");
                continue;
            }
            final AbstractByteBufferedInputChannel<?> bbic = (AbstractByteBufferedInputChannel<?>) inputChannel;
            if (this.registeredChannels.containsKey(bbic.getID())) {
                LOG.error("String_Node_Str" + bbic.getID() + "String_Node_Str");
                continue;
            }
            LOG.info("String_Node_Str" + bbic.getID());
            final InputChannelContext inputChannelContext = new InputChannelContext(inputGateContext, this, bbic);
            this.registeredChannels.put(bbic.getID(), inputChannelContext);
        }
    }
}

Output:
             final AbstractOutputChannel<?> outputChannel = outputGate.getOutputChannel(j);
-            if (outputChannel instanceof AbstractByteBufferedOutputChannel) {
+            if (!(outputChannel instanceof AbstractByteBufferedOutputChannel)) {
                 LOG.error("String_Node_Str" + outputChannel.getID() + "String_Node_Str" + environment.getJobID() + "String_Node_Str");


Input:
static IStyle processStyle(IReportContent reportContent, AbstractCrosstabItemHandle handle, IBaseResultSet evaluator, Map styleCache) throws BirtException {
    ReportElementHandle modelHandle = getReportElementHandle(handle);
    if (modelHandle == null || modelHandle.getPrivateStyle() == null || reportContent == null) {
        return null;
    }
    IStyle style = null;
    if (evaluator != null) {
        style = reportContent.createStyle();
        IStyle highlightStyle = reportContent.createStyle();
        setupHighlightStyle(modelHandle, highlightStyle, evaluator);
        if (!highlightStyle.isEmpty()) {
            IStyle newStyle = reportContent.createStyle();
            newStyle.setProperties(style);
            newStyle.setProperties(highlightStyle);
            return newStyle;
        }
    }
    return style;
}

Output:
     ReportElementHandle modelHandle = getReportElementHandle(handle);
-    if (modelHandle == null || modelHandle.getPrivateStyle() == null || reportContent == null) {
+    if (modelHandle == null || reportContent == null || evaluator == null) {
         return null;


Input:
protected void okPressed() {
    try {
        inputParameter.setName(nameEditor.getText());
        inputParameter.setPromptText(UIUtil.convertToModelString(promptTextEditor.getText(), true));
        String newControlType = getSelectedControlType();
        if (PARAM_CONTROL_COMBO.equals(newControlType)) {
            newControlType = DesignChoiceConstants.PARAM_CONTROL_LIST_BOX;
            inputParameter.setMustMatch(false);
        } else if (PARAM_CONTROL_LIST.equals(newControlType)) {
            newControlType = DesignChoiceConstants.PARAM_CONTROL_LIST_BOX;
            inputParameter.setMustMatch(true);
        } else {
            inputParameter.setProperty(ScalarParameterHandle.MUCH_MATCH_PROP, null);
        }
        inputParameter.setControlType(newControlType);
        if (DesignChoiceConstants.PARAM_TYPE_DATETIME.equals(getSelectedDataType())) {
            defaultValue = DEUtil.convertToXMLString(DataTypeUtil.toDate(defaultValue, ULocale.US));
        }
        inputParameter.setDefaultValue(defaultValue);
        inputParameter.setDataType(DATA_TYPE_CHOICE_SET.findChoiceByDisplayName(dataTypeChooser.getText()).getName());
        PropertyHandle selectionChioceList = inputParameter.getPropertyHandle(ScalarParameterHandle.SELECTION_LIST_PROP);
        selectionChioceList.setValue(null);
        if (isStatic()) {
            inputParameter.setValueType(DesignChoiceConstants.PARAM_VALUE_TYPE_STATIC);
            if (!DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(newControlType) && !DesignChoiceConstants.PARAM_CONTROL_CHECK_BOX.equals(newControlType)) {
                for (Iterator iter = choiceList.iterator(); iter.hasNext(); ) {
                    SelectionChoice choice = (SelectionChoice) iter.next();
                    if (isValidValue(choice.getValue()) == null) {
                        selectionChioceList.addItem(choice);
                    }
                }
            }
            inputParameter.setDataSetName(null);
            inputParameter.setValueExpr(null);
            inputParameter.setLabelExpr(null);
        } else {
            inputParameter.setValueType(DesignChoiceConstants.PARAM_VALUE_TYPE_DYNAMIC);
            inputParameter.setDataSetName(dataSetChooser.getText());
            inputParameter.setValueExpr(getExpression(columnChooser.getText()));
            inputParameter.setLabelExpr(getExpression(displayTextChooser.getText()));
        }
        inputParameter.setHelpText(UIUtil.convertToModelString(helpTextEditor.getText(), false));
        inputParameter.setCategory(formatCategroy);
        inputParameter.setPattern(formatPattern);
        if (isStatic() && (PARAM_CONTROL_COMBO.equals(getSelectedControlType()) || DesignChoiceConstants.PARAM_CONTROL_RADIO_BUTTON.equals(getSelectedControlType())) && !containValue(null, defaultValue, COLUMN_VALUE)) {
            defaultValue = null;
        }
        if (dirtyProperties.containsKey(CHECKBOX_HIDDEN)) {
            inputParameter.setHidden(getProperty(CHECKBOX_HIDDEN));
        }
        if (dirtyProperties.containsKey(CHECKBOX_ALLOW_NULL)) {
            inputParameter.setAllowNull(getProperty(CHECKBOX_ALLOW_NULL));
        }
        if (allowBlank.isEnabled()) {
            if (dirtyProperties.containsKey(CHECKBOX_ALLOW_BLANK)) {
                inputParameter.setAllowBlank(getProperty(CHECKBOX_ALLOW_BLANK));
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.ALLOW_BLANK_PROP, null);
        }
        if (doNotEcho.isEnabled()) {
            if (dirtyProperties.containsKey(CHECKBOX_DO_NOT_ECHO)) {
                inputParameter.setConcealValue(getProperty(CHECKBOX_DO_NOT_ECHO));
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.CONCEAL_VALUE_PROP, null);
        }
        if (needSort.isEnabled()) {
            if (dirtyProperties.containsKey(CHECKBOX_SORT)) {
                inputParameter.setFixedOrder(!getProperty(CHECKBOX_SORT));
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.FIXED_ORDER_PROP, null);
        }
        if (!isStatic() && !StringUtil.isBlank(listLimit.getText())) {
            try {
                inputParameter.setListlimit(Integer.parseInt(listLimit.getText()));
            } catch (NumberFormatException ex) {
                ExceptionHandler.openErrorMessageBox(ERROR_TITLE_INVALID_LIST_LIMIT, MessageFormat.format(ERROR_MSG_INVALID_LIST_LIMIT, new Object[] { Integer.toString(Integer.MAX_VALUE) }));
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.LIST_LIMIT_PROP, null);
        }
    } catch (Exception e) {
        ExceptionHandler.handle(e);
        return;
    }
    setResult(inputParameter);
    super.okPressed();
}

Output:
             inputParameter.setValueExpr(getExpression(columnChooser.getText()));
-            inputParameter.setLabelExpr(getExpression(displayTextChooser.getText()));
+            if (displayTextChooser.getText().equals("String_Node_Str")) {
+                inputParameter.setLabelExpr("String_Node_Str");
+            } else {
+                inputParameter.setLabelExpr(getExpression(displayTextChooser.getText()));
+            }
         }


Input:
protected Error.Type confirmJob(Job ajob) {
    String extras_config = "String_Node_Str";
    if (this.config.getNbCores() > 0) {
        extras_config = "String_Node_Str" + this.config.getNbCores();
    }
    String url_real = String.format("String_Node_Str", this.server.getPage("String_Node_Str"), ajob.getId(), ajob.getFrameNumber(), ajob.getProcessRender().getDuration(), ajob.getRevision(), ajob.getProcessRender().getMemoryUsed(), ajob.getExtras(), extras_config);
    this.isValidatingJob = true;
    int nb_try = 1;
    int max_try = 3;
    ServerCode ret = ServerCode.UNKNOWN;
    while (nb_try < max_try && ret != ServerCode.OK) {
        ret = this.server.HTTPSendFile(url_real, ajob.getOutputImagePath());
        switch(ret) {
            case OK:
                nb_try = max_try;
                break;
            case JOB_VALIDATION_ERROR_SESSION_DISABLED:
            case JOB_VALIDATION_ERROR_BROKEN_MACHINE:
                return Type.SESSION_DISABLED;
            case JOB_VALIDATION_ERROR_MISSING_PARAMETER:
                return Error.Type.UNKNOWN;
            default:
                break;
        }
        nb_try++;
        if (ret != ServerCode.OK && nb_try < max_try) {
            try {
                this.log.debug("String_Node_Str");
                Thread.sleep(32000);
            } catch (InterruptedException e) {
                return Error.Type.UNKNOWN;
            }
        }
    }
    this.isValidatingJob = false;
    File frame = new File(ajob.getOutputImagePath());
    frame.delete();
    ajob.setOutputImagePath(null);
    this.isValidatingJob = false;
    return Error.Type.OK;
}

Output:
     String extras_config = "String_Node_Str";
-    if (this.config.getNbCores() > 0) {
-        extras_config = "String_Node_Str" + this.config.getNbCores();
+    RenderProcess process = ajob.getProcessRender();
+    if (process != null && process.getCoresUsed() > 0) {
+        extras_config = "String_Node_Str" + process.getCoresUsed();
     }


Input:
public void delete() {
    GLES20.glDeleteBuffers(1, new int[] { id }, 0);
    buffers.remove(this);
}

Output:
 public void delete() {
-    GLES20.glDeleteBuffers(1, new int[] { id }, 0);
-    buffers.remove(this);
+    synchronized (buffers) {
+        GLES20.glDeleteBuffers(1, new int[] { id }, 0);
+        buffers.remove(this);
+    }
 }