Input:
final static public void calculateTargetBoundingBox(final double[][] pq, final double[] min, final double[] max) {
    min[0] = pq[2][0];
    min[1] = pq[3][0];
    max[0] = pq[2][0];
    max[1] = pq[3][0];
    for (int i = 1; i < pq[0].length; ++i) {
        if (pq[2][i] < min[0])
            min[0] = pq[2][i];
        else if (pq[2][i] > max[0])
            max[0] = pq[2][i];
        if (pq[3][i] < min[1])
            min[1] = pq[3][i];
        else if (pq[3][i] > max[1])
            max[1] = pq[3][i];
    }
}

Output:
 final static public void calculateTargetBoundingBox(final double[][] pq, final double[] min, final double[] max) {
-    min[0] = pq[2][0];
-    min[1] = pq[3][0];
-    max[0] = pq[2][0];
-    max[1] = pq[3][0];
-    for (int i = 1; i < pq[0].length; ++i) {
-        if (pq[2][i] < min[0])
-            min[0] = pq[2][i];
-        else if (pq[2][i] > max[0])
-            max[0] = pq[2][i];
-        if (pq[3][i] < min[1])
-            min[1] = pq[3][i];
-        else if (pq[3][i] > max[1])
-            max[1] = pq[3][i];
-    }
+    calculateBoundingBox(pq[2], pq[3], min, max);
 }


Input:
public void handle(Message inputMessage, IMessageTarget messageTarget) {
    if (attributes.size() == 0) {
        executionTracker.log(executionId, LogLevel.INFO, this, "String_Node_Str");
    }
    componentStatistics.incrementInboundMessages();
    ArrayList<EntityData> inputRows = inputMessage.getPayload();
    Message outputMessage = new Message(flowStep.getId());
    ArrayList<String> outputPayload = new ArrayList<String>();
    String outputRec;
    for (EntityData inputRow : inputRows) {
        outputRec = processInputRow(executionId, inputRow);
        outputPayload.add(outputRec);
    }
    outputMessage.setPayload(outputPayload);
    executionTracker.log(executionId, LogLevel.INFO, this, outputPayload.toString());
    componentStatistics.incrementOutboundMessages();
    outputMessage.getHeader().setSequenceNumber(componentStatistics.getNumberOutboundMessages());
    outputMessage.getHeader().setLastMessage(inputMessage.getHeader().isLastMessage());
    messageTarget.put(outputMessage);
}

Output:
     for (EntityData inputRow : inputRows) {
-        outputRec = processInputRow(executionId, inputRow);
+        outputRec = processInputRow(inputRow);
         outputPayload.add(outputRec);


Input:
private void writeSimpleTypeFile(WSDLDocInterface doc, SimpleType type) throws OutputFormatterException {
    logger.entering("String_Node_Str", "String_Node_Str", new Object[] { doc, type });
    String typeName = type.getName();
    StringBuffer html = new StringBuffer();
    if (typeName != null && !Utils.isEmpty(typeName)) {
        html = new StringBuffer();
        html.append(HtmlUtils.getStartTags(typeName, doc.getPackageName() + File.separator + "String_Node_Str"));
        String parentType = type.getBase();
        if (!Utils.isEmpty(parentType)) {
            parentType = Utils.removeNameSpace(parentType);
            typeName = typeName + "String_Node_Str" + parentType + "String_Node_Str";
        }
        html.append(getTextInDiv("String_Node_Str" + typeName, "String_Node_Str"));
        html.append(Constants.HTML_HR);
        html.append(Constants.HTML_DL_START + Constants.HTML_DD_START);
        if (type.getAnnotations().getDocumentation() != null) {
            html.append(getTextInSpan(type.getAnnotations().getDocumentation(), "String_Node_Str"));
        }
        html.append(Constants.HTML_DD_END + Constants.HTML_DL_END);
        StringBuffer deprDet = AnnotationsHelper.processDeprication(type.getAnnotations());
        if (deprDet != null) {
            html.append(getTextInDiv("String_Node_Str", "String_Node_Str"));
            html.append(deprDet);
        }
        processRelatedInfo(html, doc, type.getAnnotations());
        html.append(Constants.HTML_HR);
        html.append(Constants.HTML_BR + Constants.HTML_BR);
        List<EnumElement> enumElements = type.getEnums();
        if (enumElements != null && !enumElements.isEmpty()) {
            html.append(getTableTagWithStyle("String_Node_Str"));
            html.append(getTableRowTagWithStyle("String_Node_Str"));
            html.append("String_Node_Str");
            html.append("String_Node_Str");
            html.append(Constants.HTML_TABLE_TH_END);
            html.append(Constants.HTML_TABLE_TR_END);
            html.append(getTableRowTagWithStyle("String_Node_Str"));
            html.append(getTableHeadTagWithStyle("String_Node_Str"));
            html.append("String_Node_Str");
            html.append(Constants.HTML_TABLE_TH_END);
            html.append(getTableHeadTagWithStyle("String_Node_Str"));
            html.append("String_Node_Str");
            html.append(Constants.HTML_TABLE_TH_END);
            html.append(Constants.HTML_TABLE_TR_END);
            for (EnumElement enumElement : enumElements) {
                html.append(getTableRowTagWithStyle("String_Node_Str"));
                html.append(getTableDataTagWithStyle("String_Node_Str"));
                html.append(enumElement.getValue());
                html.append(Constants.HTML_TABLE_TD_END);
                html.append(getTableDataTagWithStyle("String_Node_Str"));
                if (enumElement.getAnnotations().getDocumentation() != null) {
                    html.append(enumElement.getAnnotations().getDocumentation());
                }
                deprDet = AnnotationsHelper.processDeprication(enumElement.getAnnotations());
                if (deprDet != null) {
                    html.append(getTextInDiv("String_Node_Str", "String_Node_Str"));
                    html.append(deprDet);
                }
                processRelatedInfo(html, doc, enumElement.getAnnotations());
                html.append(Constants.HTML_TABLE_TD_END);
                html.append(Constants.HTML_TABLE_TR_END);
            }
            html.append(Constants.HTML_TABLE_END);
        }
        addFooter(html);
        writeFile(html, currentTypesFolderPath, typeName + Constants.DOT_HTML);
    }
    logger.exiting("String_Node_Str", "String_Node_Str", html);
}

Output:
         html = new StringBuffer();
-        html.append(HtmlUtils.getStartTags(typeName, doc.getPackageName() + File.separator + "String_Node_Str"));
+        html.append(HtmlUtils.getStartTags(typeName, currentPackageName + File.separator + "String_Node_Str"));
         String parentType = type.getBase();


Input:
public Integer apply(Integer integer) {
    int diff = target.getMondayDoWValue() - source.getMondayDoWValue();
    int result = integer;
    if (diff == 0) {
        return integer;
    }
    if (diff < 0) {
        result = integer + diff;
        int distanceToStartRange = startRange - result;
        if (result < startRange) {
            result = endRange + 1 - distanceToStartRange;
        }
    }
    if (diff > 0) {
        result = integer + diff;
        if (result > endRange) {
            result -= endRange;
        }
    }
    return result;
}

Output:
     int diff = target.getMondayDoWValue() - source.getMondayDoWValue();
-    int result = integer;
-    if (diff == 0) {
-        return integer;
+    int result = integer + diff;
+    if (result < startRange) {
+        result -= (startRange - endRange + 1);
     }


Input:
private void drawSpheres(RenderObject robj, double rad) {
    GL2 gl = getGL2();
    maybeUpdateState(gl);
    List<int[]> pnts = robj.getPoints();
    int displayList = myGLResources.getSphereDisplayList(gl, myPointSlices);
    boolean selecting = isSelecting();
    boolean hasColors = (robj.hasColors() && isVertexColoringEnabled());
    boolean useColors = hasColors && !selecting;
    boolean useHSV = isHSVColorInterpolationEnabled() && !isLightingEnabled();
    if (useColors) {
        gl.glColorMaterial(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT_AND_DIFFUSE);
        gl.glEnable(GL2.GL_COLOR_MATERIAL);
        if (useHSV) {
            useHSV = setupHSVInterpolation(gl);
        }
    }
    boolean useDisplayList = !selecting || !hasColors;
    DisplayListPassport dlpp = null;
    RenderObjectKey key = new RenderObjectKey(robj, DrawType.POINTS);
    PointFingerPrint fingerprint = new PointFingerPrint(robj.getVersionInfo(), PointStyle.SPHERE, displayList, (float) rad);
    boolean compile = true;
    if (useDisplayList) {
        dlpp = myGLResources.getDisplayListPassport(gl, key);
        if (dlpp == null) {
            dlpp = myGLResources.allocateDisplayListPassport(gl, key, fingerprint);
            compile = true;
        } else {
            compile = !(dlpp.compareExchangeFingerPrint(fingerprint));
        }
    }
    if (compile) {
        if (dlpp != null) {
            gl.glNewList(dlpp.getList(), GL2.GL_COMPILE);
        }
        for (int[] pnt : pnts) {
            VertexIndexSet v = robj.getVertex(pnt[0]);
            if (!selecting && useColors) {
                setVertexColor(gl, robj.getColor(v.getColorIndex()), useHSV);
            }
            float[] p = robj.getPosition(v.getPositionIndex());
            gl.glPushMatrix();
            gl.glTranslatef(p[0], p[1], p[2]);
            gl.glScaled(rad, rad, rad);
            gl.glCallList(displayList);
            gl.glPopMatrix();
        }
        if (dlpp != null) {
            gl.glEndList();
            gl.glCallList(dlpp.getList());
        }
    } else {
        gl.glCallList(dlpp.getList());
    }
    if (useColors) {
        gl.glDisable(GL2.GL_COLOR_MATERIAL);
        if (useHSV) {
            gl.glUseProgramObjectARB(0);
        }
    }
}

Output:
         gl.glColorMaterial(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT_AND_DIFFUSE);
-        gl.glEnable(GL2.GL_COLOR_MATERIAL);
+        if (!mySelectedColorActive) {
+            gl.glEnable(GL2.GL_COLOR_MATERIAL);
+        }
         if (useHSV) {


Input:
private void healthCheck(Id id) {
    final HealthChecks healthChecks = conf(id).getHealthChecks();
    for (Pattern pattern : healthChecks.getLogPatterns()) {
        waitFor(id, pattern);
    }
    for (Ping ping : healthChecks.getPings()) {
        waitFor(id, ping);
    }
}

Output:
     final HealthChecks healthChecks = conf(id).getHealthChecks();
-    for (Pattern pattern : healthChecks.getLogPatterns()) {
+    for (LogPattern pattern : healthChecks.getLogPatterns()) {
         waitFor(id, pattern);


Input:
private void initGitContext(RepositoryInformation repositoryInformation) {
    log.info("String_Node_Str");
    int tenantId = Integer.parseInt(repositoryInformation.getTenantId());
    String gitLocalRepoPath = repositoryInformation.getRepoPath();
    RepositoryContext gitRepoCtx = new RepositoryContext();
    String gitRemoteRepoUrl = repositoryInformation.getRepoUrl();
    log.info("String_Node_Str" + gitLocalRepoPath);
    log.info("String_Node_Str" + gitRemoteRepoUrl);
    log.info("String_Node_Str" + tenantId);
    gitRepoCtx.setTenantId(tenantId);
    gitRepoCtx.setGitLocalRepoPath(getRepoPathForTenantId(tenantId, gitLocalRepoPath));
    gitRepoCtx.setGitRemoteRepoUrl(gitRemoteRepoUrl);
    gitRepoCtx.setRepoUsername(repositoryInformation.getRepoUsername());
    gitRepoCtx.setRepoPassword(repositoryInformation.getRepoPassword());
    try {
        if (isKeyBasedAuthentication(gitRemoteRepoUrl, tenantId)) {
            gitRepoCtx.setKeyBasedAuthentication(true);
            initSSHAuthentication();
        } else
            gitRepoCtx.setKeyBasedAuthentication(false);
    } catch (Exception e1) {
        log.error("String_Node_Str" + e1.getMessage(), e1);
    }
    FileRepository localRepo = null;
    try {
        localRepo = new FileRepository(new File(gitLocalRepoPath + "String_Node_Str"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    gitRepoCtx.setLocalRepo(localRepo);
    gitRepoCtx.setGit(new Git(localRepo));
    gitRepoCtx.setCloneExists(false);
    cacheGitRepoContext(tenantId, gitRepoCtx);
}

Output:
     gitRepoCtx.setTenantId(tenantId);
-    gitRepoCtx.setGitLocalRepoPath(getRepoPathForTenantId(tenantId, gitLocalRepoPath));
+    gitRepoCtx.setGitLocalRepoPath(getRepoPathForTenantId(tenantId, gitLocalRepoPath, isMultitenant));
     gitRepoCtx.setGitRemoteRepoUrl(gitRemoteRepoUrl);


Input:
public boolean equals(Object o) {
    return o instanceof Reagent ? this == o && name.equals(((Reagent) o).name) : false;
}

Output:
 public boolean equals(Object o) {
-    return o instanceof Reagent ? this == o && name.equals(((Reagent) o).name) : false;
+    return o instanceof Reagent && this == o && name.equals(((Reagent) o).name);
 }


Input:
private void saveUserInputToFile() {
    OWLOntology activeOnt = getOWLModelManager().getActiveOntology();
    URI uri = getOWLModelManager().getOntologyPhysicalURI(activeOnt);
    String outputFile = uri.toString().substring(0, uri.toString().lastIndexOf('.') + 1) + "String_Node_Str";
    OutputStream fos = null;
    File file = new File(outputFile);
    try {
        fos = new FileOutputStream(file);
        ObjectOutputStream o = new ObjectOutputStream(fos);
        o.flush();
        o.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fos.close();
        } catch (Exception e) {
        }
    }
}

Output:
     OutputStream fos = null;
-    File file = new File(outputFile);
+    File file = new File(URI.create(outputFile));
     try {


Input:
private Drawable getCachedDrawable(long key) {
    synchronized (mTmpValue) {
        WeakReference<Drawable.ConstantState> wr = mDrawableCache.get(key);
        if (wr != null) {
            Drawable.ConstantState entry = wr.get();
            if (entry != null) {
                return entry.newDrawable(this);
            } else {
                mDrawableCache.delete(key);
            }
        }
    }
    return null;
}

Output:
     synchronized (mTmpValue) {
-        WeakReference<Drawable.ConstantState> wr = mDrawableCache.get(key);
+        WeakReference<Drawable.ConstantState> wr = drawableCache.get(key);
         if (wr != null) {


Input:
public ConditionQueryBuilder<ModelClass> append(String selection, Object... selectionArgs) {
    String toAppend = selection;
    if (selection != null && selectionArgs != null) {
        for (Object o : selectionArgs) {
            toAppend = toAppend.replaceFirst("String_Node_Str", convertValueToString(o));
        }
    }
    mWhereRaw = toAppend;
    return super.append(toAppend);
}

Output:
 public ConditionQueryBuilder<ModelClass> append(String selection, Object... selectionArgs) {
-    String toAppend = selection;
-    if (selection != null && selectionArgs != null) {
-        for (Object o : selectionArgs) {
-            toAppend = toAppend.replaceFirst("String_Node_Str", convertValueToString(o));
+    if (selection != null) {
+        String toAppend = selection;
+        if (selectionArgs != null) {
+            for (Object o : selectionArgs) {
+                toAppend = toAppend.replaceFirst("String_Node_Str", convertValueToString(o));
+            }
         }


Input:
public Alignment<S> localAlignSmithWaterGotoh(S a, S b) {
    float[][] D = new float[a.length() + 1][b.length() + 1];
    float[][] P = new float[a.length() + 1][b.length() + 1];
    float[][] Q = new float[a.length() + 1][b.length() + 1];
    for (int i = 1; i <= a.length(); i++) {
        D[i][0] = 0.0f;
        P[i][0] = Float.NEGATIVE_INFINITY;
        Q[i][0] = Float.NEGATIVE_INFINITY;
    }
    for (int j = 1; j <= b.length(); j++) {
        D[0][j] = 0.0f;
        P[0][j] = Float.NEGATIVE_INFINITY;
        Q[0][j] = Float.NEGATIVE_INFINITY;
    }
    float maxValue = 0.0f;
    int maxI = 0;
    int maxJ = 0;
    for (int i = 1; i <= a.length(); i++) {
        for (int j = 1; j <= b.length(); j++) {
            P[i][j] = Math.max(D[i - 1][j] + this.gapOpen, P[i - 1][j] + this.gapExtend);
            Q[i][j] = Math.max(D[i][j - 1] + this.gapOpen, Q[i][j - 1] + this.gapExtend);
            float score = D[i - 1][j - 1] + (float) a.similarityScore(b, i - 1, j - 1) + this.scoreOffset;
            D[i][j] = Math.max(score, Math.max(P[i][j], Q[i][j]));
            if (D[i][j] > maxValue) {
                maxValue = D[i][j];
                maxI = i;
                maxJ = j;
            }
        }
    }
    float score = maxValue;
    int a1 = 0;
    int a2 = maxI;
    int b1 = 0;
    int b2 = maxJ;
    if (storePath) {
        ArrayList<Alignment.Operation> backOperations = new ArrayList<>(a.length() + b.length());
        int i = a.length();
        while (i > maxI) {
            backOperations.add(Operation.DELETE);
            i--;
        }
        i = maxI;
        int j = maxJ;
        while (i > 0 && j > 0) {
            if ((P[i][j] >= Q[i][j] && P[i][j] == D[i][j]) || j == 0) {
                backOperations.add(Operation.DELETE);
                i--;
            } else if (Q[i][j] == D[i][j] || i == 0) {
                backOperations.add(Operation.INSERT);
                j--;
            } else {
                backOperations.add(Operation.MATCH);
                i--;
                j--;
            }
        }
        a1 = i + 1;
        b1 = j + 1;
        while (i > 0) {
            backOperations.add(Operation.DELETE);
            i--;
        }
        Collections.reverse(backOperations);
        return new Alignment<S>(a, b, a1, a2, b1, b2, score, this.gapOpen, backOperations);
    }
    return new Alignment<S>(a, b, a1, a2, b1, b2, score, this.gapOpen, null);
}

Output:
     int a1 = 0;
-    int a2 = maxI;
+    int a2 = maxI - 1;
     int b1 = 0;


Input:
public int getHeight() {
    DimensionHandle handle = getRowHandle().getHeight();
    int px = (int) DEUtil.convertoToPixel(handle);
    if (px <= 0) {
        px = DEFAULT_HEIGHT;
    }
    return px;
}

Output:
     DimensionHandle handle = getRowHandle().getHeight();
-    int px = (int) DEUtil.convertoToPixel(handle);
+    int px = (int) (DEUtil.convertoToPixel(handle) + 0.5);
     if (px <= 0) {


Input:
public ID createInstance(Class[] argTypes, Object[] args) throws IDCreateException {
    if (args == null || args.length <= 0)
        return new GUID(this);
    else
        return new GUID(this, ((Integer) args[0]).intValue());
}

Output:
     else
-        return new GUID(this, ((Integer) args[0]).intValue());
+        return new GUID(this);
 }


Input:
public void run() {
    try {
        super.run();
        TreeObject xobject = null;
        if (selObj == null) {
            ISelection selection = this.server.getViewer().getSelection();
            xobject = (TreeObject) ((IStructuredSelection) selection).getFirstElement();
        } else {
            xobject = selObj;
        }
        server.getSite().getWorkbenchWindow().getActivePage().openEditor(new XObjectBrowserInput(xobject, xobject.getDisplayName()), XObjectBrowser.ID);
    } catch (Exception e) {
        log.error(e.getStackTrace());
        MessageDialog.openError(server.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());
    }
}

Output:
     } catch (Exception e) {
-        log.error(e.getStackTrace());
+        log.error(e.getMessage(), e);
         MessageDialog.openError(server.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());


Input:
public boolean setAssignedTLType(TLModelElement simpleType) {
    if (simpleType == getTLModelObject().getSimpleType())
        return false;
    NamedEntity ne = null;
    if (simpleType == null || !(simpleType instanceof NamedEntity))
        ne = (NamedEntity) getEmptyNode().getTLModelObject();
    else
        ne = (NamedEntity) simpleType;
    getTLModelObject().setSimpleType(ne);
    return getTLModelObject().getSimpleType() == ne;
}

Output:
 public boolean setAssignedTLType(TLModelElement simpleType) {
-    if (simpleType == getTLModelObject().getSimpleType())
+    if (getTLModelObject() == null || simpleType == getTLModelObject().getSimpleType())
         return false;


Input:
public void warning(Exception e) {
    log(Level.WARNING, "String_Node_Str" + e.getMessage());
    StackTraceElement[] stes = e.getStackTrace();
    for (StackTraceElement ste : stes) {
        log(Level.WARNING, ste.toString());
    }
    log(Level.WARNING, "String_Node_Str");
}

Output:
 public void warning(Exception e) {
-    log(Level.WARNING, "String_Node_Str" + e.getMessage());
+    log(Level.WARNING, "String_Node_Str" + e.toString());
     StackTraceElement[] stes = e.getStackTrace();


Input:
public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
    PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
    ps.setObject(0, product.getTitle());
    ps.setObject(1, product.getKey());
    ps.setObject(2, product.getSecret());
    ps.setObject(3, product.getClientTypeid());
    ps.setObject(4, product.getCertPath());
    ps.setObject(5, product.getDevCertPath());
    return ps;
}

Output:
     PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
-    ps.setObject(0, product.getTitle());
-    ps.setObject(1, product.getKey());
-    ps.setObject(2, product.getSecret());
-    ps.setObject(3, product.getClientTypeid());
-    ps.setObject(4, product.getCertPath());
-    ps.setObject(5, product.getDevCertPath());
+    ps.setObject(1, product.getTitle());
+    ps.setObject(2, product.getKey());
+    ps.setObject(3, product.getSecret());
+    ps.setObject(4, product.getClientTypeid());
+    ps.setObject(5, product.getCertPath());
+    ps.setObject(6, product.getDevCertPath());
     return ps;


Input:
public void testPushProxyRequest() throws Exception {
    drain(testUP);
    final byte[] clientGUID = GUID.makeGuid();
    byte[] guid = GUID.makeGuid();
    rs.query(guid, "String_Node_Str");
    Message m = null;
    do {
        m = testUP.receive(TIMEOUT);
    } while (!(m instanceof QueryRequest));
    ServerSocket ss = new ServerSocket(7000);
    ss.setReuseAddress(true);
    ss.setSoTimeout(TIMEOUT * 4);
    final Set proxies = new HashSet();
    proxies.add(new QueryReply.PushProxyContainer("String_Node_Str", 7000));
    Response[] res = new Response[1];
    res[0] = new Response(10, 10, "String_Node_Str");
    m = new QueryReply(m.getGUID(), (byte) 1, 6999, InetAddress.getLocalHost().getAddress(), 0, res, clientGUID, new byte[0], false, false, true, true, false, false, proxies);
    testUP.send(m);
    testUP.flush();
    Thread.sleep(1000);
    assertTrue(callback.getRFD() != null);
    rs.doAsynchronousBrowseHost(callback.getRFD().getHost(), callback.getRFD().getPort(), new GUID(GUID.makeGuid()), new GUID(clientGUID), proxies);
    Socket httpSock = ss.accept();
    assertNotNull(httpSock);
    BufferedWriter sockWriter = new BufferedWriter(new OutputStreamWriter(httpSock.getOutputStream()));
    sockWriter.write("String_Node_Str");
    sockWriter.flush();
    String currLine = null;
    BufferedReader reader = new BufferedReader(new InputStreamReader(httpSock.getInputStream()));
    currLine = reader.readLine();
    assertTrue(currLine.startsWith("String_Node_Str") || currLine.startsWith("String_Node_Str"));
    int beginIndex = currLine.indexOf("String_Node_Str") + 3;
    String guidString = currLine.substring(beginIndex, beginIndex + 26);
    GUID guidFromBackend = new GUID(clientGUID);
    GUID guidFromNetwork = new GUID(Base32.decode(guidString));
    assertEquals(guidFromNetwork, guidFromBackend);
    currLine = reader.readLine();
    assertTrue(currLine.startsWith("String_Node_Str"));
    StringTokenizer st = new StringTokenizer(currLine, "String_Node_Str");
    assertEquals(st.nextToken(), "String_Node_Str");
    InetAddress addr = InetAddress.getByName(st.nextToken().trim());
    Arrays.equals(addr.getAddress(), rs.getAddress());
    assertEquals(Integer.parseInt(st.nextToken()), PORT);
    Socket push = new Socket(InetAddress.getLocalHost(), PORT);
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(push.getOutputStream()));
    writer.write("String_Node_Str" + new GUID(clientGUID).toHexString() + "String_Node_Str");
    writer.write("String_Node_Str");
    writer.flush();
    reader = new BufferedReader(new InputStreamReader(push.getInputStream()));
    currLine = reader.readLine();
    assertTrue(currLine.startsWith("String_Node_Str"));
    currLine = reader.readLine();
    assertTrue(currLine.startsWith("String_Node_Str"));
    st = new StringTokenizer(currLine, "String_Node_Str");
    assertEquals(st.nextToken(), "String_Node_Str");
    addr = InetAddress.getByName(st.nextToken().trim());
    Arrays.equals(addr.getAddress(), rs.getAddress());
    assertEquals(Integer.parseInt(st.nextToken()), PORT);
    Thread.sleep(500);
    writer = new BufferedWriter(new OutputStreamWriter(push.getOutputStream()));
    writer.write("String_Node_Str");
    writer.flush();
    writer.write("String_Node_Str");
    writer.flush();
    httpSock.close();
    try {
        do {
            m = testUP.receive(TIMEOUT);
            assertNotInstanceof(m.toString(), PushRequest.class, m);
        } while (true);
    } catch (InterruptedIOException expected) {
    }
    ss.close();
}

Output:
     byte[] guid = GUID.makeGuid();
-    rs.query(guid, "String_Node_Str");
+    RouterService.query(guid, "String_Node_Str");
     Message m = null;


Input:
public String getDiffAsHtml(TypeLinkProvider linker) throws IOException {
    this.linker = linker;
    start();
    header("String_Node_Str");
    for (String s : sorted(revision.types.keySet())) {
        StructureDefinition orig = original.types.get(s);
        StructureDefinition rev = revision.types.get(s);
        if (orig == null) {
            markNew(rev.getName(), true, false);
        } else if (rev.getKind() == StructureDefinitionKind.PRIMITIVETYPE) {
            markNoChanges(rev.getName(), true);
        } else if (rev.hasDerivation() && orig.hasDerivation() && rev.getDerivation() != orig.getDerivation()) {
            markChanged(rev.getName(), "String_Node_Str" + orig.getDerivation().toCode() + "String_Node_Str" + rev.getDerivation().toCode(), true);
        } else {
            compare(orig, rev);
        }
    }
    for (String s : sorted(original.types.keySet())) {
        StructureDefinition orig = original.types.get(s);
        StructureDefinition rev = revision.types.get(s);
        if (rev == null)
            markDeleted(orig.getName(), true);
    }
    header("String_Node_Str");
    for (String s : sorted(revision.resources.keySet())) {
        StructureDefinition orig = original.resources.get(checkRename(s));
        StructureDefinition rev = revision.resources.get(s);
        if (orig == null) {
            markNew(rev.getName(), true, true);
        } else {
            compare(orig, rev);
        }
    }
    for (String s : sorted(original.resources.keySet())) {
        StructureDefinition orig = original.resources.get(s);
        StructureDefinition rev = revision.resources.get(s);
        if (rev == null)
            markDeleted(orig.getName(), true);
    }
    return new XhtmlComposer().setPretty(true).compose(tbl);
}

Output:
     }
-    return new XhtmlComposer().setPretty(true).compose(tbl);
+    return new XhtmlComposer(false, true).compose(tbl);
 }


Input:
public void onDroneEvent(DroneEventsType event, Drone drone) {
    super.onDroneEvent(event, drone);
    switch(event) {
        case MISSION_UPDATE:
            Length missionLength = missionProxy.getMissionLength();
            Speed speedParameter = drone.getSpeed().getSpeedParameter();
            String infoString = "String_Node_Str" + missionLength;
            if (speedParameter != null) {
                int time = (int) (missionLength.valueInMeters() / speedParameter.valueInMetersPerSecond());
                infoString = infoString + String.format("String_Node_Str", time / 60, time % 60);
            }
            infoView.setText(infoString);
            if (itemDetailFragment != null) {
                if (!missionProxy.contains(itemDetailFragment.getItem())) {
                    removeItemDetail();
                }
            }
            break;
        default:
            break;
    }
}

Output:
             infoView.setText(infoString);
-            if (itemDetailFragment != null) {
-                if (!missionProxy.contains(itemDetailFragment.getItem())) {
-                    removeItemDetail();
-                }
+            if (missionProxy.selection.getSelected().isEmpty() && itemDetailFragment != null) {
+                removeItemDetail();
             }


Input:
private void testFactTableSaveAndLoad1(IDocumentManager documentManager) throws IOException, BirtException {
    Dimension[] dimensions = new Dimension[3];
    ILevelDefn[] levelDefs = new ILevelDefn[1];
    String[] levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension1Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension2Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension3Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[2] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    hierarchy = dimensions[2].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    IDatasetIterator factTableIterator = new LevelsAndFactTableDataset();
    String[] measureColumnName = new String[2];
    measureColumnName[0] = "String_Node_Str";
    measureColumnName[1] = "String_Node_Str";
    FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    assertEquals(factTable.getDimensionInfo()[0].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[0].getDimensionLength(), 3);
    assertEquals(factTable.getDimensionInfo()[1].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[1].getDimensionLength(), 7);
    assertEquals(factTable.getDimensionInfo()[2].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[2].getDimensionLength(), 14);
    assertEquals(factTable.getMeasureInfo()[0].getMeasureName(), "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[0].getDataType(), DataType.INTEGER_TYPE);
    assertEquals(factTable.getMeasureInfo()[1].getMeasureName(), "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[1].getDataType(), DataType.DOUBLE_TYPE);
    String[] dimensionNames = new String[1];
    dimensionNames[0] = "String_Node_Str";
    IDiskArray[] dimensionPosition = new IDiskArray[1];
    dimensionPosition[0] = new BufferedPrimitiveDiskArray();
    dimensionPosition[0].add(new Integer(1));
    dimensionPosition[0].add(new Integer(2));
    FactTableRowIterator facttableRowIterator = new FactTableRowIterator(factTable, dimensionNames, dimensionPosition, new StopSign());
    assertTrue(facttableRowIterator != null);
    assertTrue(facttableRowIterator.next());
    assertEquals(0, facttableRowIterator.getDimensionPosition(0));
    assertEquals(1, facttableRowIterator.getDimensionPosition(1));
    assertEquals(3, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(121), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(121), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(0, facttableRowIterator.getDimensionPosition(0));
    assertEquals(1, facttableRowIterator.getDimensionPosition(1));
    assertEquals(4, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(122), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(122), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(5, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(211), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(211), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(6, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(212), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(212), facttableRowIterator.getMeasure(1));
    assertFalse(facttableRowIterator.next());
}

Output:
     FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
-    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign());
+    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign(), false);
     assertEquals(factTable.getSegmentCount(), 1);


Input:
protected void sendError(MessageInfo mi, RTMPCommand command, Object object, Object information) {
    AMFPacket response = new AMFPacket();
    response.writeString("String_Node_Str");
    response.writeNumber(command.getTxid());
    response.writeMixed(null);
    response.writeMixed(null);
    context.writeCommand(mi.chunkStreamID, response);
}

Output:
     response.writeNumber(command.getTxid());
-    response.writeMixed(null);
-    response.writeMixed(null);
+    response.writeMixed(object);
+    response.writeMixed(information);
     context.writeCommand(mi.chunkStreamID, response);


Input:
public static Set<ModuleNeeded> getCodesModuleNeededs(ERepositoryObjectType type) {
    if (type == null) {
        return getRunningModules();
    }
    Set<ModuleNeeded> codesModules = new HashSet<ModuleNeeded>();
    codesModules.addAll(getModulesNeededForRoutines(type));
    if (type.equals(ERepositoryObjectType.ROUTINES)) {
        codesModules.addAll(collectModuleNeeded(new ArrayList<IRepositoryViewObject>(), new HashSet<String>(), true));
    }
    return codesModules;
}

Output:
     if (type == null) {
-        return getRunningModules();
+        return Collections.emptySet();
     }


Input:
public void loadMedia() {
    mOrderClipsDGV.removeAllViews();
    Media[] sceneMedias = mMPM.mScene.getMediaAsArray();
    for (int i = 0; i < sceneMedias.length; i++) {
        ImageView iv = new ImageView(getActivity());
        if (sceneMedias[i] != null) {
            iv.setImageBitmap(mActivity.getThumbnail(sceneMedias[i]));
        } else {
            iv.setImageDrawable(getResources().getDrawable(R.drawable.thumb_incomplete));
        }
        mOrderClipsDGV.addView(iv);
    }
    mOrderClipsDGV.setOnRearrangeListener(new OnRearrangeListener() {
        public void onRearrange(int oldIndex, int newIndex) {
            mMPM.mScene.moveMedia(oldIndex, newIndex);
        }
    });
    mOrderClipsDGV.setOnItemClickListener(new OnItemClickListener() {
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            if (!mTrimMode) {
                Log.d(TAG, "String_Node_Str");
                mCurrentClipIdx = position;
                previewClip(position);
            }
        }
    });
}

Output:
         if (sceneMedias[i] != null) {
-            iv.setImageBitmap(mActivity.getThumbnail(sceneMedias[i]));
+            Bitmap thumb = Media.getThumbnail(mActivity, sceneMedias[i], mActivity.mMPM.mProject);
+            iv.setImageBitmap(thumb);
         } else {


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    final RelativeLayout widgetView;
    TextView labelTextView;
    TextView valueTextView;
    int widgetLayout;
    String[] splitString;
    OpenHABWidget openHABWidget = getItem(position);
    int screenWidth = ((WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getWidth();
    switch(this.getItemViewType(position)) {
        case TYPE_FRAME:
            widgetLayout = R.layout.openhabwidgetlist_frameitem;
            break;
        case TYPE_GROUP:
            widgetLayout = R.layout.openhabwidgetlist_groupitem;
            break;
        case TYPE_SECTIONSWITCH:
            widgetLayout = R.layout.openhabwidgetlist_sectionswitchitem;
            break;
        case TYPE_SWITCH:
            widgetLayout = R.layout.openhabwidgetlist_switchitem;
            break;
        case TYPE_ROLLERSHUTTER:
            widgetLayout = R.layout.openhabwidgetlist_rollershutteritem;
            break;
        case TYPE_TEXT:
            widgetLayout = R.layout.openhabwidgetlist_textitem;
            break;
        case TYPE_SLIDER:
            widgetLayout = R.layout.openhabwidgetlist_slideritem;
            break;
        case TYPE_IMAGE:
            widgetLayout = R.layout.openhabwidgetlist_imageitem;
            break;
        case TYPE_SELECTION:
            widgetLayout = R.layout.openhabwidgetlist_selectionitem;
            break;
        case TYPE_SETPOINT:
            widgetLayout = R.layout.openhabwidgetlist_setpointitem;
            break;
        case TYPE_CHART:
            widgetLayout = R.layout.openhabwidgetlist_chartitem;
            break;
        case TYPE_VIDEO:
            widgetLayout = R.layout.openhabwidgetlist_videoitem;
            break;
        case TYPE_VIDEO_MJPEG:
            widgetLayout = R.layout.openhabwidgetlist_videomjpegitem;
            break;
        case TYPE_WEB:
            widgetLayout = R.layout.openhabwidgetlist_webitem;
            break;
        case TYPE_COLOR:
            widgetLayout = R.layout.openhabwidgetlist_coloritem;
            break;
        default:
            widgetLayout = R.layout.openhabwidgetlist_genericitem;
            break;
    }
    if (convertView == null) {
        widgetView = new RelativeLayout(getContext());
        String inflater = Context.LAYOUT_INFLATER_SERVICE;
        LayoutInflater vi;
        vi = (LayoutInflater) getContext().getSystemService(inflater);
        vi.inflate(widgetLayout, widgetView, true);
    } else {
        widgetView = (RelativeLayout) convertView;
    }
    Integer iconColor = openHABWidget.getIconColor();
    Integer labelColor = openHABWidget.getLabelColor();
    Integer valueColor = openHABWidget.getValueColor();
    MySmartImageView widgetImage = (MySmartImageView) widgetView.findViewById(R.id.widgetimage);
    if (widgetImage != null) {
        if (openHABWidget.getIcon() != null) {
            String iconUrl = openHABBaseUrl + "String_Node_Str" + Uri.encode(openHABWidget.getIcon() + "String_Node_Str");
            widgetImage.setImageUrl(iconUrl, R.drawable.blank_icon, openHABUsername, openHABPassword);
            if (iconColor != null)
                widgetImage.setColorFilter(iconColor);
            else
                widgetImage.clearColorFilter();
        }
    }
    TextView defaultTextView = new TextView(widgetView.getContext());
    labelTextView = (TextView) widgetView.findViewById(R.id.widgetlabel);
    if (labelColor != null && labelTextView != null) {
        Log.d(TAG, String.format("String_Node_Str", labelColor));
        labelTextView.setTextColor(labelColor);
    } else if (labelTextView != null)
        labelTextView.setTextColor(defaultTextView.getTextColors().getDefaultColor());
    valueTextView = (TextView) widgetView.findViewById(R.id.widgetvalue);
    if (valueColor != null && valueTextView != null) {
        Log.d(TAG, String.format("String_Node_Str", valueColor));
        valueTextView.setTextColor(valueColor);
    } else if (valueTextView != null)
        valueTextView.setTextColor(defaultTextView.getTextColors().getDefaultColor());
    defaultTextView = null;
    switch(getItemViewType(position)) {
        case TYPE_FRAME:
            if (labelTextView != null) {
                labelTextView.setText(openHABWidget.getLabel());
                if (valueColor != null)
                    labelTextView.setTextColor(valueColor);
            }
            widgetView.setClickable(false);
            if (openHABWidget.getLabel().length() > 0) {
                widgetView.setVisibility(View.VISIBLE);
                labelTextView.setVisibility(View.VISIBLE);
            } else {
                widgetView.setVisibility(View.GONE);
                labelTextView.setVisibility(View.GONE);
            }
            break;
        case TYPE_GROUP:
            if (labelTextView != null && valueTextView != null) {
                splitString = openHABWidget.getLabel().split("String_Node_Str");
                labelTextView.setText(splitString[0]);
                if (splitString.length > 1) {
                    valueTextView.setText(splitString[1]);
                } else {
                    valueTextView.setText("String_Node_Str");
                }
            }
            break;
        case TYPE_SECTIONSWITCH:
            splitString = openHABWidget.getLabel().split("String_Node_Str");
            if (labelTextView != null)
                labelTextView.setText(splitString[0]);
            if (splitString.length > 1 && valueTextView != null) {
                valueTextView.setText(splitString[1]);
            } else {
                valueTextView.setText("String_Node_Str");
            }
            RadioGroup sectionSwitchRadioGroup = (RadioGroup) widgetView.findViewById(R.id.sectionswitchradiogroup);
            sectionSwitchRadioGroup.removeAllViews();
            sectionSwitchRadioGroup.setTag(openHABWidget);
            Iterator<OpenHABWidgetMapping> sectionMappingIterator = openHABWidget.getMappings().iterator();
            while (sectionMappingIterator.hasNext()) {
                OpenHABWidgetMapping widgetMapping = sectionMappingIterator.next();
                SegmentedControlButton segmentedControlButton = (SegmentedControlButton) LayoutInflater.from(sectionSwitchRadioGroup.getContext()).inflate(R.layout.openhabwidgetlist_sectionswitchitem_button, sectionSwitchRadioGroup, false);
                segmentedControlButton.setText(widgetMapping.getLabel());
                segmentedControlButton.setTag(widgetMapping.getCommand());
                if (openHABWidget.getItem() != null && widgetMapping.getCommand() != null) {
                    if (widgetMapping.getCommand().equals(openHABWidget.getItem().getState())) {
                        segmentedControlButton.setChecked(true);
                    } else {
                        segmentedControlButton.setChecked(false);
                    }
                } else {
                    segmentedControlButton.setChecked(false);
                }
                segmentedControlButton.setOnClickListener(new OnClickListener() {
                    public void onClick(View view) {
                        Log.i(TAG, "String_Node_Str");
                        RadioGroup group = (RadioGroup) view.getParent();
                        if (group.getTag() != null) {
                            OpenHABWidget radioWidget = (OpenHABWidget) group.getTag();
                            SegmentedControlButton selectedButton = (SegmentedControlButton) view;
                            if (selectedButton.getTag() != null) {
                                sendItemCommand(radioWidget.getItem(), (String) selectedButton.getTag());
                            }
                        }
                    }
                });
                sectionSwitchRadioGroup.addView(segmentedControlButton);
            }
            sectionSwitchRadioGroup.setOnCheckedChangeListener(new OnCheckedChangeListener() {
                public void onCheckedChanged(RadioGroup group, int checkedId) {
                    OpenHABWidget radioWidget = (OpenHABWidget) group.getTag();
                    SegmentedControlButton selectedButton = (SegmentedControlButton) group.findViewById(checkedId);
                    if (selectedButton != null) {
                        Log.d(TAG, "String_Node_Str" + selectedButton.getText());
                        Log.d(TAG, "String_Node_Str" + (String) selectedButton.getTag());
                        sendItemCommand(radioWidget.getItem(), (String) selectedButton.getTag());
                    }
                }
            });
            break;
        case TYPE_SWITCH:
            if (labelTextView != null)
                labelTextView.setText(openHABWidget.getLabel());
            Switch switchSwitch = (Switch) widgetView.findViewById(R.id.switchswitch);
            if (openHABWidget.hasItem()) {
                if (openHABWidget.getItem().getStateAsBoolean()) {
                    switchSwitch.setChecked(true);
                } else {
                    switchSwitch.setChecked(false);
                }
            }
            switchSwitch.setTag(openHABWidget.getItem());
            switchSwitch.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    Switch switchSwitch = (Switch) v;
                    OpenHABItem linkedItem = (OpenHABItem) switchSwitch.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP)
                        if (!switchSwitch.isChecked()) {
                            sendItemCommand(linkedItem, "String_Node_Str");
                        } else {
                            sendItemCommand(linkedItem, "String_Node_Str");
                        }
                    return false;
                }
            });
            break;
        case TYPE_COLOR:
            if (labelTextView != null)
                labelTextView.setText(openHABWidget.getLabel());
            ImageButton colorUpButton = (ImageButton) widgetView.findViewById(R.id.colorbutton_up);
            ImageButton colorDownButton = (ImageButton) widgetView.findViewById(R.id.colorbutton_down);
            ImageButton colorColorButton = (ImageButton) widgetView.findViewById(R.id.colorbutton_color);
            colorUpButton.setTag(openHABWidget.getItem());
            colorDownButton.setTag(openHABWidget.getItem());
            colorColorButton.setTag(openHABWidget.getItem());
            colorUpButton.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    ImageButton colorButton = (ImageButton) v;
                    OpenHABItem colorItem = (OpenHABItem) colorButton.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP)
                        sendItemCommand(colorItem, "String_Node_Str");
                    return false;
                }
            });
            colorDownButton.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    ImageButton colorButton = (ImageButton) v;
                    OpenHABItem colorItem = (OpenHABItem) colorButton.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP)
                        sendItemCommand(colorItem, "String_Node_Str");
                    return false;
                }
            });
            colorColorButton.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    ImageButton colorButton = (ImageButton) v;
                    OpenHABItem colorItem = (OpenHABItem) colorButton.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
                        Log.d(TAG, "String_Node_Str");
                        ColorPickerDialog colorDialog = new ColorPickerDialog(widgetView.getContext(), new OnColorChangedListener() {
                            public void colorChanged(float[] hsv, View v) {
                                Log.d(TAG, "String_Node_Str" + hsv[0] + "String_Node_Str" + hsv[1] + "String_Node_Str" + hsv[2]);
                                String newColor = String.valueOf(hsv[0]) + "String_Node_Str" + String.valueOf(hsv[1] * 100) + "String_Node_Str" + String.valueOf(hsv[2] * 100);
                                OpenHABItem colorItem = (OpenHABItem) v.getTag();
                                sendItemCommand(colorItem, newColor);
                            }
                        }, colorItem.getStateAsHSV());
                        colorDialog.setTag(colorItem);
                        colorDialog.show();
                    }
                    return false;
                }
            });
            break;
        case TYPE_ROLLERSHUTTER:
            if (labelTextView != null)
                labelTextView.setText(openHABWidget.getLabel());
            ImageButton rollershutterUpButton = (ImageButton) widgetView.findViewById(R.id.rollershutterbutton_up);
            ImageButton rollershutterStopButton = (ImageButton) widgetView.findViewById(R.id.rollershutterbutton_stop);
            ImageButton rollershutterDownButton = (ImageButton) widgetView.findViewById(R.id.rollershutterbutton_down);
            rollershutterUpButton.setTag(openHABWidget.getItem());
            rollershutterStopButton.setTag(openHABWidget.getItem());
            rollershutterDownButton.setTag(openHABWidget.getItem());
            rollershutterUpButton.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    ImageButton rollershutterButton = (ImageButton) v;
                    OpenHABItem rollershutterItem = (OpenHABItem) rollershutterButton.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP)
                        sendItemCommand(rollershutterItem, "String_Node_Str");
                    return false;
                }
            });
            rollershutterStopButton.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    ImageButton rollershutterButton = (ImageButton) v;
                    OpenHABItem rollershutterItem = (OpenHABItem) rollershutterButton.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP)
                        sendItemCommand(rollershutterItem, "String_Node_Str");
                    return false;
                }
            });
            rollershutterDownButton.setOnTouchListener(new OnTouchListener() {
                public boolean onTouch(View v, MotionEvent motionEvent) {
                    ImageButton rollershutterButton = (ImageButton) v;
                    OpenHABItem rollershutterItem = (OpenHABItem) rollershutterButton.getTag();
                    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP)
                        sendItemCommand(rollershutterItem, "String_Node_Str");
                    return false;
                }
            });
            break;
        case TYPE_TEXT:
            splitString = openHABWidget.getLabel().split("String_Node_Str");
            if (labelTextView != null)
                if (splitString.length > 0) {
                    labelTextView.setText(splitString[0]);
                } else {
                    labelTextView.setText(openHABWidget.getLabel());
                }
            if (valueTextView != null)
                if (splitString.length > 1) {
                    valueTextView.setVisibility(View.VISIBLE);
                    valueTextView.setText(splitString[1]);
                } else {
                    valueTextView.setVisibility(View.GONE);
                    valueTextView.setText("String_Node_Str");
                }
            break;
        case TYPE_SLIDER:
            splitString = openHABWidget.getLabel().split("String_Node_Str");
            if (labelTextView != null)
                labelTextView.setText(splitString[0]);
            SeekBar sliderSeekBar = (SeekBar) widgetView.findViewById(R.id.sliderseekbar);
            if (openHABWidget.hasItem()) {
                sliderSeekBar.setTag(openHABWidget.getItem());
                int sliderState = 0;
                try {
                    sliderState = (int) Float.parseFloat(openHABWidget.getItem().getState());
                } catch (NumberFormatException e) {
                    if (e != null) {
                        Crittercism.logHandledException(e);
                        Log.e(TAG, e.getMessage());
                    }
                    if (openHABWidget.getItem().getState().equals("String_Node_Str")) {
                        sliderState = 0;
                    } else if (openHABWidget.getItem().getState().equals("String_Node_Str")) {
                        sliderState = 100;
                    }
                }
                sliderSeekBar.setProgress(sliderState);
                sliderSeekBar.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
                    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    }
                    public void onStartTrackingTouch(SeekBar seekBar) {
                        Log.d(TAG, "String_Node_Str" + seekBar.getProgress());
                    }
                    public void onStopTrackingTouch(SeekBar seekBar) {
                        Log.d(TAG, "String_Node_Str" + seekBar.getProgress());
                        OpenHABItem sliderItem = (OpenHABItem) seekBar.getTag();
                        if (sliderItem != null && seekBar != null)
                            sendItemCommand(sliderItem, String.valueOf(seekBar.getProgress()));
                    }
                });
            }
            break;
        case TYPE_IMAGE:
            MySmartImageView imageImage = (MySmartImageView) widgetView.findViewById(R.id.imageimage);
            imageImage.setImageUrl(ensureAbsoluteURL(openHABBaseUrl, openHABWidget.getUrl()), false, openHABUsername, openHABPassword);
            if (openHABWidget.getRefresh() > 0) {
                imageImage.setRefreshRate(openHABWidget.getRefresh());
                refreshImageList.add(imageImage);
            }
            break;
        case TYPE_CHART:
            MySmartImageView chartImage = (MySmartImageView) widgetView.findViewById(R.id.chartimage);
            OpenHABItem chartItem = openHABWidget.getItem();
            Random random = new Random();
            String chartUrl = "String_Node_Str";
            if (chartItem != null) {
                if (chartItem.getType().equals("String_Node_Str")) {
                    chartUrl = openHABBaseUrl + "String_Node_Str" + chartItem.getName() + "String_Node_Str" + openHABWidget.getPeriod() + "String_Node_Str" + String.valueOf(random.nextInt());
                } else {
                    chartUrl = openHABBaseUrl + "String_Node_Str" + chartItem.getName() + "String_Node_Str" + openHABWidget.getPeriod() + "String_Node_Str" + String.valueOf(random.nextInt());
                }
                if (openHABWidget.getService() != null && openHABWidget.getService().length() > 0) {
                    chartUrl += "String_Node_Str" + openHABWidget.getService();
                }
            }
            Log.d(TAG, "String_Node_Str" + chartUrl);
            if (chartImage == null)
                Log.e(TAG, "String_Node_Str");
            chartImage.setImageUrl(chartUrl, false, openHABUsername, openHABPassword);
            ViewGroup.LayoutParams chartLayoutParams = chartImage.getLayoutParams();
            chartLayoutParams.height = (int) (screenWidth / 1.88);
            chartImage.setLayoutParams(chartLayoutParams);
            if (openHABWidget.getRefresh() > 0) {
                chartImage.setRefreshRate(openHABWidget.getRefresh());
                refreshImageList.add(chartImage);
            }
            Log.d(TAG, "String_Node_Str" + chartLayoutParams.width + "String_Node_Str" + chartLayoutParams.height);
            break;
        case TYPE_VIDEO:
            VideoView videoVideo = (VideoView) widgetView.findViewById(R.id.videovideo);
            Log.d(TAG, "String_Node_Str" + openHABWidget.getUrl());
            WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
            ViewGroup.LayoutParams videoLayoutParams = videoVideo.getLayoutParams();
            videoLayoutParams.height = (int) (wm.getDefaultDisplay().getWidth() / 1.77);
            videoVideo.setLayoutParams(videoLayoutParams);
            if (!videoWidgetList.contains(videoVideo))
                videoWidgetList.add(videoVideo);
            if (!videoVideo.isPlaying()) {
                videoVideo.setVideoURI(Uri.parse(openHABWidget.getUrl()));
                videoVideo.start();
            }
            Log.d(TAG, "String_Node_Str" + videoVideo.getHeight());
            break;
        case TYPE_VIDEO_MJPEG:
            Log.d(TAG, "String_Node_Str");
            ImageView mjpegImage = (ImageView) widgetView.findViewById(R.id.mjpegimage);
            MjpegStreamer mjpegStreamer = new MjpegStreamer(openHABWidget.getUrl(), this.openHABUsername, this.openHABPassword, this.getContext());
            mjpegStreamer.setTargetImageView(mjpegImage);
            mjpegStreamer.start();
            if (!mjpegWidgetList.contains(mjpegStreamer))
                mjpegWidgetList.add(mjpegStreamer);
            break;
        case TYPE_WEB:
            WebView webWeb = (WebView) widgetView.findViewById(R.id.webweb);
            if (openHABWidget.getHeight() > 0) {
                ViewGroup.LayoutParams webLayoutParams = webWeb.getLayoutParams();
                webLayoutParams.height = openHABWidget.getHeight() * 80;
                webWeb.setLayoutParams(webLayoutParams);
            }
            webWeb.setWebViewClient(new WebViewClient());
            webWeb.getSettings().setJavaScriptEnabled(true);
            webWeb.loadUrl(openHABWidget.getUrl());
            break;
        case TYPE_SELECTION:
            int spinnerSelectedIndex = -1;
            if (labelTextView != null)
                labelTextView.setText(openHABWidget.getLabel());
            Spinner selectionSpinner = (Spinner) widgetView.findViewById(R.id.selectionspinner);
            ArrayList<String> spinnerArray = new ArrayList<String>();
            Iterator<OpenHABWidgetMapping> mappingIterator = openHABWidget.getMappings().iterator();
            while (mappingIterator.hasNext()) {
                OpenHABWidgetMapping openHABWidgetMapping = mappingIterator.next();
                spinnerArray.add(openHABWidgetMapping.getLabel());
                if (openHABWidgetMapping.getCommand() != null && openHABWidget.getItem() != null)
                    if (openHABWidgetMapping.getCommand().equals(openHABWidget.getItem().getState())) {
                        spinnerSelectedIndex = spinnerArray.size() - 1;
                    }
            }
            ArrayAdapter<String> spinnerAdapter = new ArrayAdapter<String>(this.getContext(), android.R.layout.simple_spinner_item, spinnerArray);
            spinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            selectionSpinner.setAdapter(spinnerAdapter);
            selectionSpinner.setTag(openHABWidget);
            if (spinnerSelectedIndex >= 0)
                selectionSpinner.setSelection(spinnerSelectedIndex);
            selectionSpinner.setOnItemSelectedListener(new OnItemSelectedListener() {
                public void onItemSelected(AdapterView<?> parent, View view, int index, long id) {
                    Log.d(TAG, "String_Node_Str" + index);
                    Spinner spinner = (Spinner) parent;
                    String selectedLabel = (String) spinner.getAdapter().getItem(index);
                    Log.d(TAG, "String_Node_Str" + selectedLabel);
                    OpenHABWidget openHABWidget = (OpenHABWidget) parent.getTag();
                    if (openHABWidget != null) {
                        Log.d(TAG, "String_Node_Str" + openHABWidget.getMapping(index).getLabel());
                        Iterator<OpenHABWidgetMapping> mappingIterator = openHABWidget.getMappings().iterator();
                        while (mappingIterator.hasNext()) {
                            OpenHABWidgetMapping openHABWidgetMapping = mappingIterator.next();
                            if (openHABWidgetMapping.getLabel().equals(selectedLabel)) {
                                Log.d(TAG, "String_Node_Str" + openHABWidgetMapping.getCommand());
                                if (openHABWidget.getItem().getState() != null)
                                    if (!openHABWidget.getItem().getState().equals(openHABWidgetMapping.getCommand())) {
                                        Log.d(TAG, "String_Node_Str");
                                        sendItemCommand(openHABWidget.getItem(), openHABWidgetMapping.getCommand());
                                    }
                            }
                        }
                    }
                }
                public void onNothingSelected(AdapterView<?> arg0) {
                }
            });
            break;
        case TYPE_SETPOINT:
            splitString = openHABWidget.getLabel().split("String_Node_Str");
            if (labelTextView != null)
                labelTextView.setText(splitString[0]);
            if (valueTextView != null)
                if (splitString.length > 1) {
                    valueTextView.setVisibility(View.VISIBLE);
                    valueTextView.setText(splitString[1]);
                }
            Button setPointMinusButton = (Button) widgetView.findViewById(R.id.setpointbutton_minus);
            Button setPointPlusButton = (Button) widgetView.findViewById(R.id.setpointbutton_plus);
            setPointMinusButton.setTag(openHABWidget);
            setPointPlusButton.setTag(openHABWidget);
            setPointMinusButton.setOnClickListener(new OnClickListener() {
                public void onClick(View v) {
                    Log.d(TAG, "String_Node_Str");
                    OpenHABWidget setPointWidget = (OpenHABWidget) v.getTag();
                    float currentValue = Float.valueOf(setPointWidget.getItem().getState()).floatValue();
                    currentValue = currentValue - setPointWidget.getStep();
                    if (currentValue < setPointWidget.getMinValue())
                        currentValue = setPointWidget.getMinValue();
                    if (currentValue > setPointWidget.getMaxValue())
                        currentValue = setPointWidget.getMaxValue();
                    sendItemCommand(setPointWidget.getItem(), String.valueOf(currentValue));
                }
            });
            setPointPlusButton.setOnClickListener(new OnClickListener() {
                public void onClick(View v) {
                    Log.d(TAG, "String_Node_Str");
                    OpenHABWidget setPointWidget = (OpenHABWidget) v.getTag();
                    float currentValue = Float.valueOf(setPointWidget.getItem().getState()).floatValue();
                    currentValue = currentValue + setPointWidget.getStep();
                    if (currentValue < setPointWidget.getMinValue())
                        currentValue = setPointWidget.getMinValue();
                    if (currentValue > setPointWidget.getMaxValue())
                        currentValue = setPointWidget.getMaxValue();
                    sendItemCommand(setPointWidget.getItem(), String.valueOf(currentValue));
                }
            });
            break;
        default:
            if (labelTextView != null)
                labelTextView.setText(openHABWidget.getLabel());
            break;
    }
    LinearLayout dividerLayout = (LinearLayout) widgetView.findViewById(R.id.listdivider);
    if (dividerLayout != null) {
        if (position < this.getCount() - 1) {
            if (this.getItemViewType(position + 1) == TYPE_FRAME) {
                dividerLayout.setVisibility(View.GONE);
            } else {
                dividerLayout.setVisibility(View.VISIBLE);
            }
        } else {
            dividerLayout.setVisibility(View.GONE);
        }
    }
    return widgetView;
}

Output:
             ViewGroup.LayoutParams chartLayoutParams = chartImage.getLayoutParams();
-            chartLayoutParams.height = (int) (screenWidth / 1.88);
+            chartLayoutParams.height = (int) (screenWidth / 2);
             chartImage.setLayoutParams(chartLayoutParams);


Input:
public void tick(TickEvent.WorldTickEvent event) {
    if (event.phase == TickEvent.Phase.END && requests.containsKey(event.world)) {
        HashSet<PipeExtensionRequest> rSet = requests.get(event.world);
        World w = event.world;
        for (PipeExtensionRequest r : rSet) {
            Vec3 target = new Vec3(r.x, r.y, r.z);
            target.orientation = r.o;
            boolean retract = r.stack.getItem() == BuildCraftTransport.pipeItemsVoid;
            ArrayList<ItemStack> removedPipeStacks = null;
            if (retract) {
                target.moveBackwards(1.0D);
            } else {
                target.moveForwards(1.0D);
                if (!w.isAirBlock((int) target.x, (int) target.y, (int) target.z)) {
                    r.h.sendItem(r.stack, r.o.getOpposite());
                    continue;
                }
            }
            Block oldBlock = w.getBlock(r.x, r.y, r.z);
            int oldMeta = w.getBlockMetadata(r.x, r.y, r.z);
            NBTTagCompound nbt = new NBTTagCompound();
            w.getTileEntity(r.x, r.y, r.z).writeToNBT(nbt);
            w.setBlockToAir(r.x, r.y, r.z);
            if (retract) {
                removedPipeStacks = w.getBlock((int) target.x, (int) target.y, (int) target.z).getDrops(w, (int) target.x, (int) target.y, (int) target.z, w.getBlockMetadata((int) target.x, (int) target.y, (int) target.z), 0);
                w.setBlockToAir((int) target.x, (int) target.y, (int) target.z);
            } else {
                r.stack.getItem().onItemUse(r.stack, CoreProxy.proxy.getBuildCraftPlayer((WorldServer) w, r.x, r.y, r.z).get(), w, r.x, r.y, r.z, 1, 0, 0, 0);
            }
            nbt.setInteger("String_Node_Str", (int) target.x);
            nbt.setInteger("String_Node_Str", (int) target.y);
            nbt.setInteger("String_Node_Str", (int) target.z);
            TileGenericPipe pipeTile = (TileGenericPipe) TileEntity.createAndLoadEntity(nbt);
            w.setBlock((int) target.x, (int) target.y, (int) target.z, oldBlock, oldMeta, 3);
            w.setTileEntity((int) target.x, (int) target.y, (int) target.z, pipeTile);
            pipeTile.setWorldObj(w);
            pipeTile.validate();
            pipeTile.updateEntity();
            PipeTransportItems items = (PipeTransportItems) pipeTile.pipe.transport;
            if (!retract) {
                r.stack.stackSize--;
            }
            if (r.stack.stackSize > 0) {
                sendItem(items, r.stack, r.o.getOpposite());
            }
            if (removedPipeStacks != null) {
                for (ItemStack s : removedPipeStacks) {
                    sendItem(items, s, r.o.getOpposite());
                }
            }
            if (!retract) {
                TileGenericPipe newPipeTile = (TileGenericPipe) w.getTileEntity(r.x, r.y, r.z);
                newPipeTile.updateEntity();
                pipeTile.scheduleNeighborChange();
            }
        }
        rSet.clear();
    }
}

Output:
         for (PipeExtensionRequest r : rSet) {
-            Vec3 target = new Vec3(r.x, r.y, r.z);
-            target.orientation = r.o;
+            Vec3 target = Utils.convert(r.pos);
             boolean retract = r.stack.getItem() == BuildCraftTransport.pipeItemsVoid;


Input:
public void takeHeal(byte healAmount, int thisMinionIndex, int thisPlayerIndex, HearthTreeNode<BoardState> boardState, Deck deck) {
    if (health_ < maxHealth_) {
        if (health_ + healAmount > maxHealth_)
            health_ = maxHealth_;
        else
            health_ = (byte) (health_ + healAmount);
        HearthTreeNode<BoardState> toRet = boardState;
        toRet = toRet.data_.getHero_p0().minionHealedEvent(thisPlayerIndex, thisMinionIndex, toRet, deck);
        for (int j = 0; j < toRet.data_.getNumMinions_p0(); ++j) {
            toRet = toRet.data_.getMinion_p0(j).minionHealedEvent(thisPlayerIndex, thisMinionIndex, toRet, deck);
        }
        toRet = toRet.data_.getHero_p1().minionHealedEvent(thisPlayerIndex, thisMinionIndex, toRet, deck);
        for (int j = 0; j < toRet.data_.getNumMinions_p1(); ++j) {
            toRet = toRet.data_.getMinion_p1(j).minionHealedEvent(thisPlayerIndex, thisMinionIndex, toRet, deck);
        }
    }
}

Output:
         HearthTreeNode<BoardState> toRet = boardState;
-        toRet = toRet.data_.getHero_p0().minionHealedEvent(thisPlayerIndex, thisMinionIndex, toRet, deck);
+        toRet = toRet.data_.getHero_p0().minionHealedEvent(0, 0, thisPlayerIndex, thisMinionIndex, toRet, deck);
         for (int j = 0; j < toRet.data_.getNumMinions_p0(); ++j) {


Input:
public void testObjectToXMLEventWriter() throws Exception {
    if (XML_OUTPUT_FACTORY != null) {
        StringWriter writer = new StringWriter();
        XMLOutputFactory factory = XMLOutputFactory.newInstance();
        factory.setProperty(factory.IS_REPAIRING_NAMESPACES, new Boolean(false));
        XMLEventWriter eventWriter = factory.createXMLEventWriter(writer);
        Object objectToWrite = getWriteControlObject();
        XMLDescriptor desc = null;
        if (objectToWrite instanceof XMLRoot) {
            desc = (XMLDescriptor) xmlContext.getSession(0).getProject().getDescriptor(((XMLRoot) objectToWrite).getObject().getClass());
        } else {
            desc = (XMLDescriptor) xmlContext.getSession(0).getProject().getDescriptor(objectToWrite.getClass());
        }
        jaxbMarshaller.setProperty(MarshallerProperties.MEDIA_TYPE, "String_Node_Str");
        int sizeBefore = getNamespaceResolverSize(desc);
        jaxbMarshaller.marshal(objectToWrite, eventWriter);
        eventWriter.flush();
        int sizeAfter = getNamespaceResolverSize(desc);
        assertEquals(sizeBefore, sizeAfter);
        Document testDocument = getTestDocument(writer.toString());
        writer.close();
        objectToXMLDocumentTest(testDocument);
    }
}

Output:
         int sizeBefore = getNamespaceResolverSize(desc);
-        jaxbMarshaller.marshal(objectToWrite, eventWriter);
+        try {
+            jaxbMarshaller.marshal(objectToWrite, eventWriter);
+        } catch (Exception e) {
+            assertMarshalException(e);
+            return;
+        }
         eventWriter.flush();


Input:
public Inventory challengePanel(Player player) {
    List<CPItem> cp = new ArrayList<CPItem>();
    for (String challengeName : challengeList.get("String_Node_Str")) {
        ItemStack icon = null;
        String iconName = plugin.getChallengeConfig().getString("String_Node_Str" + challengeName + "String_Node_Str", "String_Node_Str");
        if (!iconName.isEmpty()) {
            try {
                String[] split = iconName.split("String_Node_Str");
                if (split.length == 1) {
                    if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                        iconName = "String_Node_Str";
                    }
                    icon = new ItemStack(Material.valueOf(iconName));
                } else if (split.length == 2) {
                    icon = new ItemStack(Material.valueOf(split[0]));
                    icon.setDurability(Integer.valueOf(split[1]).shortValue());
                }
            } catch (Exception e) {
                plugin.getLogger().warning("String_Node_Str" + challengeName + "String_Node_Str" + iconName);
                plugin.getLogger().warning("String_Node_Str");
            }
        }
        if (icon == null) {
            icon = new ItemStack(Material.PAPER);
        }
        String description = ChatColor.GREEN + plugin.getChallengeConfig().getString("String_Node_Str" + challengeName + "String_Node_Str", challengeName.substring(0, 1).toUpperCase() + challengeName.substring(1));
        boolean complete = false;
        if (Settings.addCompletedGlow && players.checkChallenge(player.getUniqueId(), challengeName)) {
            ItemMeta im = icon.getItemMeta();
            im.addEnchant(Enchantment.ARROW_DAMAGE, 0, true);
            icon.setItemMeta(im);
            icon.removeEnchantment(Enchantment.ARROW_DAMAGE);
            complete = true;
        }
        boolean repeatable = false;
        if (plugin.getChallengeConfig().getBoolean("String_Node_Str" + challengeName + "String_Node_Str", false)) {
            repeatable = true;
        }
        if (!complete || ((complete && repeatable) || !Settings.removeCompleteOntimeChallenges)) {
            CPItem item = new CPItem(icon, description, Settings.CHALLENGECOMMAND + "String_Node_Str" + challengeName, null);
            List<String> lore = challengeDescription(challengeName, player);
            item.setLore(lore);
            cp.add(item);
        }
    }
    int levelDone = 0;
    for (int i = 0; i < Settings.challengeLevels.size(); i++) {
        if (i == 0) {
            levelDone = 0;
        } else {
            levelDone = checkLevelCompletion(player, Settings.challengeLevels.get(i - 1));
        }
        if (levelDone <= 0) {
            for (String challengeName : challengeList.get(Settings.challengeLevels.get(i))) {
                ItemStack icon = null;
                String iconName = plugin.getChallengeConfig().getString("String_Node_Str" + challengeName + "String_Node_Str", "String_Node_Str");
                if (!iconName.isEmpty()) {
                    try {
                        String[] split = iconName.split("String_Node_Str");
                        if (split.length == 1) {
                            if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
                                iconName = "String_Node_Str";
                            }
                            icon = new ItemStack(Material.valueOf(iconName));
                        } else if (split.length == 2) {
                            icon = new ItemStack(Material.valueOf(split[0]));
                            icon.setDurability(Integer.valueOf(split[1]).shortValue());
                        }
                    } catch (Exception e) {
                        plugin.getLogger().warning("String_Node_Str" + challengeName + "String_Node_Str" + iconName);
                        plugin.getLogger().warning("String_Node_Str");
                    }
                }
                if (icon == null) {
                    icon = new ItemStack(Material.PAPER);
                }
                String description = ChatColor.GREEN + plugin.getChallengeConfig().getString("String_Node_Str" + challengeName + "String_Node_Str", challengeName.substring(0, 1).toUpperCase() + challengeName.substring(1));
                boolean complete = false;
                if (Settings.addCompletedGlow && players.checkChallenge(player.getUniqueId(), challengeName)) {
                    ItemMeta im = icon.getItemMeta();
                    im.addEnchant(Enchantment.ARROW_DAMAGE, 0, true);
                    icon.setItemMeta(im);
                    icon.removeEnchantment(Enchantment.ARROW_DAMAGE);
                    complete = true;
                }
                boolean repeatable = false;
                if (plugin.getChallengeConfig().getBoolean("String_Node_Str" + challengeName + "String_Node_Str", false)) {
                    repeatable = true;
                }
                if (!complete || ((complete && repeatable) || !Settings.removeCompleteOntimeChallenges)) {
                    CPItem item = new CPItem(icon, description, Settings.CHALLENGECOMMAND + "String_Node_Str" + challengeName, null);
                    List<String> lore = challengeDescription(challengeName, player);
                    item.setLore(lore);
                    cp.add(item);
                }
            }
        } else {
            CPItem item = new CPItem(Material.BOOK, ChatColor.GOLD + Settings.challengeLevels.get(i), null, null);
            List<String> lore = new ArrayList<String>();
            lore = chop(ChatColor.WHITE, Locale.challengestoComplete.replace("String_Node_Str", String.valueOf(levelDone)).replace("String_Node_Str", Settings.challengeLevels.get(i - 1)), 25);
            item.setLore(lore);
            cp.add(item);
        }
    }
    if (cp.size() > 0) {
        int size = cp.size() + 8;
        size -= (size % 9);
        Inventory newPanel = Bukkit.createInventory(null, size, Locale.challengesguiTitle);
        playerChallengeGUI.put(player.getUniqueId(), cp);
        for (CPItem i : cp) {
            newPanel.addItem(i.getItem());
        }
        return newPanel;
    }
    return null;
}

Output:
     List<CPItem> cp = new ArrayList<CPItem>();
-    for (String challengeName : challengeList.get("String_Node_Str")) {
-        ItemStack icon = null;
-        String iconName = plugin.getChallengeConfig().getString("String_Node_Str" + challengeName + "String_Node_Str", "String_Node_Str");
-        if (!iconName.isEmpty()) {
-            try {
-                String[] split = iconName.split("String_Node_Str");
-                if (split.length == 1) {
-                    if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
-                    } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
-                        iconName = "String_Node_Str";
+    if (challengeList.containsKey("String_Node_Str")) {
+        for (String challengeName : challengeList.get("String_Node_Str")) {
+            ItemStack icon = null;
+            String iconName = plugin.getChallengeConfig().getString("String_Node_Str" + challengeName + "String_Node_Str", "String_Node_Str");
+            if (!iconName.isEmpty()) {
+                try {
+                    String[] split = iconName.split("String_Node_Str");
+                    if (split.length == 1) {
+                        if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str") || iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        } else if (iconName.equalsIgnoreCase("String_Node_Str")) {
+                            iconName = "String_Node_Str";
+                        }
+                        icon = new ItemStack(Material.valueOf(iconName));
+                    } else if (split.length == 2) {
+                        icon = new ItemStack(Material.valueOf(split[0]));
+                        icon.setDurability(Integer.valueOf(split[1]).shortValue());
                     }


Input:
private void replaceSymbol(NodeTraversal t, Node node, String name, CompilerInput input) {
    Node parent = node.getParent();
    boolean isCrossModule = isCrossModuleName(name);
    if (!isCrossModule) {
        if (!NodeUtil.isNameDeclaration(parent)) {
            return;
        }
        boolean hasInterestingChildren = false;
        for (Node c : parent.children()) {
            if (!c.isName() || isCrossModuleName(c.getString()) || isExternVar(c.getString(), t)) {
                hasInterestingChildren = true;
                break;
            }
        }
        if (!hasInterestingChildren) {
            return;
        }
    }
    Node replacement = isCrossModule ? IR.getprop(IR.name(globalSymbolNamespace).srcref(node), IR.string(name).srcref(node)) : IR.name(name).srcref(node);
    replacement.srcref(node);
    if (node.hasChildren()) {
        Node assign = IR.assign(replacement, node.removeFirstChild());
        parent.replaceChild(node, assign);
        compiler.reportChangeToEnclosingScope(assign);
    } else if (isCrossModule) {
        parent.replaceChild(node, replacement);
        compiler.reportChangeToEnclosingScope(replacement);
        if (parent.isCall() && !maybeReferencesThis.contains(name)) {
            parent.putBooleanProp(Node.FREE_CALL, false);
        }
    }
    if (!isCrossModule && NodeUtil.isNameDeclaration(parent)) {
        preDeclarations.add(new ModuleGlobal(input.getAstRoot(compiler), IR.name(name).srcref(node)));
    }
    compiler.reportChangeToEnclosingScope(parent);
}

Output:
     Node parent = node.getParent();
-    boolean isCrossModule = isCrossModuleName(name);
-    if (!isCrossModule) {
-        if (!NodeUtil.isNameDeclaration(parent)) {
-            return;
-        }
-        boolean hasInterestingChildren = false;
-        for (Node c : parent.children()) {
-            if (!c.isName() || isCrossModuleName(c.getString()) || isExternVar(c.getString(), t)) {
-                hasInterestingChildren = true;
-                break;
-            }
-        }
-        if (!hasInterestingChildren) {
-            return;
-        }
-    }
-    Node replacement = isCrossModule ? IR.getprop(IR.name(globalSymbolNamespace).srcref(node), IR.string(name).srcref(node)) : IR.name(name).srcref(node);
-    replacement.srcref(node);
-    if (node.hasChildren()) {
-        Node assign = IR.assign(replacement, node.removeFirstChild());
-        parent.replaceChild(node, assign);
-        compiler.reportChangeToEnclosingScope(assign);
-    } else if (isCrossModule) {
-        parent.replaceChild(node, replacement);
-        compiler.reportChangeToEnclosingScope(replacement);
-        if (parent.isCall() && !maybeReferencesThis.contains(name)) {
-            parent.putBooleanProp(Node.FREE_CALL, false);
-        }
-    }
-    if (!isCrossModule && NodeUtil.isNameDeclaration(parent)) {
-        preDeclarations.add(new ModuleGlobal(input.getAstRoot(compiler), IR.name(name).srcref(node)));
+    Node replacement = IR.getprop(IR.name(globalSymbolNamespace), IR.string(name));
+    replacement.useSourceInfoFromForTree(node);
+    parent.replaceChild(node, replacement);
+    compiler.reportChangeToEnclosingScope(replacement);
+    if (parent.isCall() && !maybeReferencesThis.contains(name)) {
+        parent.putBooleanProp(Node.FREE_CALL, false);
     }


Input:
public List evaluateList(Evaluator evaluator) {
    final Member member0 = memberCalc0.evaluateMember(evaluator);
    final Member member1 = memberCalc1.evaluateMember(evaluator);
    if (member0.isNull() || member1.isNull()) {
        return Collections.EMPTY_LIST;
    }
    if (member0.getLevel() != member1.getLevel()) {
        throw evaluator.newEvalException(call.getFunDef(), "String_Node_Str");
    }
    return FunUtil.memberRange(evaluator, member0, member1);
}

Output:
 public List evaluateList(Evaluator evaluator) {
-    final Member member0 = memberCalc0.evaluateMember(evaluator);
-    final Member member1 = memberCalc1.evaluateMember(evaluator);
+    final Member member0 = memberCalcs[0].evaluateMember(evaluator);
+    final Member member1 = memberCalcs[1].evaluateMember(evaluator);
     if (member0.isNull() || member1.isNull()) {


Input:
static SelectQuery composeUnionQuery(SelectQuery rightQuery, BaseTable leftBase, BaseTable rightBase) {
    List<SelectItem> allItems = new ArrayList<>();
    List<String> groupAliasNames = new ArrayList<>();
    for (SelectItem item : rightQuery.getSelectList()) {
        if (item.isAggregateColumn()) {
            if (!(item instanceof AliasedColumn) || !(((AliasedColumn) item).getColumn() instanceof ColumnOp)) {
                continue;
            }
            ColumnOp column = (ColumnOp) ((AliasedColumn) item).getColumn();
            if (column.getOpType().equals("String_Node_Str") || column.getOpType().equals("String_Node_Str")) {
                AliasedColumn newColumn = new AliasedColumn(new ColumnOp(column.getOpType(), new BaseColumn(unionTableAlias, ((AliasedColumn) item).getAliasName())), ((AliasedColumn) item).getAliasName());
                allItems.add(newColumn);
            } else {
                AliasedColumn newColumn = new AliasedColumn(ColumnOp.sum(new BaseColumn(unionTableAlias, ((AliasedColumn) item).getAliasName())), ((AliasedColumn) item).getAliasName());
                allItems.add(newColumn);
            }
        } else {
            allItems.add(new AliasedColumn(new BaseColumn(unionTableAlias, ((AliasedColumn) item).getAliasName()), ((AliasedColumn) item).getAliasName()));
            groupAliasNames.add(((AliasedColumn) item).getAliasName());
        }
    }
    SelectQuery left = SelectQuery.create(new AsteriskColumn(), leftBase);
    SelectQuery right = SelectQuery.create(new AsteriskColumn(), rightBase);
    SetOperationRelation newBase = new SetOperationRelation(right, left, SetOperationRelation.SetOpType.unionAll);
    newBase.setAliasName(unionTableAlias);
    SelectQuery unionQuery = SelectQuery.create(allItems, newBase);
    for (String a : groupAliasNames) {
        unionQuery.addGroupby(new AliasReference(a));
    }
    return unionQuery;
}

Output:
     List<SelectItem> allItems = new ArrayList<>();
-    List<String> groupAliasNames = new ArrayList<>();
+    List<GroupingAttribute> groupingAttributes = new ArrayList<>();
     for (SelectItem item : rightQuery.getSelectList()) {


Input:
protected void executeImpl(final Action action, final NodeRef actionedUponNodeRef) {
    if (nodeService.exists(actionedUponNodeRef) && recordService.isRecord(actionedUponNodeRef) && freezeService.isFrozen(actionedUponNodeRef) == false) {
        if (recordService.isDeclared(actionedUponNodeRef) == false) {
            List<String> missingProperties = new ArrayList<String>(5);
            if (mandatoryPropertiesSet(actionedUponNodeRef, missingProperties)) {
                recordService.disablePropertyEditableCheck();
                try {
                    Map<QName, Serializable> declaredProps = new HashMap<QName, Serializable>(2);
                    declaredProps.put(PROP_DECLARED_AT, new Date());
                    declaredProps.put(PROP_DECLARED_BY, AuthenticationUtil.getRunAsUser());
                    this.nodeService.addAspect(actionedUponNodeRef, ASPECT_DECLARED_RECORD, declaredProps);
                    AuthenticationUtil.runAsSystem(new RunAsWork<Void>() {
                        public Void doWork() throws Exception {
                            ownableService.setOwner(actionedUponNodeRef, OwnableService.NO_OWNER);
                            return null;
                        }
                    });
                } finally {
                    recordService.enablePropertyEditableCheck();
                }
            } else {
                logger.debug(buildMissingPropertiesErrorString(missingProperties));
                action.setParameterValue(ActionExecuterAbstractBase.PARAM_RESULT, "String_Node_Str");
            }
        }
    } else {
        if (logger.isWarnEnabled()) {
            logger.warn(I18NUtil.getMessage(MSG_UNDECLARED_ONLY_RECORDS, actionedUponNodeRef.toString()));
        }
    }
}

Output:
 protected void executeImpl(final Action action, final NodeRef actionedUponNodeRef) {
-    if (nodeService.exists(actionedUponNodeRef) && recordService.isRecord(actionedUponNodeRef) && freezeService.isFrozen(actionedUponNodeRef) == false) {
-        if (recordService.isDeclared(actionedUponNodeRef) == false) {
+    if (nodeService.exists(actionedUponNodeRef) && recordService.isRecord(actionedUponNodeRef) && !freezeService.isFrozen(actionedUponNodeRef)) {
+        if (!recordService.isDeclared(actionedUponNodeRef)) {
             List<String> missingProperties = new ArrayList<String>(5);


Input:
public static TernaryExpression makeTernary(ExpressionType ternaryType, Expression e0, Expression e1, Expression e2) {
    final Type type = e1.getType();
    return new TernaryExpression(ternaryType, type, e0, e1, e2);
}

Output:
 public static TernaryExpression makeTernary(ExpressionType ternaryType, Expression e0, Expression e1, Expression e2) {
-    final Type type = e1.getType();
+    final Type type;
+    switch(ternaryType) {
+        case Conditional:
+            type = isConstantNull(e1) ? box(e2.getType()) : isConstantNull(e2) ? box(e1.getType()) : Types.gcd(e1.getType(), e2.getType());
+            break;
+        default:
+            type = e1.getType();
+    }
     return new TernaryExpression(ternaryType, type, e0, e1, e2);


Input:
protected boolean needPagedExecutor(List<long[]> pageSequences) {
    if (ExtensionManager.PAPER_SIZE_PAGINATION.equals(pagination)) {
        if (pageSequences == null) {
            return false;
        }
        if (pageSequences != null && pageSequences.size() == 1) {
            long[] pages = pageSequences.get(0);
            if (pages[0] == 1) {
                return false;
            }
        }
        return true;
    }
    int pageCount = getPageCount();
    if (pageCount == 1) {
        return true;
    }
    IRenderOption renderOption = executionContext.getRenderOption();
    HTMLRenderOption htmlRenderOption = new HTMLRenderOption(renderOption);
    boolean htmlPagination = htmlRenderOption.getHtmlPagination();
    if (!htmlPagination) {
        return false;
    }
    return true;
}

Output:
             long[] pages = pageSequences.get(0);
-            if (pages[0] == 1) {
+            if (pages[0] == 1 && pages[1] == reportDocument.getPageCount()) {
                 return false;


Input:
public ClusterReport queryClusterStatus(ClusterBlueprint blueprint) {
    AmClusterDef clusterDef = new AmClusterDef(blueprint, privateKey);
    try {
        ServiceStatus status = apiManager.getClusterStatus(blueprint.getName());
        clusterDef.getCurrentReport().setStatus(status);
        Map<String, ServiceStatus> hostStates = apiManager.getHostStatus(blueprint.getName());
        Map<String, NodeReport> nodeReports = clusterDef.getCurrentReport().getNodeReports();
        for (AmNodeDef node : clusterDef.getNodes()) {
            String fqdn = node.getFqdn();
            nodeReports.get(node.getName()).setStatus(hostStates.get(fqdn));
        }
    } catch (NotFoundException e) {
        logger.info("String_Node_Str" + blueprint.getName() + "String_Node_Str");
        return null;
    }
    return clusterDef.getCurrentReport().clone();
}

Output:
     try {
-        ServiceStatus status = apiManager.getClusterStatus(blueprint.getName());
+        ServiceStatus status = apiManager.getClusterStatus(blueprint.getName(), blueprint.getHadoopStack());
         clusterDef.getCurrentReport().setStatus(status);


Input:
public List checkCompatibility() {
    {
        ExtendedItemHandle exhandle = (ExtendedItemHandle) getModelHandle();
        Map illegalContents = exhandle.getIllegalContents();
        if (illegalContents.containsKey(IMeasureViewConstants.DETAIL_PROP)) {
            List detailInfoList = (List) illegalContents.get(IMeasureViewConstants.DETAIL_PROP);
            if (detailInfoList.size() > 0) {
                IllegalContentInfo detailInfo = (IllegalContentInfo) detailInfoList.get(0);
                ExtendedItemHandle oldDetail = (ExtendedItemHandle) detailInfo.getContent();
                if (oldDetail != null) {
                    try {
                        ExtendedItemHandle newDetail = CrosstabExtendedItemFactory.createAggregationCell(getModuleHandle());
                        handle.getPropertyHandle(DETAIL_PROP).setValue(newDetail);
                        List contents = oldDetail.getContents(ICrosstabCellConstants.CONTENT_PROP);
                        for (int i = 0; i < contents.size(); i++) {
                            ((DesignElementHandle) contents.get(i)).moveTo(newDetail, IAggregationCellConstants.CONTENT_PROP);
                        }
                    } catch (SemanticException e) {
                        List errorList = new ArrayList(1);
                        errorList.add(e);
                        return errorList;
                    }
                }
            }
        }
    }
    return Collections.EMPTY_LIST;
}

Output:
                         errorList.add(e);
-                        return errorList;
+                        status.setErrors(errorList);
                     }


Input:
public void removeComponent(HUDComponent component) {
    component.removeEventListener(this);
    components.remove(component);
    HUDObjectChanged(new HUDEvent(component, HUDEventType.REMOVED, new Date()));
}

Output:
 public void removeComponent(HUDComponent component) {
-    component.removeEventListener(this);
-    components.remove(component);
-    HUDObjectChanged(new HUDEvent(component, HUDEventType.REMOVED, new Date()));
+    if (component != null) {
+        component.removeEventListener(this);
+        components.remove(component);
+        HUDObjectChanged(new HUDEvent(component, HUDEventType.REMOVED, new Date()));
+    }
 }