Input:
private void generateAsynchronousProxyMethod(SourceWriter w, JMethod method) {
    JType returnType = method.getReturnType();
    JParameter[] params = method.getParameters();
    NameFactory nameFactory = new NameFactory();
    for (int i = 0; i < params.length; ++i) {
        nameFactory.addName(params[i].getName());
    }
    w.println();
    w.print("String_Node_Str" + method.getName() + "String_Node_Str");
    int i;
    for (i = 0; i < params.length; i++) {
        JParameter param = params[i];
        w.print((i > 0 ? "String_Node_Str" : "String_Node_Str") + getJavaTypeName(param.getType()) + "String_Node_Str" + param.getName());
    }
    w.println((i > 0 ? "String_Node_Str" : "String_Node_Str") + AsyncCallback.class.getName() + "String_Node_Str");
    w.indent();
    w.println("String_Node_Str" + SERIALIZATION_STREAM_READER_INSTANTIATION);
    w.println("String_Node_Str" + SERIALIZATION_STREAM_WRITER_INSTANTIATION);
    w.println("String_Node_Str");
    w.indent();
    {
        w.print("String_Node_Str" + method.getName() + "String_Node_Str");
        for (i = 0; i < params.length; i++) {
            w.print("String_Node_Str" + params[i].getName());
        }
        w.println("String_Node_Str");
    }
    w.outdent();
    String exceptionName = nameFactory.createName("String_Node_Str");
    w.println("String_Node_Str" + SerializationException.class.getName() + "String_Node_Str" + exceptionName + "String_Node_Str");
    w.indentln("String_Node_Str" + InvocationException.class.getName() + "String_Node_Str" + exceptionName + "String_Node_Str");
    w.indentln("String_Node_Str");
    w.println("String_Node_Str");
    w.println(ResponseTextHandler.class.getName() + "String_Node_Str" + ResponseTextHandler.class.getName() + "String_Node_Str");
    w.indent();
    {
        w.println("String_Node_Str");
        w.indent();
        {
            w.println("String_Node_Str");
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
        }
        w.outdent();
        w.println("String_Node_Str");
        w.println("String_Node_Str");
        w.indent();
        {
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
            w.println("String_Node_Str");
        }
        w.outdent();
        w.println("String_Node_Str");
        w.println("String_Node_Str");
        w.indent();
        {
            w.println("String_Node_Str");
            w.println("String_Node_Str");
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
                w.indent();
                {
                    w.println("String_Node_Str");
                    w.print("String_Node_Str");
                    JPrimitiveType primitive = returnType.isPrimitive();
                    if (primitive == JPrimitiveType.VOID) {
                        w.print("String_Node_Str");
                    } else {
                        if (primitive != null) {
                            w.print("String_Node_Str");
                            w.print(getObjectWrapperName(primitive));
                            w.print("String_Node_Str");
                            generateDecodeCall(w, returnType);
                            w.print("String_Node_Str");
                        } else {
                            generateDecodeCall(w, returnType);
                        }
                    }
                    w.println("String_Node_Str");
                }
                w.outdent();
                w.println("String_Node_Str");
                w.indent();
                {
                    w.println("String_Node_Str");
                    w.println("String_Node_Str");
                }
                w.outdent();
                w.println("String_Node_Str");
                w.indent();
                {
                    w.println("String_Node_Str" + InvocationException.class.getName() + "String_Node_Str");
                }
                w.outdent();
                w.println("String_Node_Str");
            }
            w.outdent();
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
            w.println("String_Node_Str");
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
            w.println("String_Node_Str");
            w.indent();
            {
                w.println("String_Node_Str");
            }
            w.outdent();
        }
        w.outdent();
        w.println("String_Node_Str");
    }
    w.outdent();
    w.println("String_Node_Str");
    w.println("String_Node_Str");
    w.indentln("String_Node_Str" + InvocationException.class.getName() + "String_Node_Str");
    w.outdent();
    w.println("String_Node_Str");
}

Output:
     w.println("String_Node_Str" + SerializationException.class.getName() + "String_Node_Str" + exceptionName + "String_Node_Str");
-    w.indentln("String_Node_Str" + InvocationException.class.getName() + "String_Node_Str" + exceptionName + "String_Node_Str");
+    w.indentln("String_Node_Str" + exceptionName + "String_Node_Str");
     w.indentln("String_Node_Str");


Input:
public void doNextWriteCheck() {
    if (!writing.compareAndSet(false, true)) {
        return;
    }
    if (writeQueue.isEmpty()) {
        return;
    }
    try {
        boolean noMoreData = write0();
        if (noMoreData && writeQueue.isEmpty()) {
            if ((processKey.isValid() && (processKey.interestOps() & SelectionKey.OP_WRITE) != 0)) {
                disableWrite();
            }
        } else {
            if ((processKey.isValid() && (processKey.interestOps() & SelectionKey.OP_WRITE) == 0)) {
                enableWrite(false);
            }
        }
    } catch (IOException e) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("String_Node_Str", e);
        }
        close("String_Node_Str" + e);
    } finally {
        writing.set(false);
    }
}

Output:
 public void doNextWriteCheck() {
-    if (!writing.compareAndSet(false, true)) {
+    if (writeQueue.isEmpty()) {
         return;


Input:
public void copyRankingInformation(NotificationRecord previous) {
    mContactAffinity = previous.mContactAffinity;
    mRecentlyIntrusive = previous.mRecentlyIntrusive;
    mPackagePriority = previous.mPackagePriority;
    mPackageVisibility = previous.mPackageVisibility;
    mIntercept = previous.mIntercept;
    mRankingTimeMs = calculateRankingTimeMs(previous.getRankingTimeMs());
    mCreationTimeMs = previous.mCreationTimeMs;
    mVisibleSinceMs = previous.mVisibleSinceMs;
    if (previous.sbn.getOverrideGroupKey() != null) {
        sbn.setOverrideGroupKey(previous.sbn.getOverrideGroupKey());
    }
}

Output:
     mVisibleSinceMs = previous.mVisibleSinceMs;
-    if (previous.sbn.getOverrideGroupKey() != null) {
+    if (previous.sbn.getOverrideGroupKey() != null && !sbn.isAppGroup()) {
         sbn.setOverrideGroupKey(previous.sbn.getOverrideGroupKey());


Input:
public void execute() throws ServletException, IOException, ActionException {
    InputStream resourceIStream = null;
    try {
        resourceIStream = getClass().getResourceAsStream("String_Node_Str" + resourcePath);
        if (resourceIStream == null) {
            getContext().getResponse().sendError(HttpServletResponse.SC_NOT_FOUND);
            throw new ActionException("String_Node_Str" + resourcePath + "String_Node_Str");
        }
        String extension = resourcePath.substring(resourcePath.lastIndexOf('.') + 1).toLowerCase();
        String contentType = CONTENT_TYPES.get(extension);
        if (contentType != null) {
            getContext().setContentType(contentType);
            if (contentType.startsWith("String_Node_Str")) {
                getContext().getResponse().setCharacterEncoding("String_Node_Str");
            }
        }
        getContext().getResponse().setHeader("String_Node_Str", "String_Node_Str");
        copyStream(resourceIStream);
    } finally {
        if (resourceIStream != null) {
            resourceIStream.close();
        }
    }
}

Output:
         if (resourceIStream == null) {
-            getContext().getResponse().sendError(HttpServletResponse.SC_NOT_FOUND);
+            getContext().getResponse().setStatus(HttpServletResponse.SC_NOT_FOUND);
             throw new ActionException("String_Node_Str" + resourcePath + "String_Node_Str");


Input:
private void createIndicatorParameters(TreeItem indicatorItem, IndicatorUnit indicatorUnit) {
    TreeItem[] items = indicatorItem.getItems();
    if (indicatorItem != null && !indicatorItem.isDisposed()) {
        for (TreeItem treeItem : items) {
            treeItem.dispose();
        }
    }
    IndicatorParameters parameters = indicatorUnit.getIndicator().getParameters();
    if (parameters == null) {
        return;
    }
    TreeItem iParamItem = new TreeItem(indicatorItem, SWT.NONE);
    iParamItem.setText(0, "String_Node_Str" + parameters.getTopN());
    TextParameters tParameter = parameters.getTextParameter();
    if (tParameter != null) {
        final TreeItem tParamItem = new TreeItem(indicatorItem, SWT.NONE);
        tParamItem.setText(0, "String_Node_Str");
        TreeItem item = new TreeItem(tParamItem, SWT.NONE);
        item.setText("String_Node_Str" + tParameter.isUseBlank());
        item = new TreeItem(tParamItem, SWT.NONE);
        item.setText("String_Node_Str" + tParameter.isIgnoreCase());
        item = new TreeItem(tParamItem, SWT.NONE);
        item.setText("String_Node_Str" + tParameter.isUseNulls());
    }
    DateParameters dParameters = parameters.getDateParameters();
    if (dParameters != null) {
        final TreeItem tParamItem = new TreeItem(indicatorItem, SWT.NONE);
        tParamItem.setText(0, "String_Node_Str");
        TreeItem item = new TreeItem(tParamItem, SWT.NONE);
        item.setText("String_Node_Str" + dParameters.getDateAggregationType().getName() + "String_Node_Str");
    }
    iParamItem = new TreeItem(indicatorItem, SWT.NONE);
    iParamItem.setText(0, "String_Node_Str" + (parameters.getDataValidDomain() != null));
    iParamItem = new TreeItem(indicatorItem, SWT.NONE);
    iParamItem.setText(0, "String_Node_Str" + (parameters.getIndicatorValidDomain() != null));
    iParamItem = new TreeItem(indicatorItem, SWT.NONE);
    iParamItem.setText(0, "String_Node_Str" + (parameters.getBins() != null));
}

Output:
         for (TreeItem treeItem : items) {
-            treeItem.dispose();
+            if (DATA_PARAM.equals(treeItem.getData(DATA_PARAM))) {
+                treeItem.dispose();
+            }
         }


Input:
private void updateSecuritySandbox() throws MojoExecutionException {
    File fpTrustFolder = FlashPlayerUtils.getTrustDir();
    File mavenCfg = new File(fpTrustFolder, "String_Node_Str");
    if (!mavenCfg.exists()) {
        try {
            mavenCfg.createNewFile();
        } catch (IOException e) {
            throw new MojoExecutionException("String_Node_Str" + mavenCfg.getAbsolutePath(), e);
        }
    }
    try {
        FileReader input = new FileReader(mavenCfg);
        String cfg = IOUtils.toString(input);
        input.close();
        String trustedFile = outputFile.getAbsolutePath();
        if (cfg.contains(trustedFile)) {
            getLog().info("String_Node_Str" + trustedFile);
            return;
        } else {
            getLog().info("String_Node_Str" + trustedFile);
        }
        if (!cfg.endsWith("String_Node_Str")) {
            cfg = cfg + '\n';
        }
        cfg = cfg + trustedFile + '\n';
        FileWriter output = new FileWriter(mavenCfg);
        IOUtils.write(cfg, output);
        output.flush();
        output.close();
    } catch (IOException e) {
        throw new MojoExecutionException("String_Node_Str" + mavenCfg.getAbsolutePath(), e);
    }
}

Output:
         input.close();
-        String trustedFile = outputFile.getAbsolutePath();
+        String trustedFile = getOutput().getAbsolutePath();
         if (cfg.contains(trustedFile)) {


Input:
protected Map<String, String> initEnv(Job ji2) throws CloudServiceException {
    LOG.info("String_Node_Str");
    Map<String, String> hEnv = new HashMap<String, String>();
    if ((ji2.getFileDependencies() != null) && (!ji2.getFileDependencies().isEmpty())) {
        hEnv.put("String_Node_Str", ji2.getFileDependencies());
    }
    Set<String> clusterConfigs = this.cluster.getConfigs();
    hEnv.put("String_Node_Str", convertCollectionToCSV(clusterConfigs));
    Command command = null;
    Application application = null;
    boolean done = false;
    if ((ji2.getCommandId() != null) && (!(ji2.getCommandId().isEmpty()))) {
        String cmdId = ji2.getCommandId();
        command = this.em.find(Command.class, cmdId);
        for (final Application ace : command.getApplications()) {
            if ((ji2.getApplicationId() != null) && ((!ji2.getApplicationId().isEmpty()))) {
                if (ace.getId().equals(ji2.getApplicationId())) {
                    application = ace;
                    break;
                }
            } else if ((ji2.getApplicationName() != null) && ((!ji2.getApplicationName().isEmpty()))) {
                if (ace.getName().equals(ji2.getApplicationName())) {
                    application = ace;
                    break;
                }
            } else {
                application = ace;
                break;
            }
        }
    } else if ((ji2.getCommandName() != null) && (!(ji2.getCommandName().isEmpty()))) {
        for (final Command cce : cluster.getCommands()) {
            if (cce.getName().equals(ji2.getCommandName())) {
                for (final Application ace : cce.getApplications()) {
                    if ((ji2.getApplicationId() != null) && ((!ji2.getApplicationId().isEmpty()))) {
                        if (ace.getId().equals(ji2.getApplicationId())) {
                            command = cce;
                            application = ace;
                            done = true;
                            break;
                        }
                    } else if ((ji2.getApplicationName() != null) && ((!ji2.getApplicationName().isEmpty()))) {
                        if (ace.getName().equals(ji2.getApplicationName())) {
                            command = cce;
                            application = ace;
                            done = true;
                            break;
                        }
                    } else {
                        command = cce;
                        application = ace;
                        done = true;
                        break;
                    }
                }
                if (done) {
                    break;
                }
            }
        }
    }
    if (command == null) {
        final String msg = "String_Node_Str";
        LOG.error(msg);
        throw new CloudServiceException(HttpURLConnection.HTTP_INTERNAL_ERROR, msg);
    }
    ji2.setCommandId(command.getId());
    ji2.setCommandName(command.getName());
    if (application != null) {
        ji2.setApplicationId(application.getId());
        ji2.setApplicationName(application.getName());
        if ((application.getConfigs() != null) && (!application.getConfigs().isEmpty())) {
            hEnv.put("String_Node_Str", convertCollectionToCSV(application.getConfigs()));
        }
        if ((application.getJars() != null) && (!application.getJars().isEmpty())) {
            hEnv.put("String_Node_Str", convertCollectionToCSV(application.getJars()));
        }
        if ((application.getEnvPropFile() != null) && (!application.getEnvPropFile().isEmpty())) {
            hEnv.put("String_Node_Str", application.getEnvPropFile());
        }
    }
    if ((command.getConfigs() != null) && (!command.getConfigs().isEmpty())) {
        hEnv.put("String_Node_Str", convertCollectionToCSV(command.getConfigs()));
    }
    this.executable = command.getExecutable();
    ji2.setExecutionClusterName(cluster.getName());
    ji2.setExecutionClusterId(cluster.getId());
    if ((command.getEnvPropFile() != null) && (!command.getEnvPropFile().isEmpty())) {
        hEnv.put("String_Node_Str", command.getEnvPropFile());
    }
    if ((ji2.getEnvPropFile() != null) && (!ji2.getEnvPropFile().isEmpty())) {
        hEnv.put("String_Node_Str", ji2.getEnvPropFile());
    }
    hEnv.put("String_Node_Str", ji2.getUser());
    hEnv.put("String_Node_Str", ji2.getUser());
    String groupName = HADOOP_GROUP_NAME;
    if (ji2.getGroup() != null) {
        groupName = ji2.getGroup();
        hEnv.put("String_Node_Str", groupName);
    }
    hEnv.put("String_Node_Str", groupName);
    String javaHome = ConfigurationManager.getConfigInstance().getString("String_Node_Str");
    if ((javaHome != null) && (!javaHome.isEmpty())) {
        hEnv.put("String_Node_Str", javaHome);
    }
    String genieHome = ConfigurationManager.getConfigInstance().getString("String_Node_Str");
    if ((genieHome == null) || genieHome.isEmpty()) {
        String msg = "String_Node_Str";
        LOG.error(msg);
        throw new CloudServiceException(HttpURLConnection.HTTP_INTERNAL_ERROR, msg);
    }
    hEnv.put("String_Node_Str", genieHome);
    String hadoopHome;
    if (cluster.getVersion() != null) {
        String hadoopVersion = cluster.getVersion();
        LOG.debug("String_Node_Str" + hadoopVersion);
        hadoopHome = ConfigurationManager.getConfigInstance().getString("String_Node_Str" + hadoopVersion + "String_Node_Str");
        if (hadoopHome == null) {
            hadoopVersion = StringUtil.trimVersion(hadoopVersion);
            hadoopHome = ConfigurationManager.getConfigInstance().getString("String_Node_Str" + hadoopVersion + "String_Node_Str");
        }
        if ((hadoopHome == null) || (!new File(hadoopHome).exists())) {
            String msg = "String_Node_Str" + hadoopVersion;
            LOG.error(msg);
            throw new CloudServiceException(HttpURLConnection.HTTP_INTERNAL_ERROR, msg);
        }
        LOG.info("String_Node_Str" + hadoopHome);
        hEnv.put("String_Node_Str", hadoopHome);
    } else {
        hadoopHome = ConfigurationManager.getConfigInstance().getString("String_Node_Str");
        if ((hadoopHome == null) || (!new File(hadoopHome).exists())) {
            String msg = "String_Node_Str";
            LOG.error(msg);
            throw new CloudServiceException(HttpURLConnection.HTTP_INTERNAL_ERROR, msg);
        }
        hEnv.put("String_Node_Str", hadoopHome);
    }
    hEnv.put("String_Node_Str", ConfigurationManager.getConfigInstance().getString("String_Node_Str", "String_Node_Str"));
    String cpOpts;
    cpOpts = ConfigurationManager.getConfigInstance().getString("String_Node_Str", "String_Node_Str");
    String copyCommand = hadoopHome + "String_Node_Str" + cpOpts + "String_Node_Str";
    hEnv.put("String_Node_Str", copyCommand);
    String mkdirCommand = hadoopHome + "String_Node_Str" + cpOpts + "String_Node_Str";
    hEnv.put("String_Node_Str", mkdirCommand);
    String baseUserWorkingDir = ConfigurationManager.getConfigInstance().getString("String_Node_Str");
    if ((baseUserWorkingDir == null) || (baseUserWorkingDir.isEmpty())) {
        String msg = "String_Node_Str";
        LOG.error(msg);
        throw new CloudServiceException(HttpURLConnection.HTTP_INTERNAL_ERROR, msg);
    } else {
        hEnv.put("String_Node_Str", baseUserWorkingDir);
    }
    if (!ji2.isDisableLogArchival()) {
        String s3ArchiveLocation = ConfigurationManager.getConfigInstance().getString("String_Node_Str");
        if ((s3ArchiveLocation != null) && (!s3ArchiveLocation.isEmpty())) {
            hEnv.put("String_Node_Str", s3ArchiveLocation);
        }
    }
    hEnv.put("String_Node_Str", genieJobIDProp + "String_Node_Str" + netflixEnvProp + "String_Node_Str" + lipstickUuidProp);
    return hEnv;
}

Output:
     String hadoopHome;
-    if (cluster.getVersion() != null) {
+    if (this.cluster.getVersion() != null) {
         String hadoopVersion = cluster.getVersion();


Input:
public static HashMap<String, Object> parse(String json, String basic, String... keys) {
    Log.i("String_Node_Str", json);
    HashMap<String, Object> results = new HashMap<String, Object>();
    if (json != null) {
        try {
            JSONObject main = new JSONObject(json).getJSONObject(basic);
            String error = main.getString("String_Node_Str");
            results.put("String_Node_Str", error);
            if (error.equals("String_Node_Str")) {
                for (int i = 0; i < keys.length; i++) {
                    if (main.has(keys[i]))
                        results.put(keys[i], main.get(keys[i]));
                }
            }
        } catch (JSONException e) {
            Log.e(TAG, "String_Node_Str");
            e.printStackTrace();
        }
    } else {
        results.put("String_Node_Str", "String_Node_Str");
        Log.e(TAG, "String_Node_Str");
    }
    return results;
}

Output:
     HashMap<String, Object> results = new HashMap<String, Object>();
-    if (json != null) {
+    if (json != null && !json.equals("String_Node_Str")) {
+        Log.i("String_Node_Str", json);
         try {


Input:
private void populateMessage2(QName parameter, String portTypeName, String operationName, File schemaFile, Collection<XmlFileConnectionItem> selectItems, File zip) throws IOException {
    String name = parameter.getLocalPart();
    XmlFileConnection connection = null;
    Property connectionProperty = null;
    XmlFileConnectionItem connectionItem = null;
    String oldConnectionId = null;
    String oldTableId = null;
    IMetadataTable oldMetadataTable = null;
    Map<String, String> oldTableMap = null;
    if (selectItems.size() > 0) {
        boolean needRewrite = false;
        for (XmlFileConnectionItem item : selectItems) {
            connectionProperty = item.getProperty();
            if (connectionProperty.getLabel().equals(name)) {
                oldConnectionId = connectionProperty.getId();
                connectionItem = item;
                connection = (XmlFileConnection) connectionItem.getConnection();
                needRewrite = true;
                Set<MetadataTable> tables = ConnectionHelper.getTables(connection);
                MetadataTable oldTable = null;
                if (tables.size() > 0) {
                    oldTable = tables.toArray(new MetadataTable[0])[0];
                    oldTableId = oldTable.getId();
                    oldMetadataTable = ConvertionHelper.convert(oldTable);
                }
                oldTableMap = RepositoryUpdateManager.getOldTableIdAndNameMap(connectionItem, oldTable, false);
                break;
            }
        }
        if (!needRewrite) {
            return;
        }
    }
    connection = ConnectionFactory.eINSTANCE.createXmlFileConnection();
    connection.setName(ERepositoryObjectType.METADATA_FILE_XML.getKey());
    connectionItem = PropertiesFactory.eINSTANCE.createXmlFileConnectionItem();
    connectionProperty = PropertiesFactory.eINSTANCE.createProperty();
    connectionProperty.setAuthor(((RepositoryContext) CoreRuntimePlugin.getInstance().getContext().getProperty(Context.REPOSITORY_CONTEXT_KEY)).getUser());
    connectionProperty.setLabel(name);
    connectionProperty.setVersion(VersionUtils.DEFAULT_VERSION);
    connectionProperty.setStatusCode("String_Node_Str");
    connectionItem.setProperty(connectionProperty);
    connectionItem.setConnection(connection);
    connection.setInputModel(false);
    ByteArray byteArray = PropertiesFactory.eINSTANCE.createByteArray();
    byteArray.setInnerContentFromFile(zip);
    connection.setFileContent(byteArray.getInnerContent());
    String schemaFileName = schemaFile.getName();
    schemaFileName = schemaFileName.substring(0, schemaFileName.lastIndexOf("String_Node_Str"));
    connection.setXmlFilePath(schemaFileName.concat("String_Node_Str").concat(zip.getName()));
    try {
        String filePath = schemaFile.getPath();
        XSDSchema xsdSchema = populationUtil.getXSDSchema(filePath);
        List<ATreeNode> rootNodes = populationUtil.getAllRootNodes(xsdSchema);
        ATreeNode node = null;
        for (ATreeNode curNode : rootNodes) {
            String curName = (String) curNode.getValue();
            if (curName.contains("String_Node_Str")) {
                if (curName.split("String_Node_Str")[1].equals(name)) {
                    node = curNode;
                    break;
                }
            } else if (curName.equals(name)) {
                node = curNode;
                break;
            }
        }
        node = populationUtil.getSchemaTree(xsdSchema, node);
        orderId = 1;
        loopElementFound = false;
        if (ConnectionHelper.getTables(connection).isEmpty()) {
            MetadataTable table = ConnectionFactory.eINSTANCE.createMetadataTable();
            if (oldTableId != null) {
                table.setId(oldTableId);
            } else {
                table.setId(ProxyRepositoryFactory.getInstance().getNextId());
            }
            RecordFile record = (RecordFile) ConnectionHelper.getPackage(connection.getName(), connection, RecordFile.class);
            if (record != null) {
                PackageHelper.addMetadataTable(table, record);
            } else {
                RecordFile newrecord = RecordFactory.eINSTANCE.createRecordFile();
                newrecord.setName(connection.getName());
                ConnectionHelper.addPackage(newrecord, connection);
                PackageHelper.addMetadataTable(table, newrecord);
            }
        }
        boolean haveElement = false;
        for (Object curNode : node.getChildren()) {
            if (((ATreeNode) curNode).getType() == ATreeNode.ELEMENT_TYPE) {
                haveElement = true;
                break;
            }
        }
        fillRootInfo(connection, node, "String_Node_Str", !haveElement);
    } catch (IOException e) {
        throw e;
    } catch (URISyntaxException e1) {
        ExceptionHandler.process(e1);
    } catch (OdaException e) {
        ExceptionHandler.process(e);
    }
    IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
    connectionProperty.setId(factory.getNextId());
    try {
        String folderPath = FolderNameUtil.getImportedXmlSchemaPath(parameter.getNamespaceURI(), portTypeName, operationName);
        IPath path = new Path(folderPath);
        factory.create(connectionItem, path, true);
        if (oldConnectionId != null) {
            connectionItem.getProperty().setId(oldConnectionId);
            factory.save(connectionItem);
        }
        propagateSchemaChange(oldMetadataTable, oldTableMap, connection, connectionItem);
        ProxyRepositoryFactory.getInstance().saveProject(ProjectManager.getInstance().getCurrentProject());
        RepositoryManager.refresh(ERepositoryObjectType.METADATA_FILE_XML);
    } catch (PersistenceException e) {
        ExceptionHandler.process(e);
    } catch (URISyntaxException e) {
        ExceptionHandler.process(e);
    }
}

Output:
         }
-        if (!needRewrite) {
+        if (!needRewrite && !WSDLUtils.isNameValidInXmlFileConnection(parameter, portTypeName, operationName)) {
             return;


Input:
public void encodeText(final CharSequence text, final ByteBufferDestination destination) {
    charsetEncoder.reset();
    ByteBuffer byteBuf = destination.getByteBuffer();
    final CharBuffer charBuf = getCachedCharBuffer();
    int start = 0;
    int todoChars = text.length();
    boolean endOfInput = true;
    do {
        charBuf.clear();
        int copied = copy(text, start, charBuf);
        start += copied;
        todoChars -= copied;
        endOfInput = todoChars <= 0;
        charBuf.flip();
        byteBuf = encode(charBuf, endOfInput, destination, byteBuf);
    } while (!endOfInput);
}

Output:
     charsetEncoder.reset();
-    ByteBuffer byteBuf = destination.getByteBuffer();
-    final CharBuffer charBuf = getCachedCharBuffer();
-    int start = 0;
-    int todoChars = text.length();
-    boolean endOfInput = true;
-    do {
-        charBuf.clear();
-        int copied = copy(text, start, charBuf);
-        start += copied;
-        todoChars -= copied;
-        endOfInput = todoChars <= 0;
-        charBuf.flip();
-        byteBuf = encode(charBuf, endOfInput, destination, byteBuf);
-    } while (!endOfInput);
+    final ByteBuffer byteBuf = destination.getByteBuffer();
+    encode(charBuf, true, destination, byteBuf);
 }


Input:
protected static DgEnvironmentFactory setupEnvironment() {
    DgEnvironmentFactory.reset();
    envFactory = new DgEnvironmentFactory();
    if (useCachedOps && !Utils2.isNullOrEmpty(opsCache)) {
        envFactory.getDgEnvironment().operations = opsCache;
    } else {
        addRegexMatchOperation(envFactory);
        addROperation(envFactory);
        addMOperation(envFactory);
        addTOperation(envFactory);
        addSOperation(envFactory);
        addNOperation(envFactory);
        addExpressionOperations(envFactory);
        opsCache = envFactory.getDgEnvironment().operations;
    }
    return envFactory;
}

Output:
     if (useCachedOps && !Utils2.isNullOrEmpty(opsCache)) {
-        envFactory.getDgEnvironment().operations = opsCache;
+        envFactory.getDgEnvironment().operations.addAll(opsCache);
     } else {


Input:
public void widgetSelected(final SelectionEvent arg0) {
    if (max.getSelectionIndex() >= 0 && max.getItemCount() > 1) {
        if (max.getSelectionIndex() < (min.getSelectionIndex() - 1)) {
            max.select(min.getSelectionIndex() - 1);
        } else {
            if (model != null) {
                String val = max.getItem(max.getSelectionIndex());
                if (val.equals(ITEM_ALL)) {
                    val = String.valueOf(max.getItem(max.getSelectionIndex() - 1));
                }
                model.getInputConfig().getInput().getDefinition().setMaximumGeneralization(attribute, Integer.valueOf(val) - 1);
                controller.update(new ModelEvent(this, ModelPart.ATTRIBUTE_TYPE, attribute));
            }
        }
    }
}

Output:
 public void widgetSelected(final SelectionEvent arg0) {
-    if (max.getSelectionIndex() >= 0 && max.getItemCount() > 1) {
-        if (max.getSelectionIndex() < (min.getSelectionIndex() - 1)) {
-            max.select(min.getSelectionIndex() - 1);
-        } else {
-            if (model != null) {
-                String val = max.getItem(max.getSelectionIndex());
-                if (val.equals(ITEM_ALL)) {
-                    val = String.valueOf(max.getItem(max.getSelectionIndex() - 1));
-                }
-                model.getInputConfig().getInput().getDefinition().setMaximumGeneralization(attribute, Integer.valueOf(val) - 1);
-                controller.update(new ModelEvent(this, ModelPart.ATTRIBUTE_TYPE, attribute));
-            }
-        }
-    }
+    if (updateMax())
+        controller.update(new ModelEvent(this, ModelPart.ATTRIBUTE_TYPE, attribute));
 }


Input:
public void setValue(int index, Object value) {
    if (index == 1) {
        super.setValue(index, value);
    } else if (index == 2) {
        setMode(AutoConnectMode.forValue(((Number) value).byteValue() & 0xFF));
    } else if (index == 3) {
        getListeningWindow().clear();
        if (value != null) {
            for (Object item : (Object[]) value) {
                GXDateTime start = (GXDateTime) GXDLMSClient.changeType((byte[]) Array.get(item, 0), DataType.DATETIME);
                GXDateTime end = (GXDateTime) GXDLMSClient.changeType((byte[]) Array.get(item, 1), DataType.DATETIME);
                getListeningWindow().add(new AbstractMap.SimpleEntry(start, end));
            }
        }
    } else if (index == 4) {
        setStatus(AutoAnswerStatus.forValue(((Number) value).intValue()));
    } else if (index == 5) {
        setNumberOfCalls(((Number) value).intValue());
    } else if (index == 6) {
        m_NumberOfRingsInListeningWindow = m_NumberOfRingsOutListeningWindow = 0;
        if (value != null) {
            m_NumberOfRingsInListeningWindow = ((Number) Array.get(value, 0)).intValue();
            m_NumberOfRingsOutListeningWindow = ((Number) Array.get(value, 1)).intValue();
        }
    } else {
        throw new IllegalArgumentException("String_Node_Str");
    }
}

Output:
                 GXDateTime end = (GXDateTime) GXDLMSClient.changeType((byte[]) Array.get(item, 1), DataType.DATETIME);
-                getListeningWindow().add(new AbstractMap.SimpleEntry(start, end));
+                getListeningWindow().add(new SimpleEntry<GXDateTime, GXDateTime>(start, end));
             }


Input:
public String getCurrency() {
    return value != null ? value.getCurrency() : null;
}

Output:
 public String getCurrency() {
-    return value != null ? value.getCurrency() : null;
+    return currency;
 }


Input:
private void sendRelayBonus() {
    for (Map.Entry<ForgeDirection, TileEntity> entry : WorldHelper.getAdjacentTileEntitiesMapped(worldObj, this).entrySet()) {
        ForgeDirection dir = entry.getKey();
        TileEntity tile = entry.getValue();
        if (tile instanceof RelayMK3Tile) {
            double provide = this.provideEMC(dir.getOpposite(), 0.5);
            double remain = provide - ((RelayMK3Tile) tile).acceptEMC(dir, provide);
            this.addEMC(remain);
        } else if (tile instanceof RelayMK2Tile) {
            double provide = this.provideEMC(dir.getOpposite(), 0.15);
            double remain = provide - ((RelayMK2Tile) tile).acceptEMC(dir, provide);
            this.addEMC(remain);
        } else if (tile instanceof RelayMK1Tile) {
            double provide = this.provideEMC(dir.getOpposite(), 0.05);
            double remain = provide - ((RelayMK1Tile) tile).acceptEMC(dir, provide);
            this.addEMC(remain);
        }
    }
}

Output:
         if (tile instanceof RelayMK3Tile) {
-            double provide = this.provideEMC(dir.getOpposite(), 0.5);
-            double remain = provide - ((RelayMK3Tile) tile).acceptEMC(dir, provide);
-            this.addEMC(remain);
+            ((RelayMK3Tile) tile).acceptEMC(dir, 0.5);
         } else if (tile instanceof RelayMK2Tile) {


Input:
private boolean removeNetwork(CallbackContext callbackContext, JSONArray data) {
    if (!validateData(data)) {
        return false;
    }
    String ssidToDisconnect = data.getString(0);
    int networkIdToRemove = ssidToNetworkId(ssidToDisconnect);
    if (networkIdToRemove > 0) {
        wifiManager.removeNetwork(networkIdToRemove);
        wifiManager.saveConfiguration();
        callbackContext.success("String_Node_Str");
        return true;
    } else {
        callbackContext.error("String_Node_Str");
        return false;
    }
}

Output:
     }
-    String ssidToDisconnect = data.getString(0);
-    int networkIdToRemove = ssidToNetworkId(ssidToDisconnect);
-    if (networkIdToRemove > 0) {
-        wifiManager.removeNetwork(networkIdToRemove);
-        wifiManager.saveConfiguration();
-        callbackContext.success("String_Node_Str");
-        return true;
-    } else {
-        callbackContext.error("String_Node_Str");
-        return false;
+    try {
+        String ssidToDisconnect = data.getString(0);
+        int networkIdToRemove = ssidToNetworkId(ssidToDisconnect);
+        if (networkIdToRemove > 0) {
+            wifiManager.removeNetwork(networkIdToRemove);
+            wifiManager.saveConfiguration();
+            callbackContext.success("String_Node_Str");
+            return true;
+        } else {
+            callbackContext.error("String_Node_Str");
+            return false;
+        }
+    } catch (Exception e) {
+        callbackContext.error(e.getMessage());
     }


Input:
public IValue checkAssign(MarkerList markers, IContext context, ICodePosition position, IValue instance, IValue newValue) {
    if (newValue != null && (this.modifiers & Modifiers.FINAL) != 0) {
        markers.add(I18n.createMarker(position, "String_Node_Str", this.name.unqualified));
    }
    IValue value1 = newValue.withType(this.type, null, markers, context);
    if (value1 == null) {
        Marker marker = I18n.createMarker(newValue.getPosition(), "String_Node_Str", this.name.unqualified);
        marker.addInfo("String_Node_Str" + this.type);
        marker.addInfo("String_Node_Str" + newValue.getType());
        markers.add(marker);
    } else {
        newValue = value1;
    }
    return newValue;
}

Output:
 public IValue checkAssign(MarkerList markers, IContext context, ICodePosition position, IValue instance, IValue newValue) {
-    if (newValue != null && (this.modifiers & Modifiers.FINAL) != 0) {
+    if (this.theClass.hasModifier(Modifiers.ANNOTATION)) {
+        markers.add(I18n.createError(position, "String_Node_Str", this.name.unqualified));
+    } else if (newValue != null && (this.modifiers & Modifiers.FINAL) != 0) {
         markers.add(I18n.createMarker(position, "String_Node_Str", this.name.unqualified));


Input:
public static AttachesToBuilder builder(String mountPoint) {
    return new AttachesToBuilder();
}

Output:
 public static AttachesToBuilder builder(String mountPoint) {
-    return new AttachesToBuilder();
+    return new AttachesToBuilder().mountPoint(mountPoint);
 }


Input:
public PartUsageLink filterProductStructure(ConfigurationItemKey pKey, ConfigSpec configSpec, Integer partUsageLink, Integer depth) throws ConfigurationItemNotFoundException, WorkspaceNotFoundException, NotAllowedException, UserNotFoundException, UserNotActiveException, PartUsageLinkNotFoundException {
    User user = userManager.checkWorkspaceReadAccess(pKey.getWorkspace());
    PartUsageLink rootUsageLink;
    if (partUsageLink == null || partUsageLink == -1) {
        ConfigurationItem ci = new ConfigurationItemDAO(new Locale(user.getLanguage()), em).loadConfigurationItem(pKey);
        rootUsageLink = new PartUsageLink();
        rootUsageLink.setId(-1);
        rootUsageLink.setAmount(1d);
        List<CADInstance> cads = new ArrayList<CADInstance>();
        cads.add(new CADInstance(0d, 0d, 0d, 0d, 0d, 0d, CADInstance.Positioning.ABSOLUTE));
        rootUsageLink.setCadInstances(cads);
        rootUsageLink.setComponent(ci.getDesignItem());
    } else {
        rootUsageLink = new PartUsageLinkDAO(new Locale(user.getLanguage()), em).loadPartUsageLink(partUsageLink);
    }
    if (configSpec instanceof LatestConfigSpec) {
        if (depth == null) {
            filterLatestConfigSpec(rootUsageLink.getComponent(), -1);
        } else {
            filterLatestConfigSpec(rootUsageLink.getComponent(), depth);
        }
    } else if (configSpec instanceof BaselineConfigSpec) {
        if (depth == null) {
            filterBaselineConfigSpec(((BaselineConfigSpec) configSpec).getBaseline(), rootUsageLink.getComponent(), -1);
        } else {
            filterBaselineConfigSpec(((BaselineConfigSpec) configSpec).getBaseline(), rootUsageLink.getComponent(), depth);
        }
    }
    return rootUsageLink;
}

Output:
         List<CADInstance> cads = new ArrayList<CADInstance>();
-        cads.add(new CADInstance(0d, 0d, 0d, 0d, 0d, 0d, CADInstance.Positioning.ABSOLUTE));
+        CADInstance cad = new CADInstance(0d, 0d, 0d, 0d, 0d, 0d, CADInstance.Positioning.ABSOLUTE);
+        cad.setId(-1);
+        cads.add(cad);
         rootUsageLink.setCadInstances(cads);


Input:
public void testJDKClasses() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testJDKClasses() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
 }


Input:
public void execute(CommandSender sender, String[] args) {
    MessagesConfig messages = Messages.getInstance();
    if (args.length < 1) {
        sender.sendMessage(messages.generalNoTagGiven);
        return;
    }
    Guild guild = GuildUtils.byTag(args[0]);
    if (guild == null) {
        sender.sendMessage(messages.generalNoGuildFound);
        return;
    }
    if (args.length < 2) {
        sender.sendMessage(messages.generalNoNickGiven);
        return;
    }
    if (!UserUtils.playedBefore(args[1])) {
        sender.sendMessage(messages.generalNotPlayedBefore);
        return;
    }
    User user = User.get(args[1]);
    Player player = user.getPlayer();
    if (!guild.getMembers().contains(user)) {
        sender.sendMessage(messages.adminUserNotMemberOf);
        return;
    }
    User admin = (sender instanceof Player) ? User.get(sender.getName()) : null;
    if (!SimpleEventHandler.handle(new GuildMemberDeputyEvent(admin == null ? EventCause.CONSOLE : EventCause.ADMIN, admin, guild, user))) {
        return;
    }
    MessageTranslator translator = new MessageTranslator().register("String_Node_Str", user.getName());
    if (user.isDeputy()) {
        guild.setDeputy(null);
        sender.sendMessage(messages.deputyRemove);
        if (player != null) {
            player.sendMessage(messages.deputyMember);
        }
        String message = translator.translate(messages.deputyNoLongerMembers);
        for (User member : guild.getOnlineMembers()) {
            member.getPlayer().sendMessage(message);
        }
        return;
    }
    guild.setDeputy(user);
    sender.sendMessage(messages.deputySet);
    if (player != null) {
        player.sendMessage(messages.deputyOwner);
    }
    String message = translator.translate(messages.deputyMembers);
    for (User member : guild.getOnlineMembers()) {
        member.getPlayer().sendMessage(message);
    }
}

Output:
     }
-    Guild guild = GuildUtils.byTag(args[0]);
+    Guild guild = GuildUtils.getByTag(args[0]);
     if (guild == null) {


Input:
public void testError() {
    MockHttpServletRequest mockRequest = new MockHttpServletRequest();
    mockRequest.setAttribute(RequestDispatcher.ERROR_STATUS_CODE, 500);
    mockRequest.setAttribute(RequestDispatcher.ERROR_REQUEST_URI, "String_Node_Str");
    mockRequest.setAttribute(RequestDispatcher.ERROR_MESSAGE, "String_Node_Str");
    mockRequest.setAttribute(RequestDispatcher.ERROR_EXCEPTION, new IllegalStateException());
    String response = new ErrorResource().error(mockRequest);
    assertTrue(response.contains("String_Node_Str"));
    assertTrue(response.contains("String_Node_Str"));
    assertTrue(response.contains("String_Node_Str"));
    assertTrue(response.contains("String_Node_Str"));
}

Output:
     mockRequest.setAttribute(RequestDispatcher.ERROR_EXCEPTION, new IllegalStateException());
-    String response = new ErrorResource().error(mockRequest);
-    assertTrue(response.contains("String_Node_Str"));
-    assertTrue(response.contains("String_Node_Str"));
-    assertTrue(response.contains("String_Node_Str"));
-    assertTrue(response.contains("String_Node_Str"));
+    Response response = new ErrorResource().error(mockRequest);
+    assertEquals(500, response.getStatus());
+    String responseBody = response.getEntity().toString();
+    assertTrue(responseBody.contains("String_Node_Str"));
+    assertTrue(responseBody.contains("String_Node_Str"));
+    assertTrue(responseBody.contains("String_Node_Str"));
+    assertTrue(responseBody.contains("String_Node_Str"));
 }


Input:
public void start() {
    if (!nrtmEnabled) {
        LOGGER.warn("String_Node_Str");
        return;
    }
    serverChannel = bootstrapChannel(nrtmServerPipelineFactory, port, "String_Node_Str");
    serverChannelLegacy = bootstrapChannel(legacyNrtmServerPipelineFactory, legacyPort, "String_Node_Str");
    port = ((InetSocketAddress) serverChannel.getLocalAddress()).getPort();
    legacyPort = ((InetSocketAddress) serverChannelLegacy.getLocalAddress()).getPort();
}

Output:
     }
-    serverChannel = bootstrapChannel(nrtmServerPipelineFactory, port, "String_Node_Str");
-    serverChannelLegacy = bootstrapChannel(legacyNrtmServerPipelineFactory, legacyPort, "String_Node_Str");
+    serverChannel = bootstrapChannel(nrtmServerPipelineFactory, nrtmPort, "String_Node_Str");
+    serverChannelLegacy = bootstrapChannel(legacyNrtmServerPipelineFactory, nrtmPortLegacy, "String_Node_Str");
     port = ((InetSocketAddress) serverChannel.getLocalAddress()).getPort();


Input:
public void onAnimationEnd(Animation animation) {
    FloatingActionButton fab3 = (FloatingActionButton) findViewById(R.id.item_p3);
    RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) fab3.getLayoutParams();
    params.setMargins(0, 0, RADII, 0);
    fab3.setLayoutParams(params);
    fab3.clearAnimation();
}

Output:
     RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) fab3.getLayoutParams();
-    params.setMargins(0, 0, RADII, 0);
+    params.setMargins(0, 0, RADIUS, 0);
     fab3.setLayoutParams(params);


Input:
private ArrayList getUnmappedChildNodes(NodeList nodes) {
    ArrayList unmappedNodes = new ArrayList();
    for (int i = 0; i < nodes.getLength(); i++) {
        Node next = nodes.item(i);
        if (isUnmappedContent(next)) {
            unmappedNodes.add(next);
        }
    }
    return unmappedNodes;
}

Output:
     ArrayList unmappedNodes = new ArrayList();
-    for (int i = 0; i < nodes.getLength(); i++) {
+    int length = nodes.getLength();
+    for (int i = 0; i < length; i++) {
         Node next = nodes.item(i);


Input:
private void addInvalidation(Data dataKey) {
    if (mapContainer.isNearCacheEnabled()) {
        if (invalidationKeys == null) {
            invalidationKeys = new ArrayList<Data>(mapEntries.size());
        }
        invalidationKeys.add(dataKey);
    }
}

Output:
 private void addInvalidation(Data dataKey) {
-    if (mapContainer.isNearCacheEnabled()) {
+    if (mapContainer.isInvalidationEnabled()) {
         if (invalidationKeys == null) {


Input:
private void onUpdate(EventLog log) {
    if (updateEvents == null) {
        updateEvents = new HashMap<Object, EventLog>();
    }
    updateEvents.put(log.getEntityId(), log);
}

Output:
     if (updateEvents == null) {
-        updateEvents = new HashMap<Object, EventLog>();
+        updateEvents = new ConcurrentHashMap<Object, EventLog>();
     }


Input:
public PaymentVoucher createPaymentVoucherIPO(Invoice invoice, DateTime dateTime, BigDecimal amount, PaymentMode paymentMode) throws AxelorException {
    MoveLine customerMoveLine = moveService.getCustomerMoveLineByQuery(invoice);
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str", invoice.getInvoiceId());
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str", paymentMode.getCode());
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str", invoice.getCompany().getName());
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str", invoice.getPartner().getName());
    }
    PaymentVoucher paymentVoucher = this.createPaymentVoucher(invoice.getCompany(), null, null, paymentMode, dateTime, invoice.getPartner(), amount, null, invoice, null, null, null);
    paymentVoucher.setAutoOk(true);
    List<PaymentInvoiceToPay> lines = new ArrayList<PaymentInvoiceToPay>();
    lines.add(paymentInvoiceToPayService.createPaymentInvoiceToPay(paymentVoucher, 1, invoice, customerMoveLine, customerMoveLine.getDebit(), customerMoveLine.getAmountRemaining(), amount));
    paymentVoucher.setPaymentInvoiceToPayList(lines);
    paymentVoucher.save();
    paymentVoucherConfirmService.confirmPaymentVoucher(paymentVoucher, false);
    return paymentVoucher;
}

Output:
     PaymentVoucher paymentVoucher = this.createPaymentVoucher(invoice.getCompany(), null, null, paymentMode, dateTime, invoice.getPartner(), amount, null, invoice, null, null, null);
-    paymentVoucher.setAutoOk(true);
+    paymentVoucher.setHasAutoInput(true);
     List<PaymentInvoiceToPay> lines = new ArrayList<PaymentInvoiceToPay>();


Input:
public Sequence<? super T> apply(T t) throws NotAppliedException, $.Break {
    c.prepend(t);
    return c;
}

Output:
 public Sequence<? super T> apply(T t) throws NotAppliedException, $.Break {
-    c.prepend(t);
-    return c;
+    sequence.prepend(t);
+    return sequence;
 }


Input:
public void propertyChange(final PropertyChangeEvent evt) {
    if (DNIeManager.BLOWN_DNI_INSERTED.equals(evt.getPropertyName())) {
        if (DEBUG)
            System.out.println("String_Node_Str");
        loadDefaultKeyStore();
        loadMainApp(true);
        JOptionPane.showOptionDialog(this.container, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"), JOptionPane.OK_OPTION, JOptionPane.ERROR_MESSAGE, null, new Object[] { Messages.getString("String_Node_Str") }, null);
        return;
    } else if (DNIeManager.CARD_EXCEPTION.equals(evt.getPropertyName())) {
        if (DEBUG)
            System.out.println("String_Node_Str");
        try {
            new SimpleKeyStoreManagerWorker(this, null, false).execute();
        } catch (final Exception e) {
            Logger.getLogger("String_Node_Str").severe("String_Node_Str" + e);
            JOptionPane.showOptionDialog(this.container, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"), JOptionPane.OK_OPTION, JOptionPane.ERROR_MESSAGE, null, new Object[] { Messages.getString("String_Node_Str") }, null);
            closeApplication(-1);
        }
        return;
    } else if (DNIeManager.NOT_DNI_INSERTED.equals(evt.getPropertyName())) {
        if (DEBUG)
            System.out.println("String_Node_Str");
        JOptionPane.showOptionDialog(this.container, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"), JOptionPane.OK_OPTION, JOptionPane.WARNING_MESSAGE, null, new Object[] { Messages.getString("String_Node_Str") }, null);
        return;
    } else if (DNIeManager.DNI_INSERTED.equals(evt.getPropertyName())) {
        if (DEBUG)
            System.out.println("String_Node_Str");
        this.container.setCursor(new Cursor(Cursor.WAIT_CURSOR));
        try {
            new SimpleKeyStoreManagerWorker(this, null, true).execute();
        } catch (final Exception e) {
            Logger.getLogger("String_Node_Str").severe("String_Node_Str" + e);
            loadDefaultKeyStore();
        } finally {
            this.container.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
        }
        loadMainApp(true);
    }
}

Output:
         loadMainApp(true);
-        JOptionPane.showOptionDialog(this.container, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"), JOptionPane.OK_OPTION, JOptionPane.ERROR_MESSAGE, null, new Object[] { Messages.getString("String_Node_Str") }, null);
+        UIUtils.showErrorMessage(this.container, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"), JOptionPane.ERROR_MESSAGE);
         return;


Input:
private void fillRootInfo(XmlFileConnection connection, ATreeNode node, String path, boolean inLoop) throws OdaException {
    XMLFileNode xmlNode = ConnectionFactory.eINSTANCE.createXMLFileNode();
    xmlNode.setXMLPath(path + "String_Node_Str" + node.getValue());
    xmlNode.setOrder(orderId);
    orderId++;
    MappingTypeRetriever retriever;
    String nameWithoutPrefixForColumn;
    String curName = (String) node.getValue();
    if (curName.contains("String_Node_Str")) {
        nameWithoutPrefixForColumn = curName.split("String_Node_Str")[1];
    } else {
        nameWithoutPrefixForColumn = curName;
    }
    retriever = MetadataTalendType.getMappingTypeRetriever("String_Node_Str");
    xmlNode.setAttribute("String_Node_Str");
    xmlNode.setType(retriever.getDefaultSelectedTalendType(node.getDataType()));
    MetadataColumn column = null;
    switch(node.getType()) {
        case ATreeNode.ATTRIBUTE_TYPE:
            xmlNode.setXMLPath("String_Node_Str" + node.getValue());
            xmlNode.setRelatedColumn(nameWithoutPrefixForColumn);
            column = ConnectionFactory.eINSTANCE.createMetadataColumn();
            column.setTalendType(xmlNode.getType());
            column.setLabel(nameWithoutPrefixForColumn);
            ConnectionHelper.getTables(connection).toArray(new MetadataTable[0])[0].getColumns().add(column);
            break;
        case ATreeNode.ELEMENT_TYPE:
            boolean haveElementOrAttributes = false;
            for (Object curNode : node.getChildren()) {
                if (((ATreeNode) curNode).getType() != ATreeNode.NAMESPACE_TYPE) {
                    haveElementOrAttributes = true;
                    break;
                }
            }
            if (!haveElementOrAttributes) {
                xmlNode.setAttribute("String_Node_Str");
                xmlNode.setRelatedColumn(nameWithoutPrefixForColumn);
                column = ConnectionFactory.eINSTANCE.createMetadataColumn();
                column.setTalendType(xmlNode.getType());
                column.setLabel(nameWithoutPrefixForColumn);
                ConnectionHelper.getTables(connection).toArray(new MetadataTable[0])[0].getColumns().add(column);
            } else {
                xmlNode.setAttribute("String_Node_Str");
            }
            break;
        case ATreeNode.NAMESPACE_TYPE:
            xmlNode.setAttribute("String_Node_Str");
            xmlNode.setXMLPath(node.getDataType());
            xmlNode.setDefaultValue((String) node.getValue());
            break;
        case ATreeNode.OTHER_TYPE:
            break;
    }
    boolean subElementsInLoop = inLoop;
    if ((!loopElementFound && path.split("String_Node_Str").length == 2 && node.getType() == ATreeNode.ELEMENT_TYPE) || subElementsInLoop) {
        connection.getLoop().add(xmlNode);
        loopElementFound = true;
        subElementsInLoop = true;
    } else {
        connection.getRoot().add(xmlNode);
    }
    if (node.getChildren().length > 0) {
        for (Object curNode : node.getChildren()) {
            fillRootInfo(connection, (ATreeNode) curNode, path + "String_Node_Str" + node.getValue(), subElementsInLoop);
        }
    }
}

Output:
             column.setTalendType(xmlNode.getType());
-            column.setLabel(nameWithoutPrefixForColumn);
-            ConnectionHelper.getTables(connection).toArray(new MetadataTable[0])[0].getColumns().add(column);
+            String uniqueName = extractColumnName(nameWithoutPrefixForColumn, metadataTable.getColumns());
+            column.setLabel(uniqueName);
+            xmlNode.setRelatedColumn(uniqueName);
+            metadataTable.getColumns().add(column);
             break;


Input:
public String fetchColumnValueAsString(TypedRow row) {
    return null;
}

Output:
 public String fetchColumnValueAsString(TypedRow row) {
-    return null;
+    TypedColumn typedCol = row.getColumn(getColumnName());
+    Object value = typedCol.getValue();
+    return convertTypeToString(value);
 }


Input:
public IntSet getIndices() {
    final IntSet result = new IntArraySet();
    final Collection<CompoundDirectoryEntry> directory = compoundReader.getDirectory();
    for (final CompoundDirectoryEntry entry : directory) {
        final String name = entry.getName();
        final String[] tokens = name.split("String_Node_Str");
        if (tokens.length < 1) {
            return null;
        }
        result.add(Integer.parseInt(tokens[0]));
    }
    return result;
}

Output:
         final String name = entry.getName();
-        final String[] tokens = name.split("String_Node_Str");
-        if (tokens.length < 1) {
-            return null;
+        if (!name.startsWith("String_Node_Str")) {
+            final String[] tokens = name.split("String_Node_Str");
+            if (tokens.length < 1) {
+                return null;
+            }
+            result.add(Integer.parseInt(tokens[0]));
         }


Input:
public static DesktopService getDesktopService() {
    if (desktopService == null) {
        ServiceReference serviceReference = bundleContext.getServiceReference(DesktopService.class.getName());
        desktopService = (DesktopService) bundleContext.getService(serviceReference);
    }
    return desktopService;
}

Output:
     if (desktopService == null) {
-        ServiceReference serviceReference = bundleContext.getServiceReference(DesktopService.class.getName());
-        desktopService = (DesktopService) bundleContext.getService(serviceReference);
+        desktopService = ServiceUtils.getService(bundleContext, DesktopService.class);
     }


Input:
static public String getUriWithFilterMany(RequestContext context, String dbName, String collName, String referenceField, Object[] ids, boolean detectOids) throws UnsupportedDocumentIdException {
    StringBuilder sb = new StringBuilder();
    sb.append("String_Node_Str").append(dbName).append("String_Node_Str").append(collName).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(referenceField).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(getIdsString(ids)).append("String_Node_Str");
    if (!detectOids) {
        sb.append("String_Node_Str");
    }
    return context.mapUri(sb.toString().replaceAll("String_Node_Str", "String_Node_Str"));
}

Output:
     StringBuilder sb = new StringBuilder();
-    sb.append("String_Node_Str").append(dbName).append("String_Node_Str").append(collName).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(referenceField).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(getIdsString(ids)).append("String_Node_Str");
+    sb.append("String_Node_Str").append(dbName).append("String_Node_Str").append(collName).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(getIdsString(ids)).append("String_Node_Str");
     if (!detectOids) {


Input:
public void setNullable(boolean nullable) {
    this.nullable = nullable ? 'T' : 'F';
}

Output:
 public void setNullable(boolean nullable) {
-    this.nullable = nullable ? 'T' : 'F';
+    this.nullable = getBooleanAsCharacter(nullable);
 }


Input:
public void doJob() {
    SystemEmailTemplateServiceImpl templateService = Spring.getBeanOfType(SystemEmailTemplateServiceImpl.class);
    templateService.generateAllSystemEmailTemplates();
}

Output:
 public void doJob() {
-    SystemEmailTemplateServiceImpl templateService = Spring.getBeanOfType(SystemEmailTemplateServiceImpl.class);
-    templateService.generateAllSystemEmailTemplates();
+    try {
+        SystemEmailTemplateServiceImpl templateService = Spring.getBeanOfType(SystemEmailTemplateServiceImpl.class);
+        templateService.generateAllSystemEmailTemplates();
+    } catch (RuntimeException re) {
+        Logger.error(re, "String_Node_Str");
+    }
 }


Input:
public List<Object> findByRelation(String colName, String colValue, Class entityClazz) {
    EntityMetadata m = KunderaMetadataManager.getEntityMetadata(entityClazz);
    SlicePredicate slicePredicate = Selector.newColumnsPredicateAll(false, 10000);
    List<Object> entities = null;
    IndexExpression ie = new IndexExpression(Bytes.fromUTF8(colName).getBytes(), IndexOperator.EQ, Bytes.fromUTF8(colValue).getBytes());
    IndexClause ix = Selector.newIndexClause(Bytes.EMPTY, 10000, ie);
    ColumnParent columnParent = new ColumnParent(m.getTableName());
    List<KeySlice> keySlices;
    try {
        cassandra_client.set_keyspace(m.getSchema());
        keySlices = cassandra_client.get_indexed_slices(columnParent, ix, slicePredicate, consistencyLevel);
    } catch (InvalidRequestException e) {
        log.error("String_Node_Str" + e.getMessage());
        throw new KunderaException("String_Node_Str", e);
    } catch (UnavailableException e) {
        log.error("String_Node_Str" + e.getMessage());
        throw new KunderaException("String_Node_Str", e);
    } catch (TimedOutException e) {
        log.error("String_Node_Str" + e.getMessage());
        throw new KunderaException("String_Node_Str", e);
    } catch (TException e) {
        log.error("String_Node_Str" + e.getMessage());
        throw new KunderaException("String_Node_Str", e);
    }
    if (keySlices != null) {
        entities = new ArrayList<Object>(keySlices.size());
        populateData(m, keySlices, entities, false, null);
    }
    return entities;
}

Output:
     } catch (InvalidRequestException e) {
-        log.error("String_Node_Str" + e.getMessage());
-        throw new KunderaException("String_Node_Str", e);
+        if (e.why != null && e.why.contains("String_Node_Str")) {
+            return entities;
+        } else {
+            log.error("String_Node_Str" + e.getMessage());
+            throw new KunderaException("String_Node_Str", e);
+        }
     } catch (UnavailableException e) {


Input:
public void publish(final LogRecord record) {
    record.getSourceMethodName();
    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            LogViewerFrame.getInstance().addRecord(record);
        }
    });
}

Output:
     record.getSourceMethodName();
-    SwingUtilities.invokeLater(new Runnable() {
-        public void run() {
-            LogViewerFrame.getInstance().addRecord(record);
-        }
-    });
+    LogViewerFrame.getInstance().addRecord(record);
 }


Input:
private void simulateItalic(PdfContentByte cb, float x, float y) {
    float alpha = (float) Math.tan(0f * Math.PI / 180);
    float beta = (float) Math.tan(15f * Math.PI / 180);
    cb.setTextMatrix(1, alpha, beta, 1, x, y);
}

Output:
     float alpha = (float) Math.tan(0f * Math.PI / 180);
-    float beta = (float) Math.tan(15f * Math.PI / 180);
+    float beta = EmitterUtil.getItalicHorizontalCoefficient();
     cb.setTextMatrix(1, alpha, beta, 1, x, y);


Input:
private String asText(List<CodeType> target) {
    StringBuilder b = new StringBuilder();
    boolean first = true;
    for (CodeType rn : target) {
        if (first) {
            first = false;
            b.append("String_Node_Str");
        } else
            b.append("String_Node_Str");
        if (rn.equals("String_Node_Str"))
            b.append("String_Node_Str");
        else
            b.append("String_Node_Str").append(rn.getValue().toLowerCase()).append("String_Node_Str").append(rn.getValue()).append("String_Node_Str");
    }
    if (!first)
        b.append("String_Node_Str");
    return b.toString();
}

Output:
             b.append("String_Node_Str");
-        if (rn.equals("String_Node_Str"))
+        final String value = rn.getValue();
+        if ("String_Node_Str".equals(value))
             b.append("String_Node_Str");


Input:
public void run() {
    long start = System.currentTimeMillis();
    String testName = method.getMethod().getDeclaringClass().getSimpleName() + "String_Node_Str" + method.getName();
    System.out.println("String_Node_Str" + testName);
    HazelcastParallelClassRunner.super.runChild(method, notifier);
    numThreads.decrementAndGet();
    float took = (float) (System.currentTimeMillis() - start) / 1000;
    System.out.println(String.format("String_Node_Str", testName, took));
}

Output:
 public void run() {
-    long start = System.currentTimeMillis();
-    String testName = method.getMethod().getDeclaringClass().getSimpleName() + "String_Node_Str" + method.getName();
-    System.out.println("String_Node_Str" + testName);
-    HazelcastParallelClassRunner.super.runChild(method, notifier);
-    numThreads.decrementAndGet();
-    float took = (float) (System.currentTimeMillis() - start) / 1000;
-    System.out.println(String.format("String_Node_Str", testName, took));
+    FRAMEWORK_METHOD_THREAD_LOCAL.set(method);
+    try {
+        long start = System.currentTimeMillis();
+        String testName = method.getMethod().getDeclaringClass().getSimpleName() + "String_Node_Str" + method.getName();
+        System.out.println("String_Node_Str" + testName);
+        HazelcastParallelClassRunner.super.runChild(method, notifier);
+        numThreads.decrementAndGet();
+        float took = (float) (System.currentTimeMillis() - start) / 1000;
+        System.out.println(String.format("String_Node_Str", testName, took));
+    } finally {
+        FRAMEWORK_METHOD_THREAD_LOCAL.remove();
+    }
 }


Input:
public boolean compile(String configFile, BuildProgressMonitor progressMonitor, boolean buildModel) {
    init();
    try {
        AjBuildConfig buildConfig = genBuildConfig(configFile);
        buildConfig.setGenerateModelMode(buildModel);
        if (null == buildConfig) {
            return false;
        }
        currNotifier = new BuildNotifierAdapter(progressMonitor);
        buildManager.setProgressListener(currNotifier);
        messageHandler.setBuildNotifierAdapter(currNotifier);
        String rtInfo = buildManager.checkRtJar(buildConfig);
        if (rtInfo != null) {
            signalWarning("String_Node_Str" + rtInfo + "String_Node_Str");
            return false;
        }
        boolean incrementalEnabled = buildConfig.isIncrementalMode() || buildConfig.isIncrementalFileMode();
        if (incrementalEnabled && nextBuild) {
            return buildManager.incrementalBuild(buildConfig, messageHandler);
        } else {
            if (incrementalEnabled) {
                nextBuild = incrementalEnabled;
            }
            return buildManager.batchBuild(buildConfig, messageHandler);
        }
    } catch (OperationCanceledException ce) {
        signalWarning("String_Node_Str");
        return false;
    } catch (AbortException e) {
        final IMessage message = e.getIMessage();
        if (null == message) {
            signalThrown(e);
        } else if (null != message.getMessage()) {
            signalWarning(message.getMessage());
        } else if (null != message.getThrown()) {
            signalThrown(message.getThrown());
        } else {
            signalThrown(e);
        }
        return false;
    } catch (Throwable t) {
        signalThrown(t);
        return false;
    }
}

Output:
         if (rtInfo != null) {
-            signalWarning("String_Node_Str" + rtInfo + "String_Node_Str");
+            Ajde.getDefault().getErrorHandler().handleWarning("String_Node_Str" + rtInfo + "String_Node_Str");
             return false;


Input:
private void performTraversals() {
    final View host = mView;
    if (DBG) {
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str");
        host.debug();
    }
    if (host == null || !mAdded)
        return;
    mIsInTraversal = true;
    mWillDrawSoon = true;
    boolean windowSizeMayChange = false;
    boolean newSurface = false;
    boolean surfaceChanged = false;
    WindowManager.LayoutParams lp = mWindowAttributes;
    int desiredWindowWidth;
    int desiredWindowHeight;
    final int viewVisibility = getHostVisibility();
    final boolean viewVisibilityChanged = !mFirst && (mViewVisibility != viewVisibility || mNewSurfaceNeeded);
    WindowManager.LayoutParams params = null;
    if (mWindowAttributesChanged) {
        mWindowAttributesChanged = false;
        surfaceChanged = true;
        params = lp;
    }
    CompatibilityInfo compatibilityInfo = mDisplayAdjustments.getCompatibilityInfo();
    if (compatibilityInfo.supportsScreen() == mLastInCompatMode) {
        params = lp;
        mFullRedrawNeeded = true;
        mLayoutRequested = true;
        if (mLastInCompatMode) {
            params.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
            mLastInCompatMode = false;
        } else {
            params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
            mLastInCompatMode = true;
        }
    }
    mWindowAttributesChangesFlag = 0;
    Rect frame = mWinFrame;
    if (mFirst) {
        mFullRedrawNeeded = true;
        mLayoutRequested = true;
        if (shouldUseDisplaySize(lp)) {
            Point size = new Point();
            mDisplay.getRealSize(size);
            desiredWindowWidth = size.x;
            desiredWindowHeight = size.y;
        } else {
            Configuration config = mContext.getResources().getConfiguration();
            desiredWindowWidth = dipToPx(config.screenWidthDp);
            desiredWindowHeight = dipToPx(config.screenHeightDp);
        }
        mAttachInfo.mUse32BitDrawingCache = true;
        mAttachInfo.mHasWindowFocus = false;
        mAttachInfo.mWindowVisibility = viewVisibility;
        mAttachInfo.mRecomputeGlobalAttributes = false;
        mLastConfiguration.setTo(host.getResources().getConfiguration());
        mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
        if (mViewLayoutDirectionInitial == View.LAYOUT_DIRECTION_INHERIT) {
            host.setLayoutDirection(mLastConfiguration.getLayoutDirection());
        }
        host.dispatchAttachedToWindow(mAttachInfo, 0);
        mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(true);
        dispatchApplyInsets(host);
    } else {
        desiredWindowWidth = frame.width();
        desiredWindowHeight = frame.height();
        if (desiredWindowWidth != mWidth || desiredWindowHeight != mHeight) {
            if (DEBUG_ORIENTATION)
                Log.v(mTag, "String_Node_Str" + host + "String_Node_Str" + frame);
            mFullRedrawNeeded = true;
            mLayoutRequested = true;
            windowSizeMayChange = true;
        }
    }
    if (viewVisibilityChanged) {
        mAttachInfo.mWindowVisibility = viewVisibility;
        host.dispatchWindowVisibilityChanged(viewVisibility);
        host.dispatchVisibilityAggregated(viewVisibility == View.VISIBLE);
        if (viewVisibility != View.VISIBLE || mNewSurfaceNeeded) {
            endDragResizing();
            destroyHardwareResources();
        }
        if (viewVisibility == View.GONE) {
            mHasHadWindowFocus = false;
        }
    }
    if (mAttachInfo.mWindowVisibility != View.VISIBLE) {
        host.clearAccessibilityFocus();
    }
    getRunQueue().executeActions(mAttachInfo.mHandler);
    boolean insetsChanged = false;
    boolean layoutRequested = mLayoutRequested && (!mStopped || mReportNextDraw);
    if (layoutRequested) {
        final Resources res = mView.getContext().getResources();
        if (mFirst) {
            mAttachInfo.mInTouchMode = !mAddedTouchMode;
            ensureTouchModeLocally(mAddedTouchMode);
        } else {
            if (!mPendingOverscanInsets.equals(mAttachInfo.mOverscanInsets)) {
                insetsChanged = true;
            }
            if (!mPendingContentInsets.equals(mAttachInfo.mContentInsets)) {
                insetsChanged = true;
            }
            if (!mPendingStableInsets.equals(mAttachInfo.mStableInsets)) {
                insetsChanged = true;
            }
            if (!mPendingVisibleInsets.equals(mAttachInfo.mVisibleInsets)) {
                mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                if (DEBUG_LAYOUT)
                    Log.v(mTag, "String_Node_Str" + mAttachInfo.mVisibleInsets);
            }
            if (!mPendingOutsets.equals(mAttachInfo.mOutsets)) {
                insetsChanged = true;
            }
            if (mPendingAlwaysConsumeNavBar != mAttachInfo.mAlwaysConsumeNavBar) {
                insetsChanged = true;
            }
            if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT || lp.height == ViewGroup.LayoutParams.WRAP_CONTENT) {
                windowSizeMayChange = true;
                if (shouldUseDisplaySize(lp)) {
                    Point size = new Point();
                    mDisplay.getRealSize(size);
                    desiredWindowWidth = size.x;
                    desiredWindowHeight = size.y;
                } else {
                    Configuration config = res.getConfiguration();
                    desiredWindowWidth = dipToPx(config.screenWidthDp);
                    desiredWindowHeight = dipToPx(config.screenHeightDp);
                }
            }
        }
        windowSizeMayChange |= measureHierarchy(host, lp, res, desiredWindowWidth, desiredWindowHeight);
    }
    if (collectViewAttributes()) {
        params = lp;
    }
    if (mAttachInfo.mForceReportNewAttributes) {
        mAttachInfo.mForceReportNewAttributes = false;
        params = lp;
    }
    if (mFirst || mAttachInfo.mViewVisibilityChanged) {
        mAttachInfo.mViewVisibilityChanged = false;
        int resizeMode = mSoftInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
        if (resizeMode == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_UNSPECIFIED) {
            final int N = mAttachInfo.mScrollContainers.size();
            for (int i = 0; i < N; i++) {
                if (mAttachInfo.mScrollContainers.get(i).isShown()) {
                    resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
                }
            }
            if (resizeMode == 0) {
                resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN;
            }
            if ((lp.softInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) != resizeMode) {
                lp.softInputMode = (lp.softInputMode & ~WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) | resizeMode;
                params = lp;
            }
        }
    }
    if (params != null) {
        if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {
            if (!PixelFormat.formatHasAlpha(params.format)) {
                params.format = PixelFormat.TRANSLUCENT;
            }
        }
        mAttachInfo.mOverscanRequested = (params.flags & WindowManager.LayoutParams.FLAG_LAYOUT_IN_OVERSCAN) != 0;
    }
    if (mApplyInsetsRequested) {
        mApplyInsetsRequested = false;
        mLastOverscanRequested = mAttachInfo.mOverscanRequested;
        dispatchApplyInsets(host);
        if (mLayoutRequested) {
            windowSizeMayChange |= measureHierarchy(host, lp, mView.getContext().getResources(), desiredWindowWidth, desiredWindowHeight);
        }
    }
    if (layoutRequested) {
        mLayoutRequested = false;
    }
    boolean windowShouldResize = layoutRequested && windowSizeMayChange && ((mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) || (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT && frame.width() < desiredWindowWidth && frame.width() != mWidth) || (lp.height == ViewGroup.LayoutParams.WRAP_CONTENT && frame.height() < desiredWindowHeight && frame.height() != mHeight));
    windowShouldResize |= mDragResizing && mResizeMode == RESIZE_MODE_FREEFORM;
    windowShouldResize |= mActivityRelaunched;
    final boolean computesInternalInsets = mAttachInfo.mTreeObserver.hasComputeInternalInsetsListeners() || mAttachInfo.mHasNonEmptyGivenInternalInsets;
    boolean insetsPending = false;
    int relayoutResult = 0;
    final boolean isViewVisible = viewVisibility == View.VISIBLE;
    if (mFirst || windowShouldResize || insetsChanged || viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
        mForceNextWindowRelayout = false;
        if (isViewVisible) {
            insetsPending = computesInternalInsets && (mFirst || viewVisibilityChanged);
        }
        if (mSurfaceHolder != null) {
            mSurfaceHolder.mSurfaceLock.lock();
            mDrawingAllowed = true;
        }
        boolean hwInitialized = false;
        boolean contentInsetsChanged = false;
        boolean hadSurface = mSurface.isValid();
        try {
            if (DEBUG_LAYOUT) {
                Log.i(mTag, "String_Node_Str" + host.getMeasuredWidth() + "String_Node_Str" + host.getMeasuredHeight() + "String_Node_Str" + params);
            }
            if (mAttachInfo.mHardwareRenderer != null) {
                if (mAttachInfo.mHardwareRenderer.pauseSurface(mSurface)) {
                    mDirty.set(0, 0, mWidth, mHeight);
                }
                mChoreographer.mFrameInfo.addFlags(FrameInfo.FLAG_WINDOW_LAYOUT_CHANGED);
            }
            final int surfaceGenerationId = mSurface.getGenerationId();
            relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
            if (DEBUG_LAYOUT)
                Log.v(mTag, "String_Node_Str" + frame.toShortString() + "String_Node_Str" + mPendingOverscanInsets.toShortString() + "String_Node_Str" + mPendingContentInsets.toShortString() + "String_Node_Str" + mPendingVisibleInsets.toShortString() + "String_Node_Str" + mPendingStableInsets.toShortString() + "String_Node_Str" + mPendingOutsets.toShortString() + "String_Node_Str" + mSurface);
            if (mPendingConfiguration.seq != 0) {
                if (DEBUG_CONFIGURATION)
                    Log.v(mTag, "String_Node_Str" + mPendingConfiguration);
                updateConfiguration(new Configuration(mPendingConfiguration), !mFirst);
                mPendingConfiguration.seq = 0;
            }
            final boolean overscanInsetsChanged = !mPendingOverscanInsets.equals(mAttachInfo.mOverscanInsets);
            contentInsetsChanged = !mPendingContentInsets.equals(mAttachInfo.mContentInsets);
            final boolean visibleInsetsChanged = !mPendingVisibleInsets.equals(mAttachInfo.mVisibleInsets);
            final boolean stableInsetsChanged = !mPendingStableInsets.equals(mAttachInfo.mStableInsets);
            final boolean outsetsChanged = !mPendingOutsets.equals(mAttachInfo.mOutsets);
            final boolean surfaceSizeChanged = (relayoutResult & WindowManagerGlobal.RELAYOUT_RES_SURFACE_RESIZED) != 0;
            final boolean alwaysConsumeNavBarChanged = mPendingAlwaysConsumeNavBar != mAttachInfo.mAlwaysConsumeNavBar;
            if (contentInsetsChanged) {
                mAttachInfo.mContentInsets.set(mPendingContentInsets);
                if (DEBUG_LAYOUT)
                    Log.v(mTag, "String_Node_Str" + mAttachInfo.mContentInsets);
            }
            if (overscanInsetsChanged) {
                mAttachInfo.mOverscanInsets.set(mPendingOverscanInsets);
                if (DEBUG_LAYOUT)
                    Log.v(mTag, "String_Node_Str" + mAttachInfo.mOverscanInsets);
                contentInsetsChanged = true;
            }
            if (stableInsetsChanged) {
                mAttachInfo.mStableInsets.set(mPendingStableInsets);
                if (DEBUG_LAYOUT)
                    Log.v(mTag, "String_Node_Str" + mAttachInfo.mStableInsets);
                contentInsetsChanged = true;
            }
            if (alwaysConsumeNavBarChanged) {
                mAttachInfo.mAlwaysConsumeNavBar = mPendingAlwaysConsumeNavBar;
                contentInsetsChanged = true;
            }
            if (contentInsetsChanged || mLastSystemUiVisibility != mAttachInfo.mSystemUiVisibility || mApplyInsetsRequested || mLastOverscanRequested != mAttachInfo.mOverscanRequested || outsetsChanged) {
                mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
                mLastOverscanRequested = mAttachInfo.mOverscanRequested;
                mAttachInfo.mOutsets.set(mPendingOutsets);
                mApplyInsetsRequested = false;
                dispatchApplyInsets(host);
            }
            if (visibleInsetsChanged) {
                mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                if (DEBUG_LAYOUT)
                    Log.v(mTag, "String_Node_Str" + mAttachInfo.mVisibleInsets);
            }
            if (!hadSurface) {
                if (mSurface.isValid()) {
                    newSurface = true;
                    mFullRedrawNeeded = true;
                    mPreviousTransparentRegion.setEmpty();
                    if (mAttachInfo.mHardwareRenderer != null) {
                        try {
                            hwInitialized = mAttachInfo.mHardwareRenderer.initialize(mSurface);
                            if (hwInitialized && (host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) == 0) {
                                mSurface.allocateBuffers();
                            }
                        } catch (OutOfResourcesException e) {
                            handleOutOfResourcesException(e);
                            return;
                        }
                    }
                }
            } else if (!mSurface.isValid()) {
                if (mLastScrolledFocus != null) {
                    mLastScrolledFocus.clear();
                }
                mScrollY = mCurScrollY = 0;
                if (mView instanceof RootViewSurfaceTaker) {
                    ((RootViewSurfaceTaker) mView).onRootViewScrollYChanged(mCurScrollY);
                }
                if (mScroller != null) {
                    mScroller.abortAnimation();
                }
                if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
                    mAttachInfo.mHardwareRenderer.destroy();
                }
            } else if ((surfaceGenerationId != mSurface.getGenerationId() || surfaceSizeChanged) && mSurfaceHolder == null && mAttachInfo.mHardwareRenderer != null) {
                mFullRedrawNeeded = true;
                try {
                    mAttachInfo.mHardwareRenderer.updateSurface(mSurface);
                } catch (OutOfResourcesException e) {
                    handleOutOfResourcesException(e);
                    return;
                }
            }
            final boolean freeformResizing = (relayoutResult & WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_FREEFORM) != 0;
            final boolean dockedResizing = (relayoutResult & WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_DOCKED) != 0;
            final boolean dragResizing = freeformResizing || dockedResizing;
            if (mDragResizing != dragResizing) {
                if (dragResizing) {
                    mResizeMode = freeformResizing ? RESIZE_MODE_FREEFORM : RESIZE_MODE_DOCKED_DIVIDER;
                    startDragResizing(mPendingBackDropFrame, mWinFrame.equals(mPendingBackDropFrame), mPendingVisibleInsets, mPendingStableInsets, mResizeMode);
                } else {
                    endDragResizing();
                }
            }
            if (!USE_MT_RENDERER) {
                if (dragResizing) {
                    mCanvasOffsetX = mWinFrame.left;
                    mCanvasOffsetY = mWinFrame.top;
                } else {
                    mCanvasOffsetX = mCanvasOffsetY = 0;
                }
            }
        } catch (RemoteException e) {
        }
        if (DEBUG_ORIENTATION)
            Log.v(TAG, "String_Node_Str" + frame + "String_Node_Str" + mSurface);
        mAttachInfo.mWindowLeft = frame.left;
        mAttachInfo.mWindowTop = frame.top;
        if (mWidth != frame.width() || mHeight != frame.height()) {
            mWidth = frame.width();
            mHeight = frame.height();
        }
        if (mSurfaceHolder != null) {
            if (mSurface.isValid()) {
                mSurfaceHolder.mSurface = mSurface;
            }
            mSurfaceHolder.setSurfaceFrameSize(mWidth, mHeight);
            mSurfaceHolder.mSurfaceLock.unlock();
            if (mSurface.isValid()) {
                if (!hadSurface) {
                    mSurfaceHolder.ungetCallbacks();
                    mIsCreating = true;
                    mSurfaceHolderCallback.surfaceCreated(mSurfaceHolder);
                    SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                    if (callbacks != null) {
                        for (SurfaceHolder.Callback c : callbacks) {
                            c.surfaceCreated(mSurfaceHolder);
                        }
                    }
                    surfaceChanged = true;
                }
                if (surfaceChanged) {
                    mSurfaceHolderCallback.surfaceChanged(mSurfaceHolder, lp.format, mWidth, mHeight);
                    SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                    if (callbacks != null) {
                        for (SurfaceHolder.Callback c : callbacks) {
                            c.surfaceChanged(mSurfaceHolder, lp.format, mWidth, mHeight);
                        }
                    }
                }
                mIsCreating = false;
            } else if (hadSurface) {
                mSurfaceHolder.ungetCallbacks();
                SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                mSurfaceHolderCallback.surfaceDestroyed(mSurfaceHolder);
                if (callbacks != null) {
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceDestroyed(mSurfaceHolder);
                    }
                }
                mSurfaceHolder.mSurfaceLock.lock();
                try {
                    mSurfaceHolder.mSurface = new Surface();
                } finally {
                    mSurfaceHolder.mSurfaceLock.unlock();
                }
            }
        }
        final ThreadedRenderer hardwareRenderer = mAttachInfo.mHardwareRenderer;
        if (hardwareRenderer != null && hardwareRenderer.isEnabled()) {
            if (hwInitialized || mWidth != hardwareRenderer.getWidth() || mHeight != hardwareRenderer.getHeight()) {
                hardwareRenderer.setup(mWidth, mHeight, mAttachInfo, mWindowAttributes.surfaceInsets);
            }
        }
        if (!mStopped || mReportNextDraw) {
            boolean focusChangedDueToTouchMode = ensureTouchModeLocally((relayoutResult & WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
            if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight() || contentInsetsChanged) {
                int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
                int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
                if (DEBUG_LAYOUT)
                    Log.v(mTag, "String_Node_Str" + mWidth + "String_Node_Str" + host.getMeasuredWidth() + "String_Node_Str" + mHeight + "String_Node_Str" + host.getMeasuredHeight() + "String_Node_Str" + contentInsetsChanged);
                performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                int width = host.getMeasuredWidth();
                int height = host.getMeasuredHeight();
                boolean measureAgain = false;
                if (lp.horizontalWeight > 0.0f) {
                    width += (int) ((mWidth - width) * lp.horizontalWeight);
                    childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);
                    measureAgain = true;
                }
                if (lp.verticalWeight > 0.0f) {
                    height += (int) ((mHeight - height) * lp.verticalWeight);
                    childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                    measureAgain = true;
                }
                if (measureAgain) {
                    if (DEBUG_LAYOUT)
                        Log.v(mTag, "String_Node_Str" + width + "String_Node_Str" + height);
                    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                }
                layoutRequested = true;
            }
        }
    } else {
        maybeHandleWindowMove(frame);
    }
    final boolean didLayout = layoutRequested && (!mStopped || mReportNextDraw);
    boolean triggerGlobalLayoutListener = didLayout || mAttachInfo.mRecomputeGlobalAttributes;
    if (didLayout) {
        performLayout(lp, mWidth, mHeight);
        if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {
            host.getLocationInWindow(mTmpLocation);
            mTransparentRegion.set(mTmpLocation[0], mTmpLocation[1], mTmpLocation[0] + host.mRight - host.mLeft, mTmpLocation[1] + host.mBottom - host.mTop);
            host.gatherTransparentRegion(mTransparentRegion);
            if (mTranslator != null) {
                mTranslator.translateRegionInWindowToScreen(mTransparentRegion);
            }
            if (!mTransparentRegion.equals(mPreviousTransparentRegion)) {
                mPreviousTransparentRegion.set(mTransparentRegion);
                mFullRedrawNeeded = true;
                try {
                    mWindowSession.setTransparentRegion(mWindow, mTransparentRegion);
                } catch (RemoteException e) {
                }
            }
        }
        if (DBG) {
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str");
            host.debug();
        }
    }
    if (triggerGlobalLayoutListener) {
        mAttachInfo.mRecomputeGlobalAttributes = false;
        mAttachInfo.mTreeObserver.dispatchOnGlobalLayout();
    }
    if (computesInternalInsets) {
        final ViewTreeObserver.InternalInsetsInfo insets = mAttachInfo.mGivenInternalInsets;
        insets.reset();
        mAttachInfo.mTreeObserver.dispatchOnComputeInternalInsets(insets);
        mAttachInfo.mHasNonEmptyGivenInternalInsets = !insets.isEmpty();
        if (insetsPending || !mLastGivenInsets.equals(insets)) {
            mLastGivenInsets.set(insets);
            final Rect contentInsets;
            final Rect visibleInsets;
            final Region touchableRegion;
            if (mTranslator != null) {
                contentInsets = mTranslator.getTranslatedContentInsets(insets.contentInsets);
                visibleInsets = mTranslator.getTranslatedVisibleInsets(insets.visibleInsets);
                touchableRegion = mTranslator.getTranslatedTouchableArea(insets.touchableRegion);
            } else {
                contentInsets = insets.contentInsets;
                visibleInsets = insets.visibleInsets;
                touchableRegion = insets.touchableRegion;
            }
            try {
                mWindowSession.setInsets(mWindow, insets.mTouchableInsets, contentInsets, visibleInsets, touchableRegion);
            } catch (RemoteException e) {
            }
        }
    }
    if (mFirst) {
        if (DEBUG_INPUT_RESIZE)
            Log.v(mTag, "String_Node_Str" + mView.hasFocus());
        if (mView != null) {
            if (!mView.hasFocus()) {
                mView.requestFocus(View.FOCUS_FORWARD);
                if (DEBUG_INPUT_RESIZE)
                    Log.v(mTag, "String_Node_Str" + mView.findFocus());
            } else {
                if (DEBUG_INPUT_RESIZE)
                    Log.v(mTag, "String_Node_Str" + mView.findFocus());
            }
        }
    }
    final boolean changedVisibility = (viewVisibilityChanged || mFirst) && isViewVisible;
    final boolean hasWindowFocus = mAttachInfo.mHasWindowFocus && isViewVisible;
    final boolean regainedFocus = hasWindowFocus && mLostWindowFocus;
    if (regainedFocus) {
        mLostWindowFocus = false;
    } else if (!hasWindowFocus && mHadWindowFocus) {
        mLostWindowFocus = true;
    }
    if (changedVisibility || regainedFocus) {
        host.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
    }
    mFirst = false;
    mWillDrawSoon = false;
    mNewSurfaceNeeded = false;
    mActivityRelaunched = false;
    mViewVisibility = viewVisibility;
    mHadWindowFocus = hasWindowFocus;
    if (hasWindowFocus && !isInLocalFocusMode()) {
        final boolean imTarget = WindowManager.LayoutParams.mayUseInputMethod(mWindowAttributes.flags);
        if (imTarget != mLastWasImTarget) {
            mLastWasImTarget = imTarget;
            InputMethodManager imm = InputMethodManager.peekInstance();
            if (imm != null && imTarget) {
                imm.onPreWindowFocus(mView, hasWindowFocus);
                imm.onPostWindowFocus(mView, mView.findFocus(), mWindowAttributes.softInputMode, !mHasHadWindowFocus, mWindowAttributes.flags);
            }
        }
    }
    if ((relayoutResult & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
        mReportNextDraw = true;
    }
    boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() || !isViewVisible;
    if (!cancelDraw && !newSurface) {
        if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).startChangingAnimations();
            }
            mPendingTransitions.clear();
        }
        performDraw();
    } else {
        if (isViewVisible) {
            scheduleTraversals();
        } else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).endChangingAnimations();
            }
            mPendingTransitions.clear();
        }
    }
    mIsInTraversal = false;
}

Output:
             if (mSurface.isValid()) {
-                if (!hadSurface) {
+                if (!hadSurface || surfaceGenerationId != mSurface.getGenerationId()) {
                     mSurfaceHolder.ungetCallbacks();


Input:
public TableDefinition buildCITYSLICKERTable() {
    TableDefinition table = new TableDefinition();
    table.setName("String_Node_Str");
    FieldDefinition fieldFNAME = new FieldDefinition();
    fieldFNAME.setName("String_Node_Str");
    fieldFNAME.setTypeName("String_Node_Str");
    fieldFNAME.setSize(20);
    fieldFNAME.setSubSize(0);
    fieldFNAME.setIsPrimaryKey(true);
    fieldFNAME.setIsIdentity(false);
    fieldFNAME.setUnique(true);
    fieldFNAME.setShouldAllowNull(false);
    table.addField(fieldFNAME);
    FieldDefinition fieldLNAME = new FieldDefinition();
    fieldLNAME.setName("String_Node_Str");
    fieldLNAME.setTypeName("String_Node_Str");
    fieldLNAME.setSize(20);
    fieldLNAME.setSubSize(0);
    fieldLNAME.setIsPrimaryKey(true);
    fieldLNAME.setIsIdentity(false);
    fieldLNAME.setUnique(true);
    fieldLNAME.setShouldAllowNull(false);
    table.addField(fieldLNAME);
    FieldDefinition fieldAGE = new FieldDefinition();
    fieldAGE.setName("String_Node_Str");
    fieldAGE.setTypeName("String_Node_Str");
    fieldAGE.setSize(15);
    fieldAGE.setSubSize(0);
    fieldAGE.setIsPrimaryKey(false);
    fieldAGE.setIsIdentity(false);
    fieldAGE.setUnique(false);
    fieldAGE.setShouldAllowNull(false);
    table.addField(fieldAGE);
    FieldDefinition fieldGENDER = new FieldDefinition();
    fieldGENDER.setName("String_Node_Str");
    fieldGENDER.setTypeName("String_Node_Str");
    fieldGENDER.setSize(6);
    fieldGENDER.setSubSize(0);
    fieldGENDER.setIsPrimaryKey(false);
    fieldGENDER.setIsIdentity(false);
    fieldGENDER.setUnique(false);
    fieldGENDER.setShouldAllowNull(true);
    table.addField(fieldGENDER);
    FieldDefinition fieldWORLDID = new FieldDefinition();
    fieldWORLDID.setName("String_Node_Str");
    fieldWORLDID.setTypeName("String_Node_Str");
    fieldWORLDID.setSize(10);
    fieldWORLDID.setSubSize(0);
    fieldWORLDID.setIsPrimaryKey(false);
    fieldWORLDID.setIsIdentity(false);
    fieldWORLDID.setUnique(false);
    fieldWORLDID.setShouldAllowNull(true);
    fieldWORLDID.setForeignKeyFieldName("String_Node_Str");
    table.addField(fieldWORLDID);
    return table;
}

Output:
     fieldWORLDID.setTypeName("String_Node_Str");
-    fieldWORLDID.setSize(10);
+    fieldWORLDID.setSize(19);
     fieldWORLDID.setSubSize(0);


Input:
public Set<InferredEdge> getNearbyEdges(Vector mean) {
    Set<InferredEdge> results = Sets.newHashSet();
    SnappedEdges snappedEdges = this.narratedGraph.snapToGraph(null, new Coordinate(mean.getElement(0), mean.getElement(1)));
    for (Edge edge : snappedEdges.getSnappedEdges()) {
        results.add(getInferredEdge(edge));
    }
    return results;
}

Output:
     Set<InferredEdge> results = Sets.newHashSet();
-    SnappedEdges snappedEdges = this.narratedGraph.snapToGraph(null, new Coordinate(mean.getElement(0), mean.getElement(1)));
+    Coordinate latlon = GeoUtils.convertToLatLon(mean);
+    SnappedEdges snappedEdges = this.narratedGraph.snapToGraph(null, latlon);
     for (Edge edge : snappedEdges.getSnappedEdges()) {


Input:
public boolean loadJSON(JSONObject json) throws JSONException {
    boolean success = super.loadJSON(json);
    if (success) {
        setUpdateTime(new Date(json.getLong(JSON_LAST_UPDATE)));
    }
    return success;
}

Output:
     if (success) {
-        setUpdateTime(new Date(json.getLong(JSON_LAST_UPDATE)));
+        setUpdateDate(new Date(json.getLong(JSON_LAST_UPDATE)));
+        mFraction = json.getDouble(JSON_FRACTION_VALUE);
+        mParentCurrency = json.getString(JSON_FRACTION_PARENT);
     }


Input:
public static int[] sampleWithReplacement(int[] array, double[] probabilities, int numberOfSamples) {
    if (array.length != probabilities.length)
        throw new IllegalArgumentException("String_Node_Str" + "String_Node_Str");
    double[] cumulativeDensityFunction = new double[probabilities.length];
    cumulativeDensityFunction[0] = probabilities[0];
    for (int index = 1; index < probabilities.length; index++) cumulativeDensityFunction[index] = cumulativeDensityFunction[index - 1] + probabilities[index];
    int[] resultArray = new int[numberOfSamples];
    for (int index = 0; index < numberOfSamples; index++) {
        double number = random.nextDouble();
        int elementIndex = Arrays.binarySearch(cumulativeDensityFunction, number);
        if (elementIndex < 0) {
            elementIndex = -elementIndex - 1;
            if (elementIndex == probabilities.length)
                elementIndex--;
        }
        resultArray[index] = array[elementIndex];
    }
    return resultArray;
}

Output:
         throw new IllegalArgumentException("String_Node_Str" + "String_Node_Str");
-    double[] cumulativeDensityFunction = new double[probabilities.length];
-    cumulativeDensityFunction[0] = probabilities[0];
-    for (int index = 1; index < probabilities.length; index++) cumulativeDensityFunction[index] = cumulativeDensityFunction[index - 1] + probabilities[index];
+    double weightsSum = weights[0];
+    for (int index = 1; index < weights.length; index++) weightsSum += weights[index];
+    double[] cumulativeDensityFunction = new double[weights.length];
+    cumulativeDensityFunction[0] = weights[0] / weightsSum;
+    for (int index = 1; index < weights.length; index++) cumulativeDensityFunction[index] = cumulativeDensityFunction[index - 1] + (weights[index] / weightsSum);
     int[] resultArray = new int[numberOfSamples];