Input:
private static String create(Class<?> cls, Object target) {
    final String name = tryGetName(cls, target);
    return Strings.isNullOrEmpty(name) ? "String_Node_Str" : name.replaceAll("String_Node_Str", "String_Node_Str").toLowerCase();
}

Output:
     final String name = tryGetName(cls, target);
-    return Strings.isNullOrEmpty(name) ? "String_Node_Str" : name.replaceAll("String_Node_Str", "String_Node_Str").toLowerCase();
+    return Strings.isNullOrEmpty(name) ? "String_Node_Str" : name.replaceAll("String_Node_Str", "String_Node_Str").toLowerCase(Locale.ENGLISH);
 }


Input:
public final boolean equals(final Object object) {
    if (object == null || object.getClass() != getClass()) {
        return false;
    }
    final ResourceInternationalString that = (ResourceInternationalString) object;
    return (key == that.key) && (hasArguments == that.hasArguments) && Objects.equals(arguments, that.arguments);
}

Output:
     final ResourceInternationalString that = (ResourceInternationalString) object;
-    return (key == that.key) && (hasArguments == that.hasArguments) && Objects.equals(arguments, that.arguments);
+    return (key == that.key) && (hasArguments == that.hasArguments) && Objects.deepEquals(arguments, that.arguments);
 }


Input:
protected void onSuccess() {
    synchronized (StreamConnsMgr.this) {
        removePendingConn(sid, nid);
    }
    ControlConnection cc = mina.getCCM().getCCWithId(nid);
    if (cc == null) {
        onFail();
        return;
    }
    log.info("String_Node_Str" + cc.getNodeId() + "String_Node_Str" + sid);
    startListeningTo(cc, sid, sourceStat);
}

Output:
     log.info("String_Node_Str" + cc.getNodeId() + "String_Node_Str" + sid);
-    startListeningTo(cc, sid, sourceStat);
+    try {
+        startListeningTo(cc, sid, sourceStat);
+    } catch (IOException e) {
+        log.error("String_Node_Str" + cc.getNodeId() + "String_Node_Str" + sid, e);
+        onFail();
+    }
 }


Input:
public static boolean hasSkyLight(World world) {
    return world.provider.hasSkylight();
}

Output:
 public static boolean hasSkyLight(World world) {
-    return world.provider.hasSkylight();
+    return world.provider.hasSkyLight();
 }


Input:
public PresenceStatus getLastPresenceStatus(ProtocolProviderService protocolProvider) {
    String lastStatus = getLastStatusString(protocolProvider);
    OperationSetPresence presence = (OperationSetPresence) protocolProvider.getOperationSet(OperationSetPresence.class);
    if (presence == null)
        return null;
    Iterator<PresenceStatus> i = presence.getSupportedStatusSet();
    if (lastStatus != null) {
        PresenceStatus status;
        while (i.hasNext()) {
            status = i.next();
            if (status.getStatusName().equals(lastStatus)) {
                return status;
            }
        }
    }
    return null;
}

Output:
             status = i.next();
-            if (status.getStatusName().equals(lastStatus)) {
+            if (status.getStatusName().equals(lastStatus))
                 return status;


Input:
Object sendRPCRequest(final InetSocketAddress remoteSocketAddress, final RPCRequest request) throws Throwable {
    if (this.shutdownRequested.get()) {
        throw new IOException("String_Node_Str");
    }
    DatagramPacket[] packets = messageToPackets(remoteSocketAddress, request);
    final Integer messageID = Integer.valueOf(request.getMessageID());
    final RPCRequestMonitor requestMonitor = new RPCRequestMonitor();
    this.pendingRequests.put(messageID, requestMonitor);
    for (int i = 0; i < RETRY_LIMIT; ++i) {
        sendPackets(packets);
        RPCResponse rpcResponse;
        try {
            synchronized (requestMonitor) {
                if (requestMonitor.rpcResponse == null) {
                    requestMonitor.wait(this.statistics.calculateTimeout(packets.length, i));
                }
                rpcResponse = requestMonitor.rpcResponse;
            }
        } catch (InterruptedException ie) {
            Log.debug("String_Node_Str", ie);
            return null;
        }
        if (rpcResponse == null) {
            Log.debug("String_Node_Str" + request.getMessageID());
            continue;
        }
        this.pendingRequests.remove(messageID);
        this.statistics.reportSuccessfulCall(request.getMethodName(), packets.length, i);
        packets = messageToPackets(remoteSocketAddress, new RPCCleanup(request.getMessageID()));
        sendPackets(packets);
        if (rpcResponse instanceof RPCReturnValue) {
            return ((RPCReturnValue) rpcResponse).getRetVal();
        }
        throw ((RPCThrowable) rpcResponse).getThrowable();
    }
    this.pendingRequests.remove(messageID);
    throw new IOException("String_Node_Str" + request.getMethodName() + "String_Node_Str" + remoteSocketAddress);
}

Output:
         this.statistics.reportSuccessfulCall(request.getMethodName(), packets.length, i);
-        packets = messageToPackets(remoteSocketAddress, new RPCCleanup(request.getMessageID()));
-        sendPackets(packets);
+        if (i == 0) {
+            packets = messageToPackets(remoteSocketAddress, new RPCCleanup(request.getMessageID()));
+            sendPackets(packets);
+        }
         if (rpcResponse instanceof RPCReturnValue) {


Input:
protected void fillContextMenu(IMenuManager manager, boolean isType) {
    IStructuredSelection selection;
    if (!isType)
        selection = ((IStructuredSelection) viewer.getSelection());
    else
        selection = ((IStructuredSelection) typesViewer.getSelection());
    Object[] selectedObjs = selection.toArray();
    Object obj = selection.getFirstElement();
    if (!isType)
        manager.add(new XSDNewConceptAction(this));
    else {
        manager.add(newComplexTypeAction);
        manager.add(newSimpleTypeAction);
        XSDDeleteTypeDefinition deleteTypeDefinition1;
        if (selectedObjs.length > 1)
            deleteTypeDefinition1 = new XSDDeleteTypeDefinition(this, true);
        else
            deleteTypeDefinition1 = new XSDDeleteTypeDefinition(this, false);
        if (selectedObjs.length >= 1 && deleteTypeDefinition1.isTypeDefinition(selectedObjs))
            manager.add(deleteTypeDefinition1);
        deleteConceptWrapAction.regisExtraClassToDel(XSDComplexTypeDefinitionImpl.class);
        if (selectedObjs.length > 1 && deleteConceptWrapAction.checkInDeletableType(selectedObjs)) {
            deleteConceptWrapAction.prepareToDelSelectedItems(selection, viewer);
        }
        if (selectedObjs.length > 1 && deleteConceptWrapAction.outPutDeleteActions() != null) {
            manager.add(deleteConceptWrapAction.outPutDeleteActions());
            if (deleteConceptWrapAction.checkOutAllConcept(selectedObjs))
                manager.add(newBrowseItemAction);
        }
    }
    manager.add(new Separator());
    if ((selection == null) || (selection.getFirstElement() == null)) {
        manager.add(new Separator(ADDITIONMENUID));
        String title = "String_Node_Str";
        if (WorkbenchClipboard.getWorkbenchClipboard().getConcepts().size() == 1)
            title = "String_Node_Str";
        else if (WorkbenchClipboard.getWorkbenchClipboard().getConcepts().size() > 1)
            title = "String_Node_Str";
        XSDPasteConceptAction pasteConceptAction = new XSDPasteConceptAction(this, title);
        if (pasteConceptAction.checkInPasteType()) {
            manager.add(new Separator());
            manager.add(pasteConceptAction);
        }
        return;
    }
    if (obj instanceof XSDElementDeclaration && selectedObjs.length == 1) {
        XSDElementDeclaration decl = (XSDElementDeclaration) obj;
        boolean isConcept = Util.checkConcept(decl);
        if (!Util.IsAImporedElement(decl, xsdSchema)) {
            if (isConcept) {
                manager.add(editConceptAction);
                manager.add(deleteConceptAction);
                manager.add(newBrowseItemAction);
            } else {
                manager.add(editElementAction);
                manager.add(deleteElementAction);
            }
            XSDCopyConceptAction copyConceptAction = new XSDCopyConceptAction(this, "String_Node_Str");
            if (Util.checkInCopy(selectedObjs)) {
                manager.add(new Separator());
                manager.add(copyConceptAction);
            }
            String title = "String_Node_Str";
            if (WorkbenchClipboard.getWorkbenchClipboard().getConcepts().size() > 1)
                title = "String_Node_Str";
            else if (WorkbenchClipboard.getWorkbenchClipboard().getConcepts().size() == 1)
                title = "String_Node_Str";
            else if (WorkbenchClipboard.getWorkbenchClipboard().getParticles().size() > 1)
                title = "String_Node_Str";
            else if (WorkbenchClipboard.getWorkbenchClipboard().getParticles().size() == 1)
                title = "String_Node_Str";
            XSDPasteConceptAction pasteConceptAction = new XSDPasteConceptAction(this, title);
            if (pasteConceptAction.checkInPasteType())
                manager.add(pasteConceptAction);
            manager.add(new Separator());
            manager.add(newElementAction);
            manager.add(new Separator());
            manager.add(changeToComplexTypeAction);
            manager.add(changeToSimpleTypeAction);
            if (((XSDElementDeclaration) obj).getTypeDefinition() instanceof XSDSimpleTypeDefinition) {
                manager.add(setFacetMsgAction);
                manager.add(setAnnotationDisplayFomatAction);
            }
            manager.add(new Separator());
            manager.add(newIdentityConstraintAction);
        } else {
            if (isConcept) {
                manager.add(newBrowseItemAction);
            }
            manager.add(newElementAction);
        }
        if (!Util.IsAImporedElement(decl, xsdSchema) || !Util.IsAImporedElement(decl.getTypeDefinition(), xsdSchema))
            setAnnotationActions2(obj, manager);
    }
    if (obj instanceof XSDModelGroup) {
        manager.add(new Separator());
        manager.add(newParticleFromTypeAction);
        manager.add(new Separator());
        manager.add(changeSubElementGroupAction);
    }
    if (obj instanceof XSDParticle && selectedObjs.length == 1) {
        XSDTerm term = ((XSDParticle) obj).getTerm();
        if (!(term instanceof XSDWildcard)) {
            if (term instanceof XSDElementDeclaration) {
                manager.add(editParticleAction);
                if (!Util.IsAImporedElement(term, xsdSchema) || term.getContainer() instanceof XSDSchema) {
                    manager.add(newParticleFromParticleAction);
                    if (term instanceof XSDModelGroup) {
                        manager.add(newParticleFromTypeAction);
                        manager.add(newGroupFromTypeAction);
                    }
                    manager.add(deleteParticleAction);
                    XSDCopyConceptAction copyConceptAction = new XSDCopyConceptAction(this, "String_Node_Str");
                    manager.add(copyConceptAction);
                    manager.add(new Separator());
                    manager.add(changeToComplexTypeAction);
                    manager.add(changeToSimpleTypeAction);
                    manager.add(new Separator());
                    if (term instanceof XSDElementDeclaration) {
                        XSDTypeDefinition type = ((XSDElementDeclaration) term).getTypeDefinition();
                        setAnnotationActions(obj, manager);
                        if (((XSDElementDeclaration) term).getTypeDefinition() instanceof XSDSimpleTypeDefinition) {
                            manager.add(setFacetMsgAction);
                            manager.add(setAnnotationDisplayFomatAction);
                        }
                        manager.add(new Separator());
                        manager.add(getXPathAction);
                    }
                }
            }
        }
    }
    if (obj instanceof XSDComplexTypeDefinition && selectedObjs.length == 1 && ((XSDComplexTypeDefinition) obj).getTargetNamespace() == null) {
        if (!isType && !Util.IsAImporedElement((XSDParticle) obj, xsdSchema)) {
            manager.add(newParticleFromTypeAction);
            manager.add(newGroupFromTypeAction);
        }
        String ns = ((XSDComplexTypeDefinition) obj).getTargetNamespace();
        if (ns == null && !Util.IsAImporedElement((XSDComplexTypeDefinition) obj, xsdSchema)) {
            manager.add(new Separator());
            manager.add(newParticleFromTypeAction);
            manager.add(new Separator());
            manager.add(editComplexTypeAction);
        }
    }
    if (obj instanceof XSDIdentityConstraintDefinition && selectedObjs.length == 1 && ((XSDIdentityConstraintDefinition) obj).getTargetNamespace() == null && !Util.IsAImporedElement((XSDIdentityConstraintDefinition) obj, xsdSchema)) {
        manager.add(editIdentityConstraintAction);
        manager.add(deleteIdentityConstraintAction);
        manager.add(newIdentityConstraintAction);
        manager.add(new Separator());
        manager.add(newXPathAction);
    }
    if (obj instanceof XSDXPathDefinition && selectedObjs.length == 1 && ((XSDXPathDefinition) obj).getSchema().getTargetNamespace() == null && !Util.IsAImporedElement((XSDXPathDefinition) obj, xsdSchema)) {
        manager.add(editXPathAction);
        manager.add(newXPathAction);
        XSDXPathDefinition xpath = (XSDXPathDefinition) obj;
        if (xpath.getVariety().equals(XSDXPathVariety.FIELD_LITERAL))
            manager.add(deleteXPathAction);
    }
    if (obj instanceof XSDSimpleTypeDefinition && selectedObjs.length == 1 && (!Util.IsAImporedElement((XSDSimpleTypeDefinition) obj, xsdSchema) || ((XSDSimpleTypeDefinition) obj).getName() == null)) {
        XSDSimpleTypeDefinition typedef = (XSDSimpleTypeDefinition) obj;
        manager.add(changeBaseTypeAction);
        manager.add(new Separator());
        EList list = typedef.getBaseTypeDefinition().getValidFacets();
        for (Iterator iter = list.iterator(); iter.hasNext(); ) {
            String element = (String) iter.next();
            manager.add(new XSDEditFacetAction(this, element));
        }
    }
    if (selectedObjs.length > 1 && deleteConceptWrapAction.checkInDeletableType(selectedObjs)) {
        deleteConceptWrapAction.prepareToDelSelectedItems(selection, viewer);
    }
    if (selectedObjs.length > 1 && deleteConceptWrapAction.checkInAllElementType(selectedObjs)) {
        manager.add(newBrowseItemAction);
    }
    if (selectedObjs.length > 1 && deleteConceptWrapAction.outPutDeleteActions() != null) {
        if (!isType)
            manager.add(deleteConceptWrapAction.outPutDeleteActions());
        String title = "String_Node_Str";
        if (Util.checkInCopyTypeElement(selectedObjs))
            title = "String_Node_Str";
        else if (Util.checkInCOpyTypeParticle(selectedObjs))
            title = "String_Node_Str";
        XSDCopyConceptAction copyConceptAction = new XSDCopyConceptAction(this, title);
        if (Util.checkInCopy(selectedObjs)) {
            manager.add(copyConceptAction);
        }
        if (selectedObjs.length > 1 && isXSDParticles(selectedObjs)) {
            manager.add(newParticleFromParticleAction);
        }
    }
    if (Util.IsEnterPrise()) {
        if (selectedObjs.length > 1 && setAnnotationWrapWriteAction.checkInWriteType(selectedObjs)) {
            manager.add(new Separator());
            manager.add(setAnnotationWrapWriteAction);
            manager.add(setAnnotationWrapNoAction);
        }
    }
    java.util.List<IAvailableModel> availablemodels = AvailableModelUtil.getAvailableModels();
    for (int i = 0; i < availablemodels.size(); i++) {
        IAvailableModel model = availablemodels.get(i);
        model.fillContextMenu(obj, manager, this, dataModelName);
        if (i == 0) {
            manager.add(new Separator());
        }
    }
    manager.add(new Separator());
    drillDownAdapter.addNavigationActions(manager);
    manager.add(new Separator(ADDITIONMENUID));
    deleteConceptWrapAction.clearExtraClassToDel();
}

Output:
         model.fillContextMenu(obj, manager, this, dataModelName);
-        if (i == 0) {
+        if (i == 1) {
             manager.add(new Separator());


Input:
private void addParticleDetail(XSDSchema xsdSchema, XSDParticle xsdParticle, ATreeNode parentNode, String currentPath) throws OdaException, IllegalAccessException, InvocationTargetException {
    XSDTerm xsdTerm = xsdParticle.getTerm();
    if (xsdTerm instanceof XSDElementDeclaration) {
        XSDElementDeclaration xsdElementDeclarationParticle = (XSDElementDeclaration) xsdTerm;
        if (particleToTreeNode.containsKey(xsdElementDeclarationParticle)) {
            ATreeNode originalTreeNode = particleToTreeNode.get(xsdElementDeclarationParticle);
            ATreeNode partNode = new ATreeNode();
            partNode.setCurrentNamespace(originalTreeNode.getCurrentNamespace());
            partNode.setValue(originalTreeNode.getValue());
            partNode.setType(ATreeNode.ELEMENT_TYPE);
            partNode.setDataType(originalTreeNode.getDataType());
            partNode.addChild(originalTreeNode.getChildren());
            parentNode.addChild(partNode);
            return;
        }
        ATreeNode partNode = new ATreeNode();
        particleToTreeNode.put(xsdElementDeclarationParticle, partNode);
        String elementName = xsdElementDeclarationParticle.getName();
        String prefix = null;
        String namespace = xsdElementDeclarationParticle.getTargetNamespace();
        XSDTypeDefinition typeDef = xsdElementDeclarationParticle.getTypeDefinition();
        if (typeDef == null) {
            XSDSchema schemaFromNamespace = getXSDSchemaFromNamespace(namespace);
            if (schemaFromNamespace == null) {
                schemaFromNamespace = xsdSchema;
            }
            xsdElementDeclarationParticle = schemaFromNamespace.resolveElementDeclarationURI(xsdElementDeclarationParticle.getURI());
            typeDef = xsdElementDeclarationParticle.getTypeDefinition();
        }
        String typeNamespace = typeDef.getTargetNamespace();
        if (typeNamespace != null && !typeNamespace.equals(namespace)) {
            XSDSchema schemaOfType = getXSDSchemaFromNamespace(typeNamespace);
            if (schemaOfType != null) {
                XSDTypeDefinition typeDefinition = schemaOfType.resolveComplexTypeDefinitionURI(typeDef.getURI());
                if (typeDefinition != null && typeDefinition.getContainer() != null) {
                    typeDef = typeDefinition;
                }
            }
        }
        if (namespace != null) {
            prefix = namespaceToPrefix.get(namespace);
            if (prefix == null) {
                prefix = ((XSDElementDeclaration) xsdTerm).getQName().contains("String_Node_Str") ? ((XSDElementDeclaration) xsdTerm).getQName().split("String_Node_Str")[0] : "String_Node_Str";
                if (isEnableGeneratePrefix() && (prefix == null || prefix.isEmpty())) {
                    prefix = "String_Node_Str" + prefixNumberGenerated;
                    prefixNumberGenerated++;
                }
                if (namespaceToPrefix.containsValue(prefix)) {
                    prefix = prefix + prefixNumberGenerated;
                    prefixNumberGenerated++;
                }
                if (prefix != null && !prefix.isEmpty()) {
                    namespaceToPrefix.put(namespace, prefix);
                } else {
                    ATreeNode namespaceNode = new ATreeNode();
                    namespaceNode.setDataType("String_Node_Str");
                    namespaceNode.setType(ATreeNode.NAMESPACE_TYPE);
                    namespaceNode.setValue(namespace);
                    partNode.addChild(namespaceNode);
                }
            }
        }
        partNode.setCurrentNamespace(namespace);
        if (prefix != null && !prefix.isEmpty()) {
            elementName = prefix + "String_Node_Str" + elementName;
        }
        partNode.setValue(elementName);
        partNode.setType(ATreeNode.ELEMENT_TYPE);
        partNode.setDataType(xsdElementDeclarationParticle.getName());
        parentNode.addChild(partNode);
        boolean resolvedAsComplex = false;
        if (typeDef instanceof XSDComplexTypeDefinition) {
            if (!currentPath.contains("String_Node_Str" + elementName + "String_Node_Str")) {
                String path = currentPath + elementName + "String_Node_Str";
                XSDTypeDefinition xsdTypeDefinition = typeDef;
                if (xsdTypeDefinition != null && xsdTypeDefinition.getName() != null) {
                    partNode.setDataType(xsdTypeDefinition.getQName());
                }
                addComplexTypeDetails(xsdSchema, partNode, xsdTypeDefinition, prefix, namespace, path);
            }
            resolvedAsComplex = true;
        } else if (typeDef.getTargetNamespace() != null) {
            resolvedAsComplex = true;
            if (!currentPath.contains("String_Node_Str" + elementName + "String_Node_Str")) {
                String path = currentPath + elementName + "String_Node_Str";
                XSDComplexTypeDefinition generalType = xsdSchema.resolveComplexTypeDefinition(typeDef.getQName());
                XSDTypeDefinition xsdTypeDefinition = xsdElementDeclarationParticle.getTypeDefinition();
                if (generalType.getContainer() != null) {
                    xsdTypeDefinition = generalType;
                }
                if (xsdTypeDefinition != null && xsdTypeDefinition.getName() != null) {
                    partNode.setDataType(xsdTypeDefinition.getName());
                }
                if (xsdTypeDefinition instanceof XSDComplexTypeDefinition) {
                    addComplexTypeDetails(xsdSchema, partNode, xsdTypeDefinition, prefix, namespace, path);
                } else {
                    resolvedAsComplex = false;
                }
            }
        }
        if (!resolvedAsComplex) {
            String dataType = xsdElementDeclarationParticle.getTypeDefinition().getQName();
            if (xsdElementDeclarationParticle.getTypeDefinition().getBaseType() != null) {
                if (!"String_Node_Str".equals(xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName())) {
                    dataType = xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName();
                }
            }
            partNode.setDataType(dataType);
        }
        handleOptionalAttribute(partNode, xsdParticle);
        addSubstitutionDetails(xsdSchema, partNode, xsdElementDeclarationParticle, null);
    } else if (xsdTerm instanceof XSDModelGroup) {
        XSDModelGroup xsdModelGroup = (XSDModelGroup) xsdTerm;
        ATreeNode node = addChoiceDetails(parentNode, xsdModelGroup);
        handleOptionalAttribute(node, xsdParticle);
        for (Object element : xsdModelGroup.getParticles()) {
            XSDParticle childParticle = (XSDParticle) element;
            addParticleDetail(xsdSchema, childParticle, node, currentPath);
        }
    }
}

Output:
             String dataType = xsdElementDeclarationParticle.getTypeDefinition().getQName();
-            if (xsdElementDeclarationParticle.getTypeDefinition().getBaseType() != null) {
+            if (dataType == null && xsdElementDeclarationParticle.getTypeDefinition().getBaseType() != null) {
                 if (!"String_Node_Str".equals(xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName())) {


Input:
public FieldDataValues setFieldDataValues(PrestoContextRules rules, final PrestoField field, FieldData fieldData, FieldValues fieldValues) {
    List<? extends Object> values = fieldValues.getValues();
    if (rules.isSortedField(field)) {
        sortFieldValues(rules, field, values, rules.isSortedAscendingField(field));
    }
    ValueFactory valueFactory = createValueFactory(rules, field);
    int size = values.size();
    int start = 0;
    int end = size;
    List<Object> inputValues = new ArrayList<Object>(size);
    List<Value> outputValues = new ArrayList<Value>(size);
    for (int i = start; i < end; i++) {
        Object value = values.get(i);
        if (value != null) {
            Value efv = getExistingFieldValue(valueFactory, rules, field, value);
            outputValues.add(efv);
            inputValues.add(value);
        } else {
            size--;
        }
    }
    if (fieldData != null) {
        fieldData.setValues(outputValues);
        if (fieldValues.isPaging() && rules.isPageableField(field) && rules.isSortedField(field)) {
            fieldData.setValuesOffset(fieldValues.getOffset());
            fieldData.setValuesLimit(fieldValues.getLimit());
            fieldData.setValuesTotal(fieldValues.getTotal());
        }
    }
    return new FieldDataValues(inputValues, outputValues);
}

Output:
         fieldData.setValues(outputValues);
-        if (fieldValues.isPaging() && rules.isPageableField(field) && rules.isSortedField(field)) {
+        if (fieldValues.isPaging() && rules.isPageableField(field) && !rules.isSortedField(field)) {
             fieldData.setValuesOffset(fieldValues.getOffset());


Input:
public static String get(String key) throws UnknownID, IOFailure, ArgumentNotValid {
    ArgumentNotValid.checkNotNullOrEmpty(key, "String_Node_Str");
    String val = System.getProperty(key);
    if (val != null) {
        return val;
    }
    for (SimpleXml settingsXml : fileSettingsXmlList) {
        if (settingsXml.hasKey(key)) {
            return settingsXml.getString(key);
        }
    }
    for (SimpleXml settingsXml : defaultClasspathSettingsXmlList) {
        if (settingsXml.hasKey(key)) {
            return settingsXml.getString(key);
        }
    }
    throw new UnknownID("String_Node_Str" + key + "String_Node_Str");
}

Output:
     }
-    for (SimpleXml settingsXml : fileSettingsXmlList) {
+    for (SimpleXml settingsXml : getFileSettingsXmlList()) {
         if (settingsXml.hasKey(key)) {


Input:
public void testBasic() throws Exception {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    hier2.createLevel("String_Node_Str");
    cqd.createMeasure("String_Node_Str");
    IBinding binding1 = new Binding("String_Node_Str");
    binding1.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding1);
    IBinding binding2 = new Binding("String_Node_Str");
    binding2.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding2);
    IBinding binding3 = new Binding("String_Node_Str");
    binding3.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding3);
    IBinding binding4 = new Binding("String_Node_Str");
    binding4.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding4);
    IBinding binding5 = new Binding("String_Node_Str");
    binding5.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding5);
    DataEngineImpl engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.DIRECT_PRESENTATION, null, null, null));
    this.createCube(engine);
    IPreparedCubeQuery pcq = engine.prepare(cqd, null);
    ICubeQueryResults queryResults = pcq.execute(null);
    CubeCursor cursor = queryResults.getCubeCursor();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    this.printCube(cursor, columnEdgeBindingNames, "String_Node_Str", "String_Node_Str");
}

Output:
     columnEdgeBindingNames.add("String_Node_Str");
-    this.printCube(cursor, columnEdgeBindingNames, "String_Node_Str", "String_Node_Str");
+    List rowEdgeBindingNames = new ArrayList();
+    rowEdgeBindingNames.add("String_Node_Str");
+    this.printCube(cursor, columnEdgeBindingNames, rowEdgeBindingNames, "String_Node_Str");
 }


Input:
public SyncopeUser suspend(final SyncopeUser user) throws WorkflowException, PropagationException {
    user.setStatus("String_Node_Str");
    SyncopeUser updated = userDAO.save(user);
    PropagationByResource propByRes = new PropagationByResource();
    propByRes.addAll(PropagationOperation.UPDATE, user.getExternalResources());
    propagationManager.update(user, null, propByRes, null);
    return updated;
}

Output:
     propByRes.addAll(PropagationOperation.UPDATE, user.getExternalResources());
-    propagationManager.update(user, null, propByRes, null);
+    propagationManager.update(user, null, false, propByRes, null);
     return updated;


Input:
public boolean execute(final Player plr, final String... args) {
    if (args.length < 2) {
        PlayerFunctions.sendMessage(plr, C.HELPER_NEED_ARGUMENT);
        return true;
    }
    if (!PlayerFunctions.isInPlot(plr)) {
        PlayerFunctions.sendMessage(plr, C.NOT_IN_PLOT);
        return true;
    }
    final Plot plot = PlayerFunctions.getCurrentPlot(plr);
    if ((plot.owner == null) || !plot.hasRights(plr)) {
        PlayerFunctions.sendMessage(plr, C.NO_PLOT_PERMS);
        return true;
    }
    if (args[0].equalsIgnoreCase("String_Node_Str")) {
        UUID uuid;
        if (args[1].equalsIgnoreCase("String_Node_Str")) {
            uuid = DBFunc.everyone;
        } else {
            uuid = UUIDHandler.getUUID(args[1]);
        }
        if (!plot.helpers.contains(uuid)) {
            if (plot.owner == uuid) {
                PlayerFunctions.sendMessage(plr, C.ALREADY_OWNER);
                return false;
            }
            if (plot.trusted.contains(uuid)) {
                plot.trusted.remove(uuid);
                DBFunc.removeTrusted(plr.getWorld().getName(), plot, Bukkit.getOfflinePlayer(uuid));
            }
            if (plot.denied.contains(uuid)) {
                plot.denied.remove(uuid);
                DBFunc.removeDenied(plr.getWorld().getName(), plot, Bukkit.getOfflinePlayer(uuid));
            }
            plot.addHelper(uuid);
            DBFunc.setHelper(plr.getWorld().getName(), plot, Bukkit.getOfflinePlayer(args[1]));
            final PlayerPlotHelperEvent event = new PlayerPlotHelperEvent(plr, plot, uuid, true);
            Bukkit.getPluginManager().callEvent(event);
        } else {
            PlayerFunctions.sendMessage(plr, C.ALREADY_ADDED);
            return false;
        }
        PlayerFunctions.sendMessage(plr, C.HELPER_ADDED);
        return true;
    } else if (args[0].equalsIgnoreCase("String_Node_Str")) {
        if (args[1].equalsIgnoreCase("String_Node_Str")) {
            final UUID uuid = DBFunc.everyone;
            if (!plot.helpers.contains(uuid)) {
                PlayerFunctions.sendMessage(plr, C.WAS_NOT_ADDED);
                return true;
            }
            plot.removeHelper(uuid);
            DBFunc.removeHelper(plr.getWorld().getName(), plot, Bukkit.getOfflinePlayer(args[1]));
            PlayerFunctions.sendMessage(plr, C.HELPER_REMOVED);
            return true;
        }
        final UUID uuid = UUIDHandler.getUUID(args[1]);
        plot.removeHelper(uuid);
        DBFunc.removeHelper(plr.getWorld().getName(), plot, Bukkit.getOfflinePlayer(args[1]));
        final PlayerPlotHelperEvent event = new PlayerPlotHelperEvent(plr, plot, uuid, false);
        Bukkit.getPluginManager().callEvent(event);
        PlayerFunctions.sendMessage(plr, C.HELPER_REMOVED);
    } else {
        PlayerFunctions.sendMessage(plr, C.HELPER_NEED_ARGUMENT);
        return true;
    }
    return true;
}

Output:
     final Plot plot = PlayerFunctions.getCurrentPlot(plr);
-    if ((plot.owner == null) || !plot.hasRights(plr)) {
+    if ((plot.owner == null) || !plot.getOwner().equals(plr)) {
         PlayerFunctions.sendMessage(plr, C.NO_PLOT_PERMS);


Input:
public static NBTTagCompound getMaterialTag(ItemStack stack) {
    NBTTagCompound tag = new NBTTagCompound();
    if (stack != null && stack.getItem() != null) {
        tag.setString(Names.NBT.material, Block.blockRegistry.getNameForObject(((ItemBlock) stack.getItem()).field_150939_a));
        tag.setInteger(Names.NBT.materialMeta, stack.getItemDamage());
    }
    return tag;
}

Output:
 public static NBTTagCompound getMaterialTag(ItemStack stack) {
-    NBTTagCompound tag = new NBTTagCompound();
+    NBTTagCompound tag = null;
     if (stack != null && stack.getItem() != null) {


Input:
public void comment(char[] ch, int start, int length) throws SAXException {
    if (isStartElementOpen) {
        outputStreamWrite(CLOSE_ELEMENT);
        outputStreamWrite(CR);
        isStartElementOpen = false;
    }
    writeComment(ch, start, length);
    complexType = false;
}

Output:
         outputStreamWrite(CLOSE_ELEMENT);
-        outputStreamWrite(CR);
+        outputStreamWrite(cr);
         isStartElementOpen = false;


Input:
private void adjustPasswordPolicies(Study study, Directory directory) {
    PasswordPolicy passwordPolicy = directory.getPasswordPolicy();
    ModeledEmailTemplate template = passwordPolicy.getResetEmailTemplates().iterator().next();
    updateTemplate(study, template, study.getResetPasswordTemplate(), "String_Node_Str");
    PasswordStrength strength = passwordPolicy.getStrength();
    strength.setMaxLength(org.sagebionetworks.bridge.models.studies.PasswordPolicy.FIXED_MAX_LENGTH);
    strength.setMinDiacritic(0);
    strength.setMinLength(study.getPasswordPolicy().getMinLength());
    strength.setMinNumeric(study.getPasswordPolicy().isNumericRequired() ? 1 : 0);
    strength.setMinSymbol(study.getPasswordPolicy().isSymbolRequired() ? 1 : 0);
    strength.setMinLowerCase(study.getPasswordPolicy().isLowerCaseRequired() ? 1 : 0);
    strength.setMinUpperCase(study.getPasswordPolicy().isUpperCaseRequired() ? 1 : 0);
    strength.save();
    passwordPolicy.setResetEmailStatus(EmailStatus.ENABLED);
    passwordPolicy.setResetSuccessEmailStatus(EmailStatus.DISABLED);
    passwordPolicy.save();
}

Output:
     PasswordPolicy passwordPolicy = directory.getPasswordPolicy();
-    ModeledEmailTemplate template = passwordPolicy.getResetEmailTemplates().iterator().next();
-    updateTemplate(study, template, study.getResetPasswordTemplate(), "String_Node_Str");
+    for (ModeledEmailTemplate template : passwordPolicy.getResetEmailTemplates()) {
+        updateTemplate(study, template, study.getResetPasswordTemplate(), "String_Node_Str");
+    }
     PasswordStrength strength = passwordPolicy.getStrength();


Input:
public void close(Dataset dataset) {
    if (datasetToPath.get(dataset).getParent().equals(getClosedPath())) {
        return;
    }
    try {
        Path datasetPath = datasetToPath.get(dataset);
        Files.move(datasetPath, getClosedPath().resolve(datasetPath.getFileName()));
    } catch (IOException ex) {
        LOGGER.log(Level.SEVERE, null, ex);
    }
}

Output:
 public void close(Dataset dataset) {
-    if (datasetToPath.get(dataset).getParent().equals(getClosedPath())) {
+    if (isClosed(dataset)) {
         return;


Input:
protected String makeEyeAltitudeDescription(double metersAltitude) {
    String s;
    if (UNIT_IMPERIAL.equals(getElevationUnit()))
        return super.makeEyeAltitudeDescription(metersAltitude);
    else {
        if (metersAltitude < 1e4)
            s = String.format("String_Node_Str", (int) Math.round(metersAltitude));
        else
            s = String.format("String_Node_Str", (int) Math.round(metersAltitude / 1e3));
    }
    return s;
}

Output:
         if (metersAltitude < 1e4)
-            s = String.format("String_Node_Str", (int) Math.round(metersAltitude));
+            s = String.format(altitude + "String_Node_Str", (int) Math.round(metersAltitude));
         else


Input:
public void matchSuccess(final MatchSuccessEvent<V> event) {
    try {
        eventWriter.writeAfter(event.getContext(), before, System.nanoTime(), true);
    } catch (IOException e) {
        throw cleanup("String_Node_Str", e);
    }
}

Output:
     try {
-        eventWriter.writeAfter(event.getContext(), before, System.nanoTime(), true);
+        eventWriter.writeSuccess(event.getContext(), System.nanoTime());
     } catch (IOException e) {


Input:
private boolean isInHeaderFooter(ReportElementHandle elementHandle) {
    DesignElementHandle containerHandle = elementHandle.getContainer();
    while (containerHandle != null) {
        if (containerHandle instanceof RowHandle) {
            Boolean rowResult = (Boolean) rowHeaderFooterCache.get(containerHandle);
            if (rowResult != null) {
                return rowResult.booleanValue();
            }
            RowHandle rowHandle = (RowHandle) containerHandle;
            DesignElementHandle rowParentHnadle = rowHandle.getContainer();
            if (rowParentHnadle instanceof TableHandle) {
                int slotID = ((TableHandle) rowParentHnadle).findContentSlot(rowHandle);
                if (TableHandle.HEADER_SLOT == slotID || TableHandle.FOOTER_SLOT == slotID) {
                    rowHeaderFooterCache.put(containerHandle, Boolean.TRUE);
                    return true;
                }
            } else if (rowParentHnadle instanceof TableGroupHandle) {
                int slotID = ((TableGroupHandle) rowParentHnadle).findContentSlot(rowHandle);
                if (TableGroupHandle.HEADER_SLOT == slotID || TableGroupHandle.FOOTER_SLOT == slotID) {
                    if (rowParentHnadle.getContainer() instanceof TableHandle) {
                        rowHeaderFooterCache.put(containerHandle, Boolean.TRUE);
                        return true;
                    }
                }
            }
            rowHeaderFooterCache.put(containerHandle, Boolean.FALSE);
        }
        if (containerHandle instanceof ReportDesignHandle) {
            return false;
        }
        if (containerHandle.getStringProperty("String_Node_Str") != null) {
            return false;
        }
        if (containerHandle instanceof ReportItemHandle) {
            if (((ReportItemHandle) containerHandle).getDataBindingReference() != null) {
                return false;
            }
        }
        containerHandle = containerHandle.getContainer();
    }
    return false;
}

Output:
             }
-            rowHeaderFooterCache.put(containerHandle, Boolean.FALSE);
-        }
-        if (containerHandle instanceof ReportDesignHandle) {
+        } else if (containerHandle instanceof ReportDesignHandle) {
             return false;


Input:
public void onClick(View view) {
    popup.show();
}

Output:
 public void onClick(View view) {
-    popup.show();
+    Fragment fragment = getFragment().getTab();
+    if (fragment.getClass().getName().contains("String_Node_Str")) {
+        Main main = (Main) fragment;
+        main.bbar(main.current);
+        main.crossfade();
+        main.timer.cancel();
+        main.timer.start();
+    }
 }


Input:
public static ConnectionStatus testConnection(String dbType, String url, String username, String pwd, String schema, final String driverClassName, final String driverJarPath, String dbVersionString, String additionalParam, StringBuffer retProposedSchema) {
    Connection connection = null;
    ConnectionStatus connectionStatus = new ConnectionStatus();
    connectionStatus.setResult(false);
    DriverShim wapperDriver = null;
    try {
        List list = new ArrayList();
        list = ExtractMetaDataUtils.getInstance().connect(dbType, url, username, pwd, driverClassName, driverJarPath, dbVersionString, additionalParam);
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i) instanceof Connection) {
                    connection = (Connection) list.get(i);
                }
                if (list.get(i) instanceof DriverShim) {
                    wapperDriver = (DriverShim) list.get(i);
                }
            }
        }
        if ((schema != null) && (schema.compareTo("String_Node_Str") != 0)) {
            final String product = EDatabaseTypeName.getTypeFromDisplayName(dbType).getProduct();
            final boolean equals = EDatabaseTypeName.ORACLEFORSID.getProduct().equals(product) || EDatabaseTypeName.TERADATA.getProduct().equals(product) || EDatabaseTypeName.VERTICA.getProduct().equals(product);
            if (!checkSchemaConnection(schema, connection, equals, dbType, retProposedSchema)) {
                connectionStatus.setMessageException(Messages.getString("String_Node_Str"));
                return connectionStatus;
            }
        }
        connectionStatus.setResult(true);
        connectionStatus.setMessageException(Messages.getString("String_Node_Str"));
    } catch (SQLException e) {
        ExceptionHandler.process(e);
        connectionStatus.setMessageException(ExceptionUtils.getFullStackTrace(e));
    } catch (Exception e) {
        connectionStatus.setMessageException(ExceptionUtils.getFullStackTrace(e));
    } finally {
        if (connection != null) {
            ConnectionUtils.closeConnection(connection);
        }
        ExtractManager extractManager = ExtractManagerFactory.createByDisplayName(dbType);
        if (extractManager != null) {
            extractManager.closeConnection(null, wapperDriver);
            if (driverClassName.equals(EDatabase4DriverClassName.JAVADB_EMBEDED.getDriverClass())) {
                extractManager.closeConnectionForDerby(wapperDriver);
            }
        }
    }
    return connectionStatus;
}

Output:
         if ((schema != null) && (schema.compareTo("String_Node_Str") != 0)) {
-            final String product = EDatabaseTypeName.getTypeFromDisplayName(dbType).getProduct();
-            final boolean equals = EDatabaseTypeName.ORACLEFORSID.getProduct().equals(product) || EDatabaseTypeName.TERADATA.getProduct().equals(product) || EDatabaseTypeName.VERTICA.getProduct().equals(product);
-            if (!checkSchemaConnection(schema, connection, equals, dbType, retProposedSchema)) {
+            final boolean notCaseSensitive = !ManagerConnection.isSchemaCaseSensitive(EDatabaseTypeName.getTypeFromDisplayName(dbType));
+            if (!checkSchemaConnection(schema, connection, notCaseSensitive, dbType, retProposedSchema)) {
                 connectionStatus.setMessageException(Messages.getString("String_Node_Str"));


Input:
public void testCoordEvalEditHTML() throws Exception {
    printTestCaseHeader("String_Node_Str");
    bi.verifyCurrentPageHTML(Common.TEST_PAGES_FOLDER + "String_Node_Str");
}

Output:
 public void testCoordEvalEditHTML() throws Exception {
-    printTestCaseHeader("String_Node_Str");
+    printTestCaseHeader();
     bi.verifyCurrentPageHTML(Common.TEST_PAGES_FOLDER + "String_Node_Str");


Input:
public void widgetDisposed(DisposeEvent e) {
    showImageShell = null;
}

Output:
 public void widgetDisposed(DisposeEvent e) {
-    showImageShell = null;
+    shells.remove(id);
 }


Input:
private void sendMails(String from, Collection<Integer> userIds, String body, List<String> attachments) {
    if (StringUtil.isEmpty(from) || ListUtil.isEmpty(userIds)) {
        return;
    }
    MessageParameters parameters = new MessageParameters();
    parameters.setFrom(from);
    ArrayList<String> recipients = new ArrayList<String>(userIds.size());
    UserBusiness userbusiness = this.getUserBusiness();
    for (Integer userId : userIds) {
        User user = null;
        try {
            user = userbusiness.getUser(Integer.valueOf(userId));
        } catch (RemoteException e) {
            this.getLogger().log(Level.WARNING, "String_Node_Str" + userId, e);
        }
        UserDataBean userInfo = userApplicationEngine.getUserInfo(user);
        recipients.add(userInfo.getEmail());
    }
    parameters.setAttachments(attachments);
    parameters.setMessage(body);
    String recipientsString = recipients.toString();
    parameters.setRecipientTo(recipientsString);
    this.emailSenderHelper.sendMessage(parameters);
}

Output:
     parameters.setFrom(from);
-    ArrayList<String> recipients = new ArrayList<String>(userIds.size());
-    UserBusiness userbusiness = this.getUserBusiness();
+    List<String> recipients = new ArrayList<String>(userIds.size());
+    UserBusiness userBusiness = this.getUserBusiness();
     for (Integer userId : userIds) {


Input:
protected BufferedDataTable[] execute(BufferedDataTable[] inData, ExecutionContext exec) throws Exception {
    BufferedDataTable input = inData[0];
    Attribute groupingAttribute = new InputTableAttribute(groupBy.getStringValue(), input);
    Attribute treatmentAttribute = new InputTableAttribute(this.treatmentAttribute.getStringValue(), input);
    List<String> posCtrls = getPosControls();
    List<String> negCtrls = getNegControls();
    HashSet<String> intersection = new HashSet<String>(posCtrls);
    intersection.retainAll(negCtrls);
    if (!intersection.isEmpty()) {
        throw new RuntimeException("String_Node_Str");
    }
    List<String> readouts = propReadouts.getIncludeList();
    Map<String, List<DataRow>> groups = AttributeUtils.splitRows(input, groupingAttribute);
    BufferedDataTable barcodeTable = prepareZPrimeTable(exec, new ArrayList<String>(groups.keySet()));
    TableUpdateCache updateCache = new TableUpdateCache(barcodeTable.getDataTableSpec());
    Attribute barcodeAttr = new InputTableAttribute(groupBy.getStringValue(), barcodeTable);
    Attribute positiveAttr = new InputTableAttribute(POSITIVE_CONTROL_DESC, barcodeTable);
    Attribute negativeAttr = new InputTableAttribute(NEGATIVE_CONTROL_DESC, barcodeTable);
    int counter = 0;
    for (DataRow dataRow : barcodeTable) {
        String barcode = barcodeAttr.getNominalAttribute(dataRow);
        String positiveControl = positiveAttr.getNominalAttribute(dataRow);
        String negativeControl = negativeAttr.getNominalAttribute(dataRow);
        logger.info("String_Node_Str" + barcode + "String_Node_Str");
        List<DataRow> plate = groups.get(barcode);
        List<DataRow> posCtrlWells = AttributeUtils.filterByAttributeValue(plate, treatmentAttribute, positiveControl);
        List<DataRow> negCtrlWells = AttributeUtils.filterByAttributeValue(plate, treatmentAttribute, negativeControl);
        RealMatrix posMatrix = getMatrix(posCtrlWells, readouts, input);
        RealMatrix negMatrix = getMatrix(negCtrlWells, readouts, input);
        int[] columnIndex = checkColumns(posMatrix, negMatrix);
        int[] rowIndex = getRowIndices(posMatrix);
        posMatrix.getSubMatrix(rowIndex, columnIndex);
        rowIndex = getRowIndices(negMatrix);
        negMatrix.getSubMatrix(rowIndex, columnIndex);
        posMatrix = bootstrapMatrix(posMatrix);
        negMatrix = bootstrapMatrix(negMatrix);
        String posStatus = getSampilingStatus(posMatrix, posCtrlWells.size());
        String negStatus = getSampilingStatus(negMatrix, negCtrlWells.size());
        Double zPrime = Double.NaN;
        Double classificationError = Double.NaN;
        if ((posMatrix != null) && (negMatrix != null)) {
            RealVector posMeanVect = computeColumnMeans(posMatrix);
            RealVector negMeanVect = computeColumnMeans(negMatrix);
            Covariance posCov = new Covariance(posMatrix);
            Covariance negCov = new Covariance(negMatrix);
            RealVector meanVect = posMeanVect.subtract(negMeanVect);
            RealMatrix cov = posCov.getCovarianceMatrix();
            cov.add(negCov.getCovarianceMatrix());
            try {
                DecompositionSolver solver = new SingularValueDecompositionImpl(cov).getSolver();
                RealMatrix inv = solver.getInverse();
                RealVector weights = inv.preMultiply(meanVect);
                double[] posProj = computeProjectedValues(posMatrix, weights);
                double[] negProj = computeProjectedValues(negMatrix, weights);
                classificationError = calculateClassificationError(weights, posMeanVect, negMeanVect, posProj, negProj);
                double posCtrlMean = StatUtils.mean(posProj);
                double posCtrlSD = Math.sqrt(StatUtils.variance(posProj));
                double negCtrlMean = StatUtils.mean(negProj);
                double negCtrlSD = Math.sqrt(StatUtils.variance(negProj));
                zPrime = 1 - 3 * ((posCtrlSD + negCtrlSD) / Math.abs(posCtrlMean - negCtrlMean));
            } catch (InvalidMatrixException e) {
                zPrime = Double.NaN;
            }
        }
        Attribute attribute;
        attribute = new Attribute(POSITIVE_CONTROL_DESC + "String_Node_Str", DoubleCell.TYPE);
        updateCache.add(dataRow, attribute, new DoubleCell(negCtrlWells.size()));
        attribute = new Attribute(POSITIVE_CONTROL_DESC + "String_Node_Str", StringCell.TYPE);
        updateCache.add(dataRow, attribute, new StringCell(posStatus));
        attribute = new Attribute(NEGATIVE_CONTROL_DESC + "String_Node_Str", DoubleCell.TYPE);
        updateCache.add(dataRow, attribute, new DoubleCell(negCtrlWells.size()));
        attribute = new Attribute(NEGATIVE_CONTROL_DESC + "String_Node_Str", StringCell.TYPE);
        updateCache.add(dataRow, attribute, new StringCell(negStatus));
        attribute = new Attribute("String_Node_Str", DoubleCell.TYPE);
        updateCache.add(dataRow, attribute, isValidNumber(zPrime) ? DataType.getMissingCell() : new DoubleCell(zPrime));
        attribute = new Attribute("String_Node_Str", DoubleCell.TYPE);
        updateCache.add(dataRow, attribute, isValidNumber(classificationError) ? DataType.getMissingCell() : new DoubleCell(classificationError));
        BufTableUtils.updateProgress(exec, counter++, groups.size());
    }
    ColumnRearranger c = updateCache.createColRearranger();
    BufferedDataTable out = exec.createColumnRearrangeTable(barcodeTable, c, exec);
    return new BufferedDataTable[] { out };
}

Output:
     }
-    List<String> readouts = propReadouts.getIncludeList();
+    List<Attribute> readouts = new ArrayList<Attribute>();
+    for (String item : propReadouts.getIncludeList()) {
+        Attribute attribute = new InputTableAttribute(item, input);
+        if (attribute.getType().equals(DoubleCell.TYPE)) {
+            readouts.add(attribute);
+        } else {
+            logger.warn("String_Node_Str" + attribute.getName() + "String_Node_Str");
+        }
+    }
     Map<String, List<DataRow>> groups = AttributeUtils.splitRows(input, groupingAttribute);


Input:
private final boolean isValidLineAndSaveSAMHeader(final String line, final Context context) throws IOException {
    if (line.length() == 0)
        return false;
    if (line.charAt(0) != '@') {
        if (this.headers != null) {
            final Path outputPath = new Path(context.getConfiguration().get("String_Node_Str"));
            final Path headerPath = new Path(outputPath, SAM_HEADER_FILE_PREFIX + context.getTaskAttemptID().toString());
            final Writer writer = new OutputStreamWriter(PathUtils.createOutputStream(headerPath, context.getConfiguration()));
            for (String l : this.headers) writer.write(l + "String_Node_Str");
            writer.close();
            this.headers = null;
        }
        return true;
    }
    if (this.headers == null)
        this.headers = Lists.newArrayList();
    this.headers.add(line);
    return false;
}

Output:
             final Path headerPath = new Path(outputPath, SAM_HEADER_FILE_PREFIX + context.getTaskAttemptID().toString());
-            final Writer writer = new OutputStreamWriter(PathUtils.createOutputStream(headerPath, context.getConfiguration()));
+            final Writer writer = new OutputStreamWriter(PathUtils.createOutputStream(headerPath, context.getConfiguration()), "String_Node_Str");
             for (String l : this.headers) writer.write(l + "String_Node_Str");


Input:
public Map<Service, Set<Provider>> getVpcOffSvcProvidersMap(long vpcOffId) {
    Map<Service, Set<Provider>> serviceProviderMap = new HashMap<Service, Set<Provider>>();
    List<VpcOfferingServiceMapVO> map = _vpcOffSvcMapDao.listByVpcOffId(vpcOffId);
    for (VpcOfferingServiceMapVO instance : map) {
        Service service = Service.getService(instance.getService());
        Set<Provider> providers;
        providers = serviceProviderMap.get(service);
        if (providers == null) {
            providers = new HashSet<Provider>();
        }
        providers.add(Provider.getProvider(instance.getProvider()));
        serviceProviderMap.put(service, providers);
    }
    return serviceProviderMap;
}

Output:
     for (VpcOfferingServiceMapVO instance : map) {
-        Service service = Service.getService(instance.getService());
+        String service = instance.getService();
         Set<Provider> providers;


Input:
private AtlasFrameAnimation getFrameAnimation(String id) {
    AtlasFrameAnimation fa = (AtlasFrameAnimation) fanims.get(id);
    flipX = false;
    if (fa == null && id != null) {
        String flipId = FrameAnimation.getFlipId(id);
        fa = (AtlasFrameAnimation) fanims.get(flipId);
        if (fa != null)
            flipX = true;
        else {
            StringBuilder sb = new StringBuilder();
            if (id.endsWith(FrameAnimation.LEFT)) {
                sb.append(id.substring(0, id.length() - 4));
                sb.append("String_Node_Str");
            } else if (id.endsWith(FrameAnimation.FRONTLEFT)) {
                sb.append(id.substring(0, id.length() - 9));
                sb.append("String_Node_Str");
            } else if (id.endsWith(FrameAnimation.RIGHT)) {
                sb.append(id.substring(0, id.length() - 5));
                sb.append("String_Node_Str");
            } else if (id.endsWith(FrameAnimation.FRONTRIGHT)) {
                sb.append(id.substring(0, id.length() - 10));
                sb.append("String_Node_Str");
            }
            String s = sb.toString();
            fa = (AtlasFrameAnimation) fanims.get(s);
            if (fa == null) {
                flipId = FrameAnimation.getFlipId(s);
                fa = (AtlasFrameAnimation) fanims.get(flipId);
                if (fa != null)
                    flipX = true;
            }
        }
    }
    return fa;
}

Output:
 private AtlasFrameAnimation getFrameAnimation(String id) {
-    AtlasFrameAnimation fa = (AtlasFrameAnimation) fanims.get(id);
+    FrameAnimation fa = fanims.get(id);
     flipX = false;


Input:
public synchronized Set<String> getReadyNodeIds(String streamId) {
    Set<String> result = new HashSet<String>();
    if (readySources.containsKey(streamId)) {
        for (SourceStatus ss : readySources.get(streamId).values()) {
            result.add(ss.getFromNode().getId());
        }
    }
    return result;
}

Output:
     if (readySources.containsKey(streamId)) {
-        for (SourceStatus ss : readySources.get(streamId).values()) {
+        for (SourceStatus ss : readySources.get(streamId)) {
             result.add(ss.getFromNode().getId());


Input:
public void addDependencyMgt(PomDependencyMgt dep) {
    String key = getDependencyMgtExtraInfoKey(dep.getGroupId(), dep.getArtifaceId());
    ivyModuleDescriptor.addExtraInfo(key, dep.getVersion());
    ivyModuleDescriptor.addDependencyDescriptorMediator(ModuleId.newInstance(dep.getGroupId(), dep.getArtifaceId()), ExactPatternMatcher.INSTANCE, new OverrideDependencyDescriptorMediator(null, dep.getVersion()));
}

Output:
 public void addDependencyMgt(PomDependencyMgt dep) {
-    String key = getDependencyMgtExtraInfoKey(dep.getGroupId(), dep.getArtifaceId());
+    String key = getDependencyMgtExtraInfoKey(dep.getGroupId(), dep.getArtifactId());
     ivyModuleDescriptor.addExtraInfo(key, dep.getVersion());


Input:
public int getColumnIndexByCoordinate(int value) {
    int index = columnCoordinates.indexOf(new Integer(value));
    return (index == -1) ? 0 : index;
}

Output:
 public int getColumnIndexByCoordinate(int value) {
-    int index = columnCoordinates.indexOf(new Integer(value));
+    int index = columnCoordinates.indexOf(value);
     return (index == -1) ? 0 : index;


Input:
public GameField generateSolvedField(int width, int height) {
    GameField gameField = new GameField();
    int startX;
    int startY;
    int direction;
    tiles = new Tile[width][height];
    for (int i = 1; i < width - 1; i++) {
        for (int j = 1; j < height - 1; j++) {
            tiles[i][j] = new Tile(false, false, false, false, UNDEFINED, 'o');
        }
    }
    for (int i = 0; i < width; i++) {
        tiles[i][0] = new Tile(false, false, false, false, TileType.NONE, 'n');
    }
    for (int i = 0; i < width; i++) {
        tiles[i][height - 1] = new Tile(false, false, false, false, TileType.NONE, 'n');
    }
    for (int i = 0; i < height; i++) {
        tiles[0][i] = new Tile(false, false, false, false, TileType.NONE, 'n');
    }
    for (int i = 0; i < height; i++) {
        tiles[width - 1][i] = new Tile(false, false, false, false, TileType.NONE, 'n');
    }
    Tile startTile;
    switch((int) (Math.random() * (4))) {
        case 0:
            startTile = new Tile(false, true, false, false, TileType.START, 's');
            startX = (int) (Math.random() * (width - 2) + 1);
            startY = 0;
            direction = 0;
            tiles[startX][0] = startTile;
            break;
        case 1:
            startTile = new Tile(true, false, false, false, TileType.START, 's');
            startX = (int) (Math.random() * (width - 2) + 1);
            startY = height - 1;
            direction = 2;
            tiles[startX][height - 1] = startTile;
            break;
        case 2:
            startTile = new Tile(false, false, false, true, TileType.START, 's');
            startX = 0;
            startY = (int) (Math.random() * (height - 2) + 1);
            direction = 1;
            tiles[startX][startY] = startTile;
            break;
        case 3:
            startTile = new Tile(false, false, true, false, TileType.START, 's');
            startX = width - 1;
            startY = (int) (Math.random() * (height - 2) + 1);
            direction = 3;
            tiles[startX][startY] = startTile;
            break;
        default:
            throw new IllegalStateException("String_Node_Str");
    }
    int x = startX;
    int y = startY;
    while ((x != 0 && x != width - 1 && y != 0 && y != height - 1) || (x == startX && y == startY)) {
        if (Math.random() < 0.7f && !(startX == x && startY == y)) {
            direction = (int) (Math.random() * 4);
        }
        int xNew = x + directionsX[direction];
        int yNew = y + directionsY[direction];
        while (tiles[xNew][yNew].getTileType() != UNDEFINED && tiles[xNew][yNew].getShortcut() != 'n') {
            direction = (int) (Math.random() * (4) + 0);
            xNew = x + directionsX[direction];
            yNew = y + directionsY[direction];
        }
        switch(direction) {
            case 0:
                tiles[x][y].setBottom(true);
                tiles[xNew][yNew].setTop(true);
                break;
            case 1:
                tiles[x][y].setRight(true);
                tiles[xNew][yNew].setLeft(true);
                break;
            case 2:
                tiles[x][y].setTop(true);
                tiles[xNew][yNew].setBottom(true);
                break;
            case 3:
                tiles[x][y].setLeft(true);
                tiles[xNew][yNew].setRight(true);
                break;
            default:
                throw new IllegalStateException("String_Node_Str");
        }
        x = xNew;
        y = yNew;
        tiles[x][y].setTileType(TileType.PUZZLE);
    }
    for (int i = 1; i < width - 1; i++) {
        for (int j = 1; j < height - 1; j++) {
            tiles[i][j].setTileType(PUZZLE);
            tiles[i][j].setShortcut(tileShortcutHashMap.get(tiles[i][j]));
        }
    }
    tiles[x][y].setTileType(TileType.FINISH);
    tiles[x][y].setShortcut('f');
    gameField.setStartX(startX);
    gameField.setStartY(startY);
    gameField.setField(tiles);
    return gameField;
}

Output:
     gameField.setField(tiles);
-    return gameField;
+    if (number > (width - 2) * (height - 2) / 3) {
+        return gameField;
+    } else {
+        return generateSolvedField(width, height);
+    }
 }


Input:
boolean persistChangeData(Node row, ApiKey apiKey, int brokerRelation, int accounting) {
    Session session = getDatabase().getCurrentSession();
    try {
        Timestamp currentTime = TimeUtils.convertToTimestamp(row.getAttribute("String_Node_Str"));
        long transactionID = Long.parseLong(row.getAttribute("String_Node_Str"));
        long quantity = Long.parseLong(row.getAttribute("String_Node_Str"));
        String typeName = row.getAttribute("String_Node_Str");
        long typeId = Long.parseLong(row.getAttribute("String_Node_Str"));
        BigDecimal price = BigDecimal.valueOf(Float.parseFloat(row.getAttribute("String_Node_Str")));
        long clientId = Long.parseLong(row.getAttribute("String_Node_Str"));
        String clientName = row.getAttribute("String_Node_Str");
        long stationId = Long.parseLong(row.getAttribute("String_Node_Str"));
        String stationName = row.getAttribute("String_Node_Str");
        boolean isBuy = ("String_Node_Str").equals(row.getAttribute("String_Node_Str"));
        boolean isPersonal = ("String_Node_Str").equals(row.getAttribute("String_Node_Str"));
        BigDecimal corporationStanding = getCorporationStanding(apiKey, stationId);
        BigDecimal factionStanding = getFactionStanding(apiKey, stationId);
        BigDecimal taxes = (BigDecimal.valueOf(0.01).subtract(BigDecimal.valueOf(0.0005).multiply(BigDecimal.valueOf(brokerRelation)))).divide(BigDecimal.valueOf(Math.exp(((BigDecimal.valueOf(0.1).multiply(factionStanding)).add(BigDecimal.valueOf(0.04).multiply(corporationStanding)).doubleValue()))), 3, RoundingMode.HALF_UP);
        if (!isBuy) {
            taxes = taxes.add(BigDecimal.valueOf(0.01).subtract(BigDecimal.valueOf(0.001).multiply(BigDecimal.valueOf(accounting))));
        }
        WalletTransaction transaction = (WalletTransaction) session.get(WalletTransaction.class, transactionID);
        if (transaction == null) {
            BigDecimal actualPrice = price;
            if (isBuy) {
                actualPrice = price.negate();
            }
            transaction = new WalletTransaction();
            transaction.setTransactionId(transactionID);
            transaction.setTransactionDateTime(currentTime);
            transaction.setCharacterId(apiKey.getCharacterId());
            transaction.setQuantity(quantity);
            transaction.setRemaining(quantity);
            transaction.setTypeName(typeName);
            transaction.setTypeId(typeId);
            transaction.setPrice(actualPrice);
            transaction.setTaxes(taxes.multiply(price.abs()).negate());
            transaction.setClientId(clientId);
            transaction.setClientName(clientName);
            transaction.setStationId(stationId);
            transaction.setStationName(stationName);
            transaction.setPersonal(isPersonal);
            session.save(transaction);
            return true;
        }
    } catch (Exception e) {
        LOG.error(e.getLocalizedMessage(), e);
        dialog.setVisible(true);
    }
    return false;
}

Output:
         boolean isPersonal = ("String_Node_Str").equals(row.getAttribute("String_Node_Str"));
-        BigDecimal corporationStanding = getCorporationStanding(apiKey, stationId);
-        BigDecimal factionStanding = getFactionStanding(apiKey, stationId);
-        BigDecimal taxes = (BigDecimal.valueOf(0.01).subtract(BigDecimal.valueOf(0.0005).multiply(BigDecimal.valueOf(brokerRelation)))).divide(BigDecimal.valueOf(Math.exp(((BigDecimal.valueOf(0.1).multiply(factionStanding)).add(BigDecimal.valueOf(0.04).multiply(corporationStanding)).doubleValue()))), 3, RoundingMode.HALF_UP);
+        double corporationStanding = getCorporationStanding(apiKey, stationId);
+        double factionStanding = getFactionStanding(apiKey, stationId);
+        double brokerFees = (0.01 - 0.0005 * brokerRelation / Math.pow(2.0, 0.14 * factionStanding + 0.06 * corporationStanding));
+        double marketTax = 0.0;
         if (!isBuy) {


Input:
private void processaCombate() {
    Agente inimigo = getInimigoJuntoComigo();
    boolean morreu = false;
    if (inimigo != null) {
        morreu = dahPancada(inimigo);
        if (morreu) {
            ganhaEnergia(Constants.ENTIDADE_COMBATE_RECOMPENSA);
            ganhouCombate();
        }
    }
}

Output:
             ganhaEnergia(Constants.ENTIDADE_COMBATE_RECOMPENSA);
-            ganhouCombate();
+            sinalizaGanhouCombate();
         }


Input:
private void writeObject(final ObjectOutputStream oos) throws IOException {
    oos.defaultWriteObject();
    new JsonNode(this.initialAggregate).write(oos);
}

Output:
     oos.defaultWriteObject();
-    new JsonNode(this.initialAggregate).write(oos);
+    this.initialAggregate.write(oos);
 }


Input:
public void onDraw(Canvas canvas) {
    canvas.getRegion();
    canvas.drawTexture(sectionTexture, sectionRegion);
    if (icon.get() != null) {
        canvas.drawTexture(icon.get(), innerRegion);
    }
    if (text.get() != null) {
        canvas.drawText(text.get(), innerRegion);
    }
    if (isSelected) {
        canvas.drawTexture(selectedTexture, sectionRegion);
        if (widget.get() != null) {
            canvas.drawWidget(widget.get(), infoRegion);
        }
    }
}

Output:
     canvas.drawTexture(sectionTexture, sectionRegion);
-    if (icon.get() != null) {
-        canvas.drawTexture(icon.get(), innerRegion);
+    if (icon != null) {
+        canvas.drawTexture(icon, innerRegion);
     }


Input:
public void generate(HmDevice device) {
    ThingTypeUID thingTypeUID = UidUtils.generateThingTypeUID(device);
    ThingType tt = thingTypeProvider.getThingType(thingTypeUID, Locale.getDefault());
    if (tt == null || device.isGatewayExtras()) {
        logger.debug("String_Node_Str", device.getType(), device.getDatapointCount());
        List<ChannelGroupType> groupTypes = new ArrayList<ChannelGroupType>();
        for (HmChannel channel : device.getChannels()) {
            List<ChannelDefinition> channelDefinitions = new ArrayList<ChannelDefinition>();
            for (HmDatapoint dp : channel.getDatapoints().values()) {
                if (!isStatusDatapoint(dp) && !isIgnoredDatapoint(dp)) {
                    if (dp.getParamsetType() == HmParamsetType.VALUES) {
                        ChannelTypeUID channelTypeUID = UidUtils.generateChannelTypeUID(dp);
                        ChannelType channelType = channelTypeProvider.getChannelType(channelTypeUID, Locale.getDefault());
                        if (channelType == null) {
                            channelType = createChannelType(dp, channelTypeUID);
                            channelTypeProvider.addChannelType(channelType);
                        }
                        ChannelDefinition channelDef = new ChannelDefinition(dp.getName(), channelType.getUID());
                        channelDefinitions.add(channelDef);
                    }
                }
            }
            ChannelGroupTypeUID groupTypeUID = UidUtils.generateChannelGroupTypeUID(channel);
            ChannelGroupType groupType = channelTypeProvider.getChannelGroupType(groupTypeUID, Locale.getDefault());
            if (groupType == null || device.isGatewayExtras()) {
                String groupLabel = String.format("String_Node_Str", WordUtils.capitalizeFully(StringUtils.replace(channel.getType(), "String_Node_Str", "String_Node_Str")));
                groupType = new ChannelGroupType(groupTypeUID, false, groupLabel, null, channelDefinitions);
                channelTypeProvider.addChannelGroupType(groupType);
                groupTypes.add(groupType);
            }
        }
        tt = createThingType(device, groupTypes);
        thingTypeProvider.addThingType(tt);
    }
    addFirmware(device);
}

Output:
 public void generate(HmDevice device) {
-    ThingTypeUID thingTypeUID = UidUtils.generateThingTypeUID(device);
-    ThingType tt = thingTypeProvider.getThingType(thingTypeUID, Locale.getDefault());
-    if (tt == null || device.isGatewayExtras()) {
-        logger.debug("String_Node_Str", device.getType(), device.getDatapointCount());
-        List<ChannelGroupType> groupTypes = new ArrayList<ChannelGroupType>();
-        for (HmChannel channel : device.getChannels()) {
-            List<ChannelDefinition> channelDefinitions = new ArrayList<ChannelDefinition>();
-            for (HmDatapoint dp : channel.getDatapoints().values()) {
-                if (!isStatusDatapoint(dp) && !isIgnoredDatapoint(dp)) {
-                    if (dp.getParamsetType() == HmParamsetType.VALUES) {
-                        ChannelTypeUID channelTypeUID = UidUtils.generateChannelTypeUID(dp);
-                        ChannelType channelType = channelTypeProvider.getChannelType(channelTypeUID, Locale.getDefault());
-                        if (channelType == null) {
-                            channelType = createChannelType(dp, channelTypeUID);
-                            channelTypeProvider.addChannelType(channelType);
+    if (thingTypeProvider != null) {
+        ThingTypeUID thingTypeUID = UidUtils.generateThingTypeUID(device);
+        ThingType tt = thingTypeProvider.getThingType(thingTypeUID, Locale.getDefault());
+        if (tt == null || device.isGatewayExtras()) {
+            logger.debug("String_Node_Str", device.getType(), device.getDatapointCount());
+            List<ChannelGroupType> groupTypes = new ArrayList<ChannelGroupType>();
+            for (HmChannel channel : device.getChannels()) {
+                List<ChannelDefinition> channelDefinitions = new ArrayList<ChannelDefinition>();
+                for (HmDatapoint dp : channel.getDatapoints().values()) {
+                    if (!isStatusDatapoint(dp) && !isIgnoredDatapoint(dp)) {
+                        if (dp.getParamsetType() == HmParamsetType.VALUES) {
+                            ChannelTypeUID channelTypeUID = UidUtils.generateChannelTypeUID(dp);
+                            ChannelType channelType = channelTypeProvider.getChannelType(channelTypeUID, Locale.getDefault());
+                            if (channelType == null) {
+                                channelType = createChannelType(dp, channelTypeUID);
+                                channelTypeProvider.addChannelType(channelType);
+                            }
+                            ChannelDefinition channelDef = new ChannelDefinition(dp.getName(), channelType.getUID());
+                            channelDefinitions.add(channelDef);
                         }


Input:
public static void use(Player player, Object packet) {
    try {
        if (packet == null) {
            return;
        }
        if (!packet.getClass().equals(USE_ENTITY_CLASS)) {
            return;
        }
        if (PACKET_ACTION_FIELD == null) {
            return;
        }
        int id = PACKET_ID_FIELD.getInt(packet);
        Object actionEnum = PACKET_ACTION_FIELD.get(packet);
        if (actionEnum == null) {
            return;
        }
        call(player, id, actionEnum.toString());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
         }
-        call(player, id, actionEnum.toString());
+        call(player, id, actionEnum.toString(), enumHand.toString());
     } catch (Exception e) {


Input:
public Image getImage(Object element) {
    if (element instanceof Repository)
        return RepositoryTreeNodeType.REPO.getIcon();
    if (element instanceof RefNode)
        return getRefIcon(((RefNode) element).getObject());
    if (element instanceof Ref)
        return getRefIcon((Ref) element);
    if (element instanceof GitModelBlob || element instanceof GitModelTree) {
        Object adapter = ((IAdaptable) element).getAdapter(IResource.class);
        return getWorkbenchLabelProvider().getImage(adapter);
    }
    if (element instanceof GitModelCommit || element instanceof GitModelCache || element instanceof GitModelWorkingTree || element instanceof RepositoryCommit)
        return getChangesetIcon();
    if (element instanceof GitModelRepository)
        return getImage(((GitModelRepository) element).getRepository());
    if (element instanceof ProjectRecord)
        return PlatformUI.getWorkbench().getSharedImages().getImage(SharedImages.IMG_OBJ_PROJECT);
    return super.getImage(element);
}

Output:
     if (element instanceof GitModelBlob || element instanceof GitModelTree) {
-        Object adapter = ((IAdaptable) element).getAdapter(IResource.class);
+        Object adapter = CommonUtils.getAdapter(((IAdaptable) element), IResource.class);
         return getWorkbenchLabelProvider().getImage(adapter);


Input:
public static List<XSDComplexTypeDefinition> getComplexTypes(XSDSchema xsd) {
    EList<XSDTypeDefinition> contents = xsd.getTypeDefinitions();
    List<XSDComplexTypeDefinition> complexs = new ArrayList<XSDComplexTypeDefinition>();
    for (XSDTypeDefinition type : contents) {
        if (type instanceof XSDComplexTypeDefinition) {
            boolean exist = false;
            for (XSDComplexTypeDefinition xsdEl : complexs) {
                if (xsdEl.getName().equals(type.getName()) && xsdEl.getTargetNamespace() != null && type.getTargetNamespace() != null && xsdEl.getTargetNamespace().equals(type.getTargetNamespace())) {
                    exist = true;
                    break;
                } else if (xsdEl.getTargetNamespace() == null && type.getTargetNamespace() == null && xsdEl.getName().equals(type.getName())) {
                    exist = true;
                    break;
                }
            }
            if (!exist && (type.getTargetNamespace() != null && !type.getTargetNamespace().equals(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001)) || type.getTargetNamespace() == null) {
                complexs.add((XSDComplexTypeDefinition) type);
            }
        }
    }
    return complexs;
}

Output:
             }
-            if (!exist && (type.getTargetNamespace() != null && !type.getTargetNamespace().equals(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001)) || type.getTargetNamespace() == null) {
+            if (!exist && ((type.getTargetNamespace() != null && !type.getTargetNamespace().equals(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001)) || type.getTargetNamespace() == null)) {
                 complexs.add((XSDComplexTypeDefinition) type);


Input:
private Collection<MavenProject> getDescendants() {
    List<MavenProject> descendants = new ArrayList<MavenProject>();
    boolean add = true;
    for (MavenProject project : getHierarchy()) {
        if (project == exclusionPoint) {
            add = !add;
        } else if (add) {
            descendants.add(project);
        }
    }
    return descendants;
}

Output:
         if (project == exclusionPoint) {
-            add = !add;
-        } else if (add) {
+            break;
+        } else {
             descendants.add(project);


Input:
public void terminate(Throwable reason) {
    synchronized (mutex) {
        if (terminate != null)
            return;
        terminate = reason;
        willClose = true;
    }
    if ((channel != null) && channel.isConnected())
        channel.close();
}

Output:
     }
-    if ((channel != null) && channel.isConnected())
-        channel.close();
+    if (channel == null) {
+        listener.connectionFailed(this);
+    } else {
+        if (channel.isConnected())
+            try {
+                channel.close();
+            } catch (Exception ignored) {
+            }
+        Collection<RequestContext> requestsToRestore = new ArrayList<>();
+        for (RequestContext request : requests) {
+            if (request.getFuture().isDone())
+                continue;
+            boolean shouldRestore = restoreCurrent && (request.isIdempotent() || restoreNonIdempotentOperations);
+            if (shouldRestore)
+                requestsToRestore.add(request);
+            else
+                request.getFuture().failedWithCause(reason);
+        }
+        if (requestsToRestore.isEmpty())
+            listener.connectionTerminated(this);
+        else
+            listener.connectionTerminated(this, requestsToRestore);
+    }
 }


Input:
private void testGroupQuality() {
    recordGroup.initialize();
    groupingRecords.clear();
    recordGroup.setSeperateOutput(Boolean.TRUE);
    recordGroup.setIsOutputDistDetails(true);
    try {
        for (String[] inputRow : inputList) {
            recordGroup.doGroup(inputRow);
        }
        recordGroup.end();
    } catch (IOException e) {
        log.error(e.getMessage(), e);
    } catch (InterruptedException e) {
        log.error(e.getMessage(), e);
    }
    for (String[] rds : groupingRecords) {
        if (rds[0].equals("String_Node_Str")) {
            Assert.assertEquals(0.9768518573708005, Double.valueOf(rds[rds.length - 2]).doubleValue(), 0d);
        }
    }
}

Output:
 private void testGroupQuality() {
-    recordGroup.initialize();
+    try {
+        recordGroup.initialize();
+    } catch (InstantiationException e) {
+        log.error(e.getMessage(), e);
+        Assert.fail();
+    } catch (IllegalAccessException e) {
+        log.error(e.getMessage(), e);
+        Assert.fail();
+    } catch (ClassNotFoundException e) {
+        log.error(e.getMessage(), e);
+        Assert.fail();
+    }
     groupingRecords.clear();


Input:
public void put(Request req) {
    long now = System.currentTimeMillis();
    boolean sendEvictEvent = false;
    Record evictedRecord = null;
    if (req.value == null) {
        req.value = new Data();
    }
    Record record = getRecord(req);
    if (record != null && !record.isValid(now)) {
        if (record.isActive() && record.isEvictable()) {
            sendEvictEvent = true;
            evictedRecord = createNewRecord(record.getKeyData(), record.getValueData());
        }
        record.setValue(null);
        record.setMultiValues(null);
    }
    if (req.operation == CONCURRENT_MAP_PUT_IF_ABSENT) {
        if (record != null && record.isActive() && record.isValid(now) && record.getValueData() != null) {
            req.clearForResponse();
            req.response = record.getValueData();
            return;
        }
    } else if (req.operation == CONCURRENT_MAP_REPLACE_IF_NOT_NULL) {
        if (record == null || !record.isActive() || !record.isValid(now) || record.getValueData() == null) {
            req.value = null;
            return;
        }
    } else if (req.operation == CONCURRENT_MAP_REPLACE_IF_SAME) {
        if (record == null || !record.isActive() || !record.isValid(now)) {
            req.response = Boolean.FALSE;
            return;
        }
        MultiData multiData = (MultiData) toObject(req.value);
        if (multiData == null || multiData.size() != 2) {
            throw new RuntimeException("String_Node_Str" + multiData);
        }
        Data expectedOldValue = multiData.getData(0);
        req.value = multiData.getData(1);
        if (!expectedOldValue.equals(record.getValueData())) {
            req.response = Boolean.FALSE;
            return;
        }
    }
    Data oldValue = null;
    if (record == null) {
        record = createNewRecord(req.key, req.value);
        mapRecords.put(req.key, record);
    } else {
        markAsActive(record);
        oldValue = (record.isValid(now)) ? record.getValueData() : null;
        record.setValue(req.value);
        record.incrementVersion();
        record.setLastUpdated();
    }
    if (req.ttl > 0 && req.ttl < Long.MAX_VALUE) {
        record.setExpirationTime(req.ttl);
        ttlPerRecord = true;
    }
    if (sendEvictEvent) {
        concurrentMapManager.fireMapEvent(mapListeners, EntryEvent.TYPE_EVICTED, null, evictedRecord, req.caller);
    }
    if (oldValue == null) {
        concurrentMapManager.fireMapEvent(mapListeners, EntryEvent.TYPE_ADDED, null, record, req.caller);
    } else {
        fireInvalidation(record);
        concurrentMapManager.fireMapEvent(mapListeners, EntryEvent.TYPE_UPDATED, oldValue, record, req.caller);
    }
    if (req.txnId != -1 || req.operation == ClusterOperation.CONCURRENT_MAP_PUT_AND_UNLOCK) {
        unlock(record, req);
    }
    record.setIndexes(req.indexes, req.indexTypes);
    updateIndexes(record);
    markAsDirty(record);
    req.clearForResponse();
    req.version = record.getVersion();
    req.longValue = record.getCopyCount();
    if (localUpdateListener != null && req.txnId != Long.MIN_VALUE) {
        localUpdateListener.recordUpdated(record);
    }
    if (req.operation == CONCURRENT_MAP_REPLACE_IF_SAME || req.operation == CONCURRENT_MAP_SET) {
        req.response = Boolean.TRUE;
    } else {
        req.response = oldValue;
    }
}

Output:
     if (req.operation == CONCURRENT_MAP_PUT_IF_ABSENT) {
-        if (record != null && record.isActive() && record.isValid(now) && record.getValueData() != null) {
+        if (!isApplicable(CONCURRENT_MAP_PUT_IF_ABSENT, req, now)) {
             req.clearForResponse();


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.list_fragment_with_spinner, null);
    mListView = (ListView) view.findViewById(R.id.list);
    mProgressBar = (ProgressBar) view.findViewById(R.id.progress);
    if (mAdapter != null) {
        mListView.setAdapter(mAdapter);
        mListView.onRestoreInstanceState(mListState);
        mProgressBar.setVisibility(View.GONE);
    }
    return view;
}

Output:
 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-    View view = inflater.inflate(R.layout.list_fragment_with_spinner, null);
+    View view = inflater.inflate(R.layout.list_view_with_spinner, null);
     mListView = (ListView) view.findViewById(R.id.list);


Input:
public static Map<String, Object> getReconResults(List<Map<String, Object>> entryList, String reconId, boolean formatted) {
    Map<String, Object> results = new HashMap<String, Object>();
    List<Map<String, Object>> resultEntries = new ArrayList<Map<String, Object>>();
    if (formatted) {
        if (reconId != null) {
            for (Map<String, Object> entry : entryList) {
                if (reconId.equals(entry.get("String_Node_Str"))) {
                    if ("String_Node_Str".equals(entry.get("String_Node_Str"))) {
                        results.put("String_Node_Str", AuditServiceImpl.formatReconEntry(entry));
                    } else if ("String_Node_Str".equals(entry.get("String_Node_Str"))) {
                        results.put("String_Node_Str", AuditServiceImpl.formatReconEntry(entry));
                    } else {
                        resultEntries.add(AuditServiceImpl.formatReconEntry(entry));
                    }
                }
            }
        } else {
            for (Map<String, Object> entry : entryList) {
                resultEntries.add(AuditServiceImpl.formatReconEntry(entry));
            }
        }
        if (resultEntries.size() > 0) {
            results.put("String_Node_Str", resultEntries);
        }
    } else {
        results.put("String_Node_Str", entryList);
    }
    return results;
}

Output:
     if (formatted) {
-        if (reconId != null) {
-            for (Map<String, Object> entry : entryList) {
-                if (reconId.equals(entry.get("String_Node_Str"))) {
-                    if ("String_Node_Str".equals(entry.get("String_Node_Str"))) {
-                        results.put("String_Node_Str", AuditServiceImpl.formatReconEntry(entry));
-                    } else if ("String_Node_Str".equals(entry.get("String_Node_Str"))) {
-                        results.put("String_Node_Str", AuditServiceImpl.formatReconEntry(entry));
-                    } else {
-                        resultEntries.add(AuditServiceImpl.formatReconEntry(entry));
-                    }
-                }
-            }
-        } else {
-            for (Map<String, Object> entry : entryList) {
-                resultEntries.add(AuditServiceImpl.formatReconEntry(entry));
-            }
+        List<Map<String, Object>> resultEntries = new ArrayList<Map<String, Object>>();
+        for (Map<String, Object> entry : entryList) {
+            resultEntries.add(AuditServiceImpl.formatReconEntry(entry));
         }


Input:
private void storageLimitExceeded(UploadItem uploadItem) {
    MFConfiguration.getErrorTracker().i(TAG, "String_Node_Str");
    notifyUploadListenerCancelled(uploadItem);
}

Output:
 private void storageLimitExceeded(UploadItem uploadItem) {
-    MFConfiguration.getErrorTracker().i(TAG, "String_Node_Str");
+    MFConfiguration.getStaticMFLogger().logMessage(TAG, "String_Node_Str");
     notifyUploadListenerCancelled(uploadItem);


Input:
public static BitmapDrawable getAztecPlaceholderDrawableFromResID(Context context, int drawableId, int maxImageSizeForVisualEditor) {
    Drawable drawable = ContextCompat.getDrawable(context, drawableId);
    Bitmap bitmap;
    if (drawable instanceof BitmapDrawable) {
        bitmap = ((BitmapDrawable) drawable).getBitmap();
        bitmap = ImageUtils.getScaledBitmapAtLongestSide(bitmap, maxImageSizeForVisualEditor);
    } else if (drawable instanceof VectorDrawableCompat || drawable instanceof VectorDrawable) {
        bitmap = Bitmap.createBitmap(maxImageSizeForVisualEditor, maxImageSizeForVisualEditor, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);
    } else {
        throw new IllegalArgumentException("String_Node_Str" + drawable.getClass().getName());
    }
    bitmap.setDensity(DisplayMetrics.DENSITY_DEFAULT);
    return new BitmapDrawable(context.getResources(), bitmap);
}

Output:
         bitmap = ImageUtils.getScaledBitmapAtLongestSide(bitmap, maxImageSizeForVisualEditor);
-    } else if (drawable instanceof VectorDrawableCompat || drawable instanceof VectorDrawable) {
+    } else if (drawable instanceof VectorDrawableCompat || Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && drawable instanceof VectorDrawable) {
         bitmap = Bitmap.createBitmap(maxImageSizeForVisualEditor, maxImageSizeForVisualEditor, Bitmap.Config.ARGB_8888);


Input:
public void testHeaders1() throws Exception {
    BitcoinSerializer bs = new BitcoinSerializer(MainNetParams.get());
    String headersMessageBytesHex = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    byte[] headersMessageBytes = HEX.decode(headersMessageBytesHex);
    HeadersMessage hm = (HeadersMessage) bs.deserialize(ByteBuffer.wrap(headersMessageBytes));
    Block block = hm.getBlockHeaders().get(0);
    String hash = block.getHashAsString();
    assertEquals(hash, "String_Node_Str");
    assertNull(block.transactions);
    assertEquals(Utils.HEX.encode(block.getMerkleRoot().getBytes()), "String_Node_Str");
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    bs.serialize(hm, byteArrayOutputStream);
    byte[] serializedBytes = byteArrayOutputStream.toByteArray();
    String serializedBytesHex = new String(HEX.encode(serializedBytes));
    assertEquals(headersMessageBytes.length, serializedBytes.length);
    assertEquals(true, Arrays.equals(headersMessageBytes, serializedBytes));
}

Output:
     byte[] serializedBytes = byteArrayOutputStream.toByteArray();
-    String serializedBytesHex = new String(HEX.encode(serializedBytes));
+    String serializedBytesHex = HEX.encode(serializedBytes);
     assertEquals(headersMessageBytes.length, serializedBytes.length);


Input:
public ValueInsertionResult write(String channelName, DataHubCompositeValue columnValue) {
    Mutator<String> mutator = connector.buildMutator(StringSerializer.get());
    DataHubKey key = keyGenerator.newKey();
    String columnName = keyRenderer.keyToString(key);
    HColumn<String, DataHubCompositeValue> column = hector.createColumn(columnName, columnValue, StringSerializer.get(), DataHubCompositeValueSerializer.get());
    String rowKey = rowKeyStrategy.buildKey(channelName, key);
    try {
        mutator.insert(rowKey, channelName, column);
    } catch (HInvalidRequestException e) {
        if (e.getMessage().contains("String_Node_Str")) {
            throw new NoSuchChannelException("String_Node_Str" + channelName, e);
        }
        throw e;
    }
    return new ValueInsertionResult(key);
}

Output:
     } catch (HInvalidRequestException e) {
-        if (e.getMessage().contains("String_Node_Str")) {
-            throw new NoSuchChannelException("String_Node_Str" + channelName, e);
-        }
-        throw e;
+        throw maybePromoteToNoSuchChannel(e, channelName);
     }


Input:
public void onConnectionSuccess(DeviceService service) {
    if (isConnected()) {
        DiscoveryManager.getInstance().getConnectableDeviceStore().addDevice(this);
        if (listener != null)
            listener.onDeviceReady(ConnectableDevice.this);
        setLastConnected(Util.getTime());
    }
}

Output:
     if (isConnected()) {
-        DiscoveryManager.getInstance().getConnectableDeviceStore().addDevice(this);
+        if (DiscoveryManager.getInstance().getConnectableDeviceStore() != null)
+            DiscoveryManager.getInstance().getConnectableDeviceStore().addDevice(this);
         if (listener != null)


Input:
public static int updateBySpecialChain(Dao dao, Entity en, String tableName, Chain chain, Condition cnd) {
    if (en != null)
        tableName = en.getTableName();
    if (tableName == null)
        throw Lang.makeThrow(DaoException.class, "String_Node_Str");
    final StringBuilder sql = new StringBuilder("String_Node_Str").append(tableName).append("String_Node_Str");
    Chain head = chain.head();
    final List<Object> values = new ArrayList<Object>();
    final List<ValueAdaptor> adaptors = new ArrayList<ValueAdaptor>();
    while (head != null) {
        MappingField mf = null;
        if (en != null)
            mf = en.getField(head.name());
        String colName = head.name();
        if (mf != null)
            colName = mf.getColumnName();
        sql.append(colName).append("String_Node_Str");
        if (head.special()) {
            if ("String_Node_Str".equals(head.value()) || "String_Node_Str".equals(head.value())) {
                sql.append(colName);
            }
            sql.append(head.value());
        } else {
            sql.append("String_Node_Str");
            values.add(head.value());
            ValueAdaptor adaptor = Jdbcs.getAdaptorBy(head.value());
            if (mf != null && mf.getAdaptor() != null)
                adaptor = mf.getAdaptor();
            adaptors.add(adaptor);
        }
        sql.append("String_Node_Str");
        head = head.next();
        if (head != null)
            sql.append("String_Node_Str");
    }
    if (cnd != null)
        sql.append("String_Node_Str").append(cnd.toSql(en));
    if (log.isDebugEnabled())
        log.debug(sql);
    final int[] ints = new int[1];
    dao.run(new ConnCallback() {
        public void invoke(Connection conn) throws Exception {
            PreparedStatement ps = conn.prepareStatement(sql.toString());
            try {
                for (int i = 0; i < values.size(); i++) adaptors.get(i).set(ps, values.get(i), i + 1);
                ints[0] = ps.executeUpdate();
            } finally {
                Daos.safeClose(ps);
            }
        }
    });
    return ints[0];
}

Output:
         if (head.special()) {
-            if ("String_Node_Str".equals(head.value()) || "String_Node_Str".equals(head.value())) {
-                sql.append(colName);
+            if (head.value() != null && head.value() instanceof String) {
+                String str = (String) head.value();
+                if (str.length() > 0) {
+                    switch(str.charAt(0)) {
+                        case '+':
+                        case '-':
+                        case '*':
+                        case '/':
+                        case '%':
+                        case '&':
+                        case '^':
+                        case '|':
+                            sql.append(colName);
+                            break;
+                    }
+                }
             }


Input:
public void setSampleValue(String formatToken, int sampleIndex, String value) {
    int formatFieldIndex = formatTypeToFormatFieldIndex.get(formatToken);
    setSampleValue(formatFieldIndex, sampleIndex, value);
}

Output:
 public void setSampleValue(String formatToken, int sampleIndex, String value) {
-    int formatFieldIndex = formatTypeToFormatFieldIndex.get(formatToken);
+    int formatFieldIndex = formatTypeToFormatFieldIndex.getInt(formatToken);
     setSampleValue(formatFieldIndex, sampleIndex, value);


Input:
public void setPosition(int newX, int newY) {
    if (newX > 0 && newY > 0) {
        x = newX;
        y = newY;
    }
}

Output:
 public void setPosition(int newX, int newY) {
-    if (newX > 0 && newY > 0) {
+    if (newX >= 0 && newY >= 0) {
         x = newX;


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

Output:
         final long tid = getThread().getId();
-        if (writeLockedBy.get() == tid) {
+        if (writeLockedBy == tid) {
             holds.get().count++;


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (savedInstanceState != null) {
        mResultIsMap = savedInstanceState.getBoolean(EXTRA_IS_MAP, false);
    }
    setContentView(R.layout.entity_select_layout);
    searchbox = (EditText) findViewById(R.id.searchbox);
    header = (LinearLayout) findViewById(R.id.entity_select_header);
    barcodeButton = (ImageButton) findViewById(R.id.barcodeButton);
    searchbox.addTextChangedListener(this);
    searchbox.requestFocus();
    session = CommCareApplication._().getCurrentSession();
    Vector<Entry> entries = session.getEntriesForCommand(session.getCommand());
    prototype = entries.elementAt(0);
    setTitle(getString(R.string.application_name) + "String_Node_Str" + "String_Node_Str");
    selectDatum = session.getNeededDatum();
    barcodeButton.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            Intent i = new Intent("String_Node_Str");
            try {
                startActivityForResult(i, BARCODE_FETCH);
            } catch (ActivityNotFoundException anfe) {
                Toast noReader = Toast.makeText(EntitySelectActivity.this, "String_Node_Str", Toast.LENGTH_LONG);
                noReader.show();
            }
        }
    });
    if (selectDatum.getLongDetail() != null && this.getIntent().hasExtra(EXTRA_ENTITY_KEY)) {
        TreeReference entity = getEntityFromID(this.getIntent().getStringExtra(EXTRA_ENTITY_KEY));
        if (entity != null) {
            Intent i = getDetailIntent(entity);
            startActivityForResult(i, CONFIRM_SELECT);
        } else {
            refreshView();
        }
    } else {
        refreshView();
    }
}

Output:
     });
-    if (selectDatum.getLongDetail() != null && this.getIntent().hasExtra(EXTRA_ENTITY_KEY)) {
-        TreeReference entity = getEntityFromID(this.getIntent().getStringExtra(EXTRA_ENTITY_KEY));
-        if (entity != null) {
-            Intent i = getDetailIntent(entity);
-            startActivityForResult(i, CONFIRM_SELECT);
-        } else {
-            refreshView();
-        }
-    } else {
-        refreshView();
-    }
+    searchbox.addTextChangedListener(this);
+    searchbox.requestFocus();
 }