Input:
private static String getNormalizeParameterValue(String value, IElementParameter ep, boolean itemFromTable) {
    List<EParameterFieldType> escapeQuotation = Arrays.asList(EParameterFieldType.MEMO_JAVA, EParameterFieldType.SCHEMA_XPATH_QUERYS);
    if (escapeQuotation.contains(ep.getFieldType()) && ep.isRaw()) {
        value = value.replaceAll("String_Node_Str", "String_Node_Str");
    }
    List<EParameterFieldType> needRemoveCRLFList = Arrays.asList(EParameterFieldType.MEMO, EParameterFieldType.MEMO_JAVA, EParameterFieldType.MEMO_SQL, EParameterFieldType.MEMO_IMPORT, EParameterFieldType.MEMO_MESSAGE);
    if (needRemoveCRLFList.contains(ep.getFieldType())) {
        value = value.replaceAll("String_Node_Str", "String_Node_Str");
    }
    List<EParameterFieldType> needQuoteList = Arrays.asList(EParameterFieldType.CLOSED_LIST, EParameterFieldType.COMPONENT_LIST, EParameterFieldType.COLUMN_LIST, EParameterFieldType.PREV_COLUMN_LIST, EParameterFieldType.CONNECTION_LIST, EParameterFieldType.LOOKUP_COLUMN_LIST, EParameterFieldType.CONTEXT_PARAM_NAME_LIST, EParameterFieldType.PROCESS_TYPE, EParameterFieldType.COLOR, EParameterFieldType.TABLE_BY_ROW, EParameterFieldType.HADOOP_JARS_DIALOG);
    List<EParameterFieldType> needQuoteListForItem = itemFromTable ? Arrays.asList(EParameterFieldType.SCHEMA_TYPE, EParameterFieldType.MODULE_LIST) : new ArrayList<EParameterFieldType>();
    List<String> needQuoteListByName = Arrays.asList("String_Node_Str");
    if (needQuoteList.contains(ep.getFieldType()) || needQuoteListForItem.contains(ep.getFieldType()) || needQuoteListByName.contains(ep.getName()) || ep.isRaw()) {
        value = "String_Node_Str" + value + "String_Node_Str";
    }
    if (value == null || "String_Node_Str".equals(value.trim())) {
        value = "String_Node_Str";
    } else if ("String_Node_Str".equals(value) || "String_Node_Str".equals(value) || "String_Node_Str".equals(value)) {
        value = value.replaceAll("String_Node_Str", "String_Node_Str");
    } else if ("String_Node_Str".equals(value)) {
        value = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    } else if ("String_Node_Str".equals(value)) {
        value = "String_Node_Str";
    } else if ("String_Node_Str".equals(value)) {
        value = "String_Node_Str";
    } else if ("String_Node_Str".equals(value)) {
        value = "String_Node_Str";
    }
    return value;
}

Output:
     List<EParameterFieldType> needQuoteList = Arrays.asList(EParameterFieldType.CLOSED_LIST, EParameterFieldType.COMPONENT_LIST, EParameterFieldType.COLUMN_LIST, EParameterFieldType.PREV_COLUMN_LIST, EParameterFieldType.CONNECTION_LIST, EParameterFieldType.LOOKUP_COLUMN_LIST, EParameterFieldType.CONTEXT_PARAM_NAME_LIST, EParameterFieldType.PROCESS_TYPE, EParameterFieldType.COLOR, EParameterFieldType.TABLE_BY_ROW, EParameterFieldType.HADOOP_JARS_DIALOG);
-    List<EParameterFieldType> needQuoteListForItem = itemFromTable ? Arrays.asList(EParameterFieldType.SCHEMA_TYPE, EParameterFieldType.MODULE_LIST) : new ArrayList<EParameterFieldType>();
+    List<EParameterFieldType> needQuoteListForItem = itemFromTable ? Arrays.asList(EParameterFieldType.SCHEMA_TYPE, EParameterFieldType.SAP_SCHEMA_TYPE, EParameterFieldType.MODULE_LIST) : new ArrayList<EParameterFieldType>();
     List<String> needQuoteListByName = Arrays.asList("String_Node_Str");


Input:
protected int addButtons(Composite cmp, final Table table) {
    btnAddAgg = new Button(cmp, SWT.PUSH);
    btnAddAgg.setText(Messages.getString("String_Node_Str"));
    GridData data = new GridData();
    data.widthHint = Math.max(60, btnAddAgg.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
    btnAddAgg.setLayoutData(data);
    btnAddAgg.addListener(SWT.Selection, new Listener() {

        public void handleEvent(Event event) {
            DataColumnBindingDialog dialog = new DataColumnBindingDialog(true);
            dialog.setInput(inputElement, null, context);
            dialog.setExpressionProvider(expressionProvider);
            dialog.setAggreate(true);
            if (dialog.open() == Dialog.OK) {
                if (bindingTable != null) {
                    refreshBindingTable();
                    bindingTable.getTable().setSelection(bindingTable.getTable().getItemCount() - 1);
                }
            }
            refreshBindingTable();
            if (table.getItemCount() > 0)
                setSelectionInTable(table.getItemCount() - 1);
            updateButtons();
        }
    });
    btnRefresh = new Button(cmp, SWT.PUSH);
    btnRefresh.setText(Messages.getString("String_Node_Str"));
    data = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
    data.widthHint = Math.max(60, btnRefresh.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
    btnRefresh.setLayoutData(data);
    btnRefresh.addListener(SWT.Selection, new Listener() {
        public void handleEvent(Event event) {
            try {
                List<ComputedColumn> columnList = new ArrayList<ComputedColumn>();
                CubeHandle cubeHandle = ChartXTabUtil.getBindingCube(inputElement);
                if (cubeHandle != null) {
                    if (inputElement.getCube() == null) {
                        refreshBindingTable();
                    } else {
                        List<LevelHandle> levels = ChartXTabUtil.getAllLevels(cubeHandle);
                        for (Iterator<LevelHandle> iter = levels.iterator(); iter.hasNext(); ) {
                            LevelHandle levelHandle = iter.next();
                            ComputedColumn column = StructureFactory.newComputedColumn(inputElement, ChartXTabUtil.createLevelBindingName(levelHandle));
                            column.setDataType(levelHandle.getDataType());
                            column.setExpression(ChartXTabUtil.createDimensionExpression(levelHandle));
                            columnList.add(column);
                        }
                        List<MeasureHandle> measures = ChartXTabUtil.getAllMeasures(cubeHandle);
                        for (Iterator<MeasureHandle> iter = measures.iterator(); iter.hasNext(); ) {
                            MeasureHandle measureHandle = iter.next();
                            ComputedColumn column = StructureFactory.newComputedColumn(inputElement, ChartXTabUtil.createMeasureBindingName(measureHandle));
                            column.setDataType(measureHandle.getDataType());
                            column.setExpression(ExpressionUtil.createJSMeasureExpression(measureHandle.getName()));
                            column.setAggregateFunction(measureHandle.getFunction());
                            columnList.add(column);
                        }
                        if (columnList.size() > 0) {
                            for (Iterator<ComputedColumn> iter = columnList.iterator(); iter.hasNext(); ) {
                                DEUtil.addColumn(inputElement, iter.next(), false);
                            }
                        }
                    }
                } else {
                    DataSetHandle dataSetHandle = inputElement.getDataSet();
                    if (dataSetHandle == null) {
                        refreshBindingTable();
                    } else {
                        List resultSetColumnList = DataUtil.getColumnList(dataSetHandle);
                        for (Iterator iterator = resultSetColumnList.iterator(); iterator.hasNext(); ) {
                            ResultSetColumnHandle resultSetColumn = (ResultSetColumnHandle) iterator.next();
                            ComputedColumn column = StructureFactory.newComputedColumn(inputElement, resultSetColumn.getColumnName());
                            column.setDataType(resultSetColumn.getDataType());
                            column.setExpression(DEUtil.getExpression(resultSetColumn));
                            columnList.add(column);
                        }
                        if (columnList.size() > 0) {
                            for (Iterator<ComputedColumn> iter = columnList.iterator(); iter.hasNext(); ) {
                                DEUtil.addColumn(inputElement, iter.next(), false);
                            }
                        }
                    }
                }
                bindingTable.setInput(inputElement);
            } catch (SemanticException e) {
                WizardBase.displayException(e);
            }
        }
    });
    return 2;
}

Output:
 protected int addButtons(Composite cmp, final Table table) {
-    btnAddAgg = new Button(cmp, SWT.PUSH);
-    btnAddAgg.setText(Messages.getString("String_Node_Str"));
-    GridData data = new GridData();
-    data.widthHint = Math.max(60, btnAddAgg.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
-    btnAddAgg.setLayoutData(data);
-    btnAddAgg.addListener(SWT.Selection, new Listener() {
+    Listener[] listeners = getAggregationButton().getListeners(SWT.Selection);
+    if (listeners.length > 0) {
+        getAggregationButton().removeListener(SWT.Selection, listeners[0]);
+    }
+    getAggregationButton().addListener(SWT.Selection, new Listener() {


Input:
private final HistoryRecord performClearTaskLocked(int taskId, HistoryRecord newR, int launchFlags, boolean doClear) {
    int i = mHistory.size();
    while (i > 0) {
        i--;
        HistoryRecord r = (HistoryRecord) mHistory.get(i);
        if (r.task.taskId == taskId) {
            i++;
            break;
        }
    }
    while (i > 0) {
        i--;
        HistoryRecord r = (HistoryRecord) mHistory.get(i);
        if (r.finishing) {
            continue;
        }
        if (r.task.taskId != taskId) {
            return null;
        }
        if (r.realActivity.equals(newR.realActivity)) {
            HistoryRecord ret = r;
            if (doClear) {
                while (i < (mHistory.size() - 1)) {
                    i++;
                    r = (HistoryRecord) mHistory.get(i);
                    if (r.finishing) {
                        continue;
                    }
                    if (finishActivityLocked(r, i, Activity.RESULT_CANCELED, null, "String_Node_Str")) {
                        i--;
                    }
                }
            }
            if (ret.launchMode == ActivityInfo.LAUNCH_MULTIPLE && (launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) == 0) {
                if (!ret.finishing) {
                    int index = indexOfTokenLocked(ret);
                    if (index >= 0) {
                        finishActivityLocked(ret, 0, Activity.RESULT_CANCELED, null, "String_Node_Str");
                    }
                    return null;
                }
            }
            return ret;
        }
    }
    return null;
}

Output:
                     if (index >= 0) {
-                        finishActivityLocked(ret, 0, Activity.RESULT_CANCELED, null, "String_Node_Str");
+                        finishActivityLocked(ret, index, Activity.RESULT_CANCELED, null, "String_Node_Str");
                     }


Input:
public void actionPerformed(TableElementButton tableElementButton, String actionID) {
    if (actionID.equals("String_Node_Str")) {
        int index = Integer.valueOf(tableElementButton.getID().substring(3));
        BlockTransformerProvider provider = StructureHandler.blockTransformerProviderForID(currentTransformerType);
        BlockTransformer blockTransformer = provider.defaultTransformer();
        TableDataSource tableDataSource = provider.tableDataSource(blockTransformer);
        blockTransformerList.add(index, blockTransformer);
        navigator.pushTable(new GuiTable(tableDelegate, tableDataSource));
    } else if (actionID.equals("String_Node_Str")) {
        currentTransformerType = nextTransformerID(currentTransformerType);
        tableDelegate.reloadData();
    } else if (tableElementButton.getID().startsWith("String_Node_Str")) {
        int index = Integer.valueOf(tableElementButton.getID().substring(11));
        BlockTransformer blockTransformer = blockTransformerList.get(index);
        BlockTransformerProvider provider = StructureHandler.blockTransformerProviderForID(StructureHandler.blockTransformerIDForType(blockTransformer.getClass()));
        if (actionID.equals("String_Node_Str")) {
            navigator.pushTable(new GuiTable(tableDelegate, provider.tableDataSource(blockTransformer)));
        } else if (actionID.equals("String_Node_Str")) {
            blockTransformerList.remove(blockTransformer);
            tableDelegate.reloadData();
        } else if (actionID.equals("String_Node_Str")) {
            blockTransformerList.remove(index);
            blockTransformerList.add(index - 1, blockTransformer);
            tableDelegate.reloadData();
        } else if (actionID.equals("String_Node_Str")) {
            blockTransformerList.remove(index);
            blockTransformerList.add(index + 1, blockTransformer);
            tableDelegate.reloadData();
        }
    }
}

Output:
         BlockTransformerProvider provider = StructureHandler.blockTransformerProviderForID(StructureHandler.blockTransformerIDForType(blockTransformer.getClass()));
-        if (actionID.equals("String_Node_Str")) {
-            navigator.pushTable(new GuiTable(tableDelegate, provider.tableDataSource(blockTransformer)));
-        } else if (actionID.equals("String_Node_Str")) {
-            blockTransformerList.remove(blockTransformer);
-            tableDelegate.reloadData();
-        } else if (actionID.equals("String_Node_Str")) {
-            blockTransformerList.remove(index);
-            blockTransformerList.add(index - 1, blockTransformer);
-            tableDelegate.reloadData();
-        } else if (actionID.equals("String_Node_Str")) {
-            blockTransformerList.remove(index);
-            blockTransformerList.add(index + 1, blockTransformer);
-            tableDelegate.reloadData();
+        switch(actionID) {
+            case "String_Node_Str":
+                navigator.pushTable(new GuiTable(tableDelegate, provider.tableDataSource(blockTransformer)));
+                break;
+            case "String_Node_Str":
+                blockTransformerList.remove(blockTransformer);
+                tableDelegate.reloadData();
+                break;
+            case "String_Node_Str":
+                blockTransformerList.remove(index);
+                blockTransformerList.add(index - 1, blockTransformer);
+                tableDelegate.reloadData();
+                break;
+            case "String_Node_Str":
+                blockTransformerList.remove(index);
+                blockTransformerList.add(index + 1, blockTransformer);
+                tableDelegate.reloadData();
+                break;
         }


Input:
public void testHigherHitsCacheMergePolicy() {
    String cacheName = randomMapName();
    Config config = newConfig();
    HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config);
    HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config);
    TestMemberShipListener memberShipListener = new TestMemberShipListener(1);
    h2.getCluster().addMembershipListener(memberShipListener);
    TestLifeCycleListener lifeCycleListener = new TestLifeCycleListener(1);
    h2.getLifecycleService().addLifecycleListener(lifeCycleListener);
    closeConnectionBetween(h1, h2);
    assertOpenEventually(memberShipListener.latch);
    assertClusterSizeEventually(1, h1);
    assertClusterSizeEventually(1, h2);
    CachingProvider cachingProvider1 = HazelcastServerCachingProvider.createCachingProvider(h1);
    CachingProvider cachingProvider2 = HazelcastServerCachingProvider.createCachingProvider(h2);
    CacheManager cacheManager1 = cachingProvider1.getCacheManager();
    CacheManager cacheManager2 = cachingProvider2.getCacheManager();
    CacheConfig cacheConfig = newCacheConfig(cacheName, HigherHitsCacheMergePolicy.class.getName());
    Cache cache1 = cacheManager1.createCache(cacheName, cacheConfig);
    Cache cache2 = cacheManager2.createCache(cacheName, cacheConfig);
    cache1.put("String_Node_Str", "String_Node_Str");
    cache1.put("String_Node_Str", "String_Node_Str");
    assertEquals("String_Node_Str", cache1.get("String_Node_Str"));
    assertEquals("String_Node_Str", cache1.get("String_Node_Str"));
    cache2.put("String_Node_Str", "String_Node_Str");
    cache2.put("String_Node_Str", "String_Node_Str");
    assertEquals("String_Node_Str", cache2.get("String_Node_Str"));
    assertEquals("String_Node_Str", cache2.get("String_Node_Str"));
    assertOpenEventually(lifeCycleListener.latch);
    assertClusterSizeEventually(2, h1);
    assertClusterSizeEventually(2, h2);
    Cache cacheTest = cacheManager2.getCache(cacheName);
    assertEquals("String_Node_Str", cacheTest.get("String_Node_Str"));
    assertEquals("String_Node_Str", cacheTest.get("String_Node_Str"));
}

Output:
     h2.getCluster().addMembershipListener(memberShipListener);
-    TestLifeCycleListener lifeCycleListener = new TestLifeCycleListener(1);
+    CountDownLatch mergeBlockingLatch = new CountDownLatch(1);
+    TestLifeCycleListener lifeCycleListener = new TestLifeCycleListener(1, mergeBlockingLatch);
     h2.getLifecycleService().addLifecycleListener(lifeCycleListener);


Input:
public User putUser(User user) throws StoreException {
    User savedUser = this.getUser(user.getUserid());
    if (savedUser == null) {
        return null;
    }
    if (user.getDescription() != null) {
        savedUser.setDescription(user.getDescription());
    }
    if (user.getName() != null) {
        savedUser.setName(user.getName());
    }
    if (user.getEnabled() != null) {
        savedUser.setEnabled(user.getEnabled());
    }
    if (user.getEmail() != null) {
        savedUser.setEmail(user.getEmail());
    }
    if (user.getPassword() != null) {
        savedUser.setPassword(user.getPassword());
    }
    Connection conn = dbConnect();
    try {
        String query = "String_Node_Str";
        PreparedStatement statement = conn.prepareStatement(query);
        statement.setString(1, savedUser.getName());
        statement.setString(2, savedUser.getEmail());
        statement.setString(3, savedUser.getPassword());
        statement.setString(4, savedUser.getDescription());
        statement.setInt(5, savedUser.getEnabled() ? 1 : 0);
        statement.setInt(6, savedUser.getUserid());
        statement.executeUpdate();
        statement.close();
    } catch (SQLException s) {
        throw new StoreException("String_Node_Str" + s);
    } finally {
        dbClose();
    }
    return savedUser;
}

Output:
     if (user.getPassword() != null) {
-        savedUser.setPassword(user.getPassword());
+        savedUser.setPassword(SHA256Calculator.getSHA256(user.getPassword(), user.getSalt()));
     }


Input:
private Boolean isStudySubjecAndCRCRolesMatch(String studySubjectId, String crcUserName, String studyOid) {
    StudyBean parentStudy = getParentStudy(studyOid);
    Integer studyIdFromStudyOid = parentStudy.getId();
    StudySubjectBean studySubjectBean = getStudySubject(studySubjectId, parentStudy);
    Integer studyIdFromStudySubjectId = studySubjectBean.getStudyId();
    System.out.println("String_Node_Str");
    System.out.println("String_Node_Str" + studyIdFromStudyOid);
    System.out.println("String_Node_Str" + studySubjectId);
    System.out.println("String_Node_Str" + studyIdFromStudySubjectId);
    return doesCRCNotHaveStudySubjectAccessRole(crcUserName, studyIdFromStudySubjectId);
}

Output:
     System.out.println("String_Node_Str" + studyIdFromStudySubjectId);
-    return doesCRCNotHaveStudySubjectAccessRole(crcUserName, studyIdFromStudySubjectId);
+    return doesStudySubjecAndCRCRolesMatch(crcUserName, studyIdFromStudySubjectId);
 }


Input:
public void sessionStatusChanged(WonderlandSession session, WonderlandSession.Status status) {
    logger.warning("String_Node_Str" + session + "String_Node_Str" + status);
    if (status.equals(WonderlandSession.Status.CONNECTED)) {
        try {
            new AudioManagerClient(session);
        } catch (ConnectionFailureException e) {
            logger.warning(e.getMessage());
        }
    }
}

Output:
     if (status.equals(WonderlandSession.Status.CONNECTED)) {
-        try {
-            new AudioManagerClient(session);
-        } catch (ConnectionFailureException e) {
-            logger.warning(e.getMessage());
-        }
+        connectClient(session);
+    } else if (status.equals(WonderlandSession.Status.DISCONNECTED)) {
+        disconnectClient();
     }


Input:
private void convertTexts(String dungeonKeeperFolder, String destination) {
    if (!ConvertProcess.INTERFACE_TEXTS.isOutdated()) {
        return;
    }
    logger.log(Level.INFO, "String_Node_Str", destination);
    updateStatus(null, null, ConvertProcess.INTERFACE_TEXTS);
    AssetUtils.deleteFolder(new File(destination));
    String dataDirectory = dungeonKeeperFolder + PathUtils.DKII_TEXT_DEFAULT_FOLDER;
    final List<File> srtFiles = new ArrayList<>();
    File dataDir = new File(dataDirectory);
    try {
        Files.walkFileTree(dataDir.toPath(), EnumSet.noneOf(FileVisitOption.class), 1, new SimpleFileVisitor<Path>() {
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                if (attrs.isRegularFile() && file.getFileName().toString().toLowerCase().endsWith("String_Node_Str")) {
                    srtFiles.add(file.toFile());
                }
                return FileVisitResult.CONTINUE;
            }
        });
    } catch (IOException ex) {
        String msg = "String_Node_Str" + dataDirectory + "String_Node_Str";
        logger.log(Level.SEVERE, msg, ex);
        throw new RuntimeException(msg, ex);
    }
    new File(destination).mkdirs();
    int i = 0;
    int total = srtFiles.size();
    CharBuffer codePage = null;
    for (File file : srtFiles) {
        updateStatus(i, total, ConvertProcess.INTERFACE_TEXTS);
        i++;
        StrFile strFile;
        if (codePage == null) {
            strFile = new StrFile(file);
            codePage = strFile.getCodePage();
        } else {
            strFile = new StrFile(codePage, file);
        }
        String fileName = file.getName();
        fileName = fileName.substring(0, fileName.length() - 3);
        File dictFile = new File(destination.concat(fileName).concat("String_Node_Str"));
        try (PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(dictFile, false), "String_Node_Str"))) {
            for (Map.Entry<Integer, String> entry : strFile.getEntriesAsSet()) {
                pw.println(entry.getKey() + "String_Node_Str" + entry.getValue());
            }
        } catch (IOException ex) {
            String msg = "String_Node_Str" + dictFile + "String_Node_Str";
            logger.log(Level.SEVERE, msg, ex);
            throw new RuntimeException(msg, ex);
        }
    }
}

Output:
     }
-    logger.log(Level.INFO, "String_Node_Str", destination);
+    LOGGER.log(Level.INFO, "String_Node_Str", destination);
     updateStatus(null, null, ConvertProcess.INTERFACE_TEXTS);


Input:
public void dispatch(Packet packet) {
    try {
        if (packet.isFlagSet(FLAG_OP)) {
            if (packet.isFlagSet(FLAG_RESPONSE)) {
                responseHandler.handle(packet);
            } else if (packet.isFlagSet(FLAG_OP_CONTROL)) {
                invocationMonitor.handle(packet);
            } else {
                operationExecutor.handle(packet);
            }
        } else if (packet.isFlagSet(FLAG_EVENT)) {
            eventService.handle(packet);
        } else if (packet.isFlagSet(FLAG_BIND)) {
            connectionManager.handle(packet);
        } else {
            logger.severe("String_Node_Str" + packet.getFlags());
        }
    } catch (Throwable t) {
        inspectOutputMemoryError(t);
        logger.severe("String_Node_Str" + packet, t);
    }
}

Output:
     } catch (Throwable t) {
-        inspectOutputMemoryError(t);
+        inspectOutOfMemoryError(t);
         logger.severe("String_Node_Str" + packet, t);


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object value, AbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    Converter converter = xmlChoiceCollectionMapping.getConverter();
    if (null != converter) {
        if (converter instanceof XMLConverter) {
            value = ((XMLConverter) converter).convertObjectValueToDataValue(value, session, marshalRecord.getMarshaller());
        } else {
            value = converter.convertObjectValueToDataValue(value, session);
        }
    }
    NodeValue associatedNodeValue = null;
    XMLField associatedField = null;
    Object fieldValue = value;
    if (value instanceof XMLRoot) {
        XMLRoot rootValue = (XMLRoot) value;
        String localName = rootValue.getLocalName();
        String namespaceUri = rootValue.getNamespaceURI();
        fieldValue = rootValue.getObject();
        associatedField = getFieldForName(localName, namespaceUri);
        if (associatedField == null) {
            associatedField = xmlChoiceCollectionMapping.getClassToFieldMappings().get(fieldValue.getClass());
        }
    } else {
        associatedField = xmlChoiceCollectionMapping.getClassToFieldMappings().get(value.getClass());
    }
    if (associatedField == null) {
        List<XMLField> sourceFields = xmlChoiceCollectionMapping.getClassToSourceFieldsMappings().get(value.getClass());
        if (sourceFields != null) {
            associatedField = sourceFields.get(0);
        }
    }
    if (associatedField != null) {
        associatedNodeValue = this.fieldToNodeValues.get(associatedField);
    }
    if (associatedNodeValue != null) {
        XPathFragment frag = associatedField.getXPathFragment();
        associatedNodeValue = ((XMLChoiceCollectionMappingUnmarshalNodeValue) associatedNodeValue).getChoiceElementMarshalNodeValue();
        while (frag != null) {
            if (associatedNodeValue.isOwningNode(frag)) {
                ContainerValue nestedNodeValue = (ContainerValue) associatedNodeValue;
                nestedNodeValue.marshalSingleValue(frag, marshalRecord, object, fieldValue, session, namespaceResolver, marshalContext);
                break;
            }
            frag = frag.getNextFragment();
            if (frag == null) {
                ContainerValue nestedNodeValue = (ContainerValue) associatedNodeValue;
                nestedNodeValue.marshalSingleValue(frag, marshalRecord, object, fieldValue, session, namespaceResolver, marshalContext);
            }
        }
    }
    return true;
}

Output:
     } else {
-        associatedField = xmlChoiceCollectionMapping.getClassToFieldMappings().get(value.getClass());
+        if (value.getClass() == ClassConstants.STRING && this.xmlChoiceCollectionMapping.isMixedContent()) {
+            marshalMixedContent(marshalRecord, (String) value);
+            return true;
+        } else {
+            associatedField = xmlChoiceCollectionMapping.getClassToFieldMappings().get(value.getClass());
+        }
     }


Input:
private void addBands(Product product, Map<Integer, BandInfo> bandInfoMap, MultiLevelImageFactory mlif) throws IOException {
    product.setPreferredTileSize(DEFAULT_TILE_SIZE, DEFAULT_TILE_SIZE);
    product.setNumResolutionsMax(L1C_TILE_LAYOUTS[0].numResolutions);
    product.setAutoGrouping("String_Node_Str");
    ArrayList<Integer> bandIndexes = new ArrayList<Integer>(bandInfoMap.keySet());
    Collections.sort(bandIndexes);
    if (bandIndexes.isEmpty()) {
        throw new IOException("String_Node_Str");
    }
    for (Integer bandIndex : bandIndexes) {
        BandInfo bandInfo = bandInfoMap.get(bandIndex);
        Band band = addBand(product, bandInfo);
        band.setSourceImage(mlif.createSourceImage(bandInfo));
    }
    for (Integer bandIndex : bandIndexes) {
        BandInfo bandInfo = bandInfoMap.get(bandIndex);
        Band reflec = product.addBand(bandInfo.wavebandInfo.bandName.replace("String_Node_Str", "String_Node_Str"), bandInfo.wavebandInfo.bandName + "String_Node_Str" + bandInfo.wavebandInfo.reflecUnit + "String_Node_Str" + bandInfo.wavebandInfo.quantificationValue + "String_Node_Str");
        reflec.setDescription("String_Node_Str" + bandInfo.wavebandInfo.bandName + "String_Node_Str");
    }
    for (Integer bandIndex : bandIndexes) {
        BandInfo bandInfo = bandInfoMap.get(bandIndex);
        Band radiance = product.addBand(bandInfo.wavebandInfo.bandName.replace("String_Node_Str", "String_Node_Str"), bandInfo.wavebandInfo.bandName + "String_Node_Str" + bandInfo.wavebandInfo.solarIrradiance + "String_Node_Str" + bandInfo.wavebandInfo.reflecUnit + "String_Node_Str" + bandInfo.wavebandInfo.quantificationValue + "String_Node_Str");
        radiance.setDescription("String_Node_Str" + bandInfo.wavebandInfo.bandName + "String_Node_Str");
    }
    Band ndvi = product.addBand("String_Node_Str", "String_Node_Str");
    ndvi.setDescription("String_Node_Str");
}

Output:
 private void addBands(Product product, Map<Integer, BandInfo> bandInfoMap, MultiLevelImageFactory mlif) throws IOException {
-    product.setPreferredTileSize(DEFAULT_TILE_SIZE, DEFAULT_TILE_SIZE);
+    product.setPreferredTileSize(DEFAULT_JAI_TILE_SIZE, DEFAULT_JAI_TILE_SIZE);
     product.setNumResolutionsMax(L1C_TILE_LAYOUTS[0].numResolutions);


Input:
protected void updateDataServer() {
    dataWatcher.updateObject(12, Float.valueOf((float) laser.tail.x));
    dataWatcher.updateObject(13, Float.valueOf((float) laser.tail.y));
    dataWatcher.updateObject(14, Float.valueOf((float) laser.tail.z));
    dataWatcher.updateObject(15, Byte.valueOf((byte) (laser.isVisible ? 1 : 0)));
    dataWatcher.updateObject(17, Float.valueOf(itemAngle1));
    dataWatcher.updateObject(18, Float.valueOf(itemAngle2));
}

Output:
 protected void updateDataServer() {
-    dataWatcher.updateObject(12, Float.valueOf((float) laser.tail.x));
-    dataWatcher.updateObject(13, Float.valueOf((float) laser.tail.y));
-    dataWatcher.updateObject(14, Float.valueOf((float) laser.tail.z));
+    dataWatcher.updateObject(12, Float.valueOf((float) laser.tail.xCoord));
+    dataWatcher.updateObject(13, Float.valueOf((float) laser.tail.yCoord));
+    dataWatcher.updateObject(14, Float.valueOf((float) laser.tail.zCoord));
     dataWatcher.updateObject(15, Byte.valueOf((byte) (laser.isVisible ? 1 : 0)));


Input:
public void onRow(Row4Aggregation row) throws IOException, DataException {
    Row4Aggregation newRow = new Row4Aggregation();
    if (row.getLevelMembers().length != newMemberSize && orignalLevelCount == newMemberSize) {
        Member[] nMembers = new Member[newMemberSize];
        System.arraycopy(row.getLevelMembers(), 0, nMembers, 0, firstTimeLevel);
        Member[] timeMember = cubeDimensionReader.getLevelMembers(timeDimensionIndex, endLevelIndex, row.getDimPos()[timeDimensionIndex]);
        System.arraycopy(timeMember, 0, nMembers, firstTimeLevel, timeMember.length);
        if ((orignalLevelCount - (lowestTimeLevel + 1)) > 0) {
            System.arraycopy(row.getLevelMembers(), lowestTimeLevel + 1, nMembers, firstTimeLevel + timeMember.length, orignalLevelCount - (lowestTimeLevel + 1));
        }
        newRow.setLevelMembers(nMembers);
        newRow.setDimPos(row.getDimPos());
        newRow.setMeasures(row.getMeasures());
        newRow.setMeasureList(row.getMeasureList());
        newRow.setParameterValues(row.getParameterValues());
    } else {
        newRow = row;
    }
    if (this.existReferenceDate) {
        sortedFactRows.push(newRow);
    } else {
        factRows.add(newRow);
    }
}

Output:
     Row4Aggregation newRow = new Row4Aggregation();
-    if (row.getLevelMembers().length != newMemberSize && orignalLevelCount == newMemberSize) {
+    if (row.getLevelMembers().length != newMemberSize || orignalLevelCount != newMemberSize) {
         Member[] nMembers = new Member[newMemberSize];


Input:
private void enableTableControls() {
    nodesButton.setEnabled(true);
    edgesButton.setEnabled(true);
    configurationButton.setEnabled(true);
    availableColumnsButton.setEnabled(true);
    filterTextField.setEnabled(true);
    columnComboBox.setEnabled(true);
    labelFilter.setEnabled(true);
}

Output:
 private void enableTableControls() {
-    nodesButton.setEnabled(true);
-    edgesButton.setEnabled(true);
-    configurationButton.setEnabled(true);
-    availableColumnsButton.setEnabled(true);
-    filterTextField.setEnabled(true);
-    columnComboBox.setEnabled(true);
-    labelFilter.setEnabled(true);
+    SwingUtilities.invokeLater(new Runnable() {
+        public void run() {
+            nodesButton.setEnabled(true);
+            edgesButton.setEnabled(true);
+            configurationButton.setEnabled(true);
+            availableColumnsButton.setEnabled(true);
+            filterTextField.setEnabled(true);
+            columnComboBox.setEnabled(true);
+            labelFilter.setEnabled(true);
+        }
+    });
 }


Input:
public void remove() {
    operation = (operation == MutableEntryOperation.CREATE) ? MutableEntryOperation.NONE : MutableEntryOperation.REMOVE;
    value = null;
}

Output:
 public void remove() {
-    operation = (operation == MutableEntryOperation.CREATE) ? MutableEntryOperation.NONE : MutableEntryOperation.REMOVE;
+    operation = (operation == MutableEntryOperation.CREATE || operation == MutableEntryOperation.LOAD) ? MutableEntryOperation.NONE : MutableEntryOperation.REMOVE;
     value = null;


Input:
private void jumpToQuestion(int questionIndex) {
    if (questionIndex != INDEX_NOT_SET && !model.isRelevant(questionIndex))
        throw new IllegalStateException();
    if (questionIndex > activeQuestionIndex) {
        if (activeQuestionIndex != INDEX_NOT_SET) {
            ((ChatterboxWidget) get(activeQuestionIndex)).setViewState(ChatterboxWidget.VIEW_COLLAPSED);
        }
        for (int i = activeQuestionIndex + 1; i <= questionIndex; i++) {
            putQuestion(i, i == questionIndex);
        }
    } else if (questionIndex <= activeQuestionIndex) {
        for (int i = activeQuestionIndex; i > questionIndex; i--) {
            removeFrame(i);
        }
        if (questionIndex != INDEX_NOT_SET) {
            ((ChatterboxWidget) get(questionIndex)).setViewState(ChatterboxWidget.VIEW_EXPANDED);
        }
    }
    if (activeQuestionIndex != questionIndex) {
        activeQuestionIndex = questionIndex;
        ChatterboxWidget widget = (ChatterboxWidget) get(activeQuestionIndex);
        focus(widget);
        progressBar.setValue(questionIndex);
    }
    babysitStyles();
}

Output:
         ChatterboxWidget widget = (ChatterboxWidget) get(activeQuestionIndex);
-        focus(widget);
+        this.focus(widget, true);
         progressBar.setValue(questionIndex);


Input:
static Map<String, TableDescription> getExistingTables() {
    Map<String, TableDescription> existingTables = new HashMap<String, TableDescription>();
    ListTablesResult listResult = DYNAMO.listTables();
    for (String tableName : listResult.getTableNames()) {
        DescribeTableResult describeResult = DYNAMO.describeTable(new DescribeTableRequest(tableName));
        TableDescription table = describeResult.getTable();
        existingTables.put(tableName, table);
    }
    return existingTables;
}

Output:
     Map<String, TableDescription> existingTables = new HashMap<String, TableDescription>();
-    ListTablesResult listResult = DYNAMO.listTables();
+    ListTablesResult listResult = DYNAMO.listTables(Integer.MAX_VALUE);
     for (String tableName : listResult.getTableNames()) {


Input:
private static Calendar getCalendar(Date d) {
    Calendar c = Calendar.getInstance();
    if (d == null) {
        c.clear();
        c.set(1970, 0, 1);
    } else {
        c.setTime(d);
    }
    return c;
}

Output:
 private static Calendar getCalendar(Date d) {
-    Calendar c = Calendar.getInstance();
+    Calendar c = Calendar.getInstance(timeZone);
     if (d == null) {


Input:
private TransitionDrawable initPreviewBackgroundDrawable() {
    boolean isWallpaperSelected = mWallpaperFactory.isWallpaperThemeSelected();
    Drawable black = new ColorDrawable(Color.BLACK);
    Drawable wallpaper = mUseLiveWallpaper ? new ColorDrawable(Color.TRANSPARENT) : new BitmapDrawable(getResources(), mWallpaperFactory.getPrefSystemWallpaper());
    mChangeDrawables = !isWallpaperSelected ? new Drawable[] { black, wallpaper } : new Drawable[] { wallpaper, black };
    mBlackDrawableIndex = !isWallpaperSelected ? 0 : 1;
    return new TransitionDrawable(mChangeDrawables);
}

Output:
 private TransitionDrawable initPreviewBackgroundDrawable() {
-    boolean isWallpaperSelected = mWallpaperFactory.isWallpaperThemeSelected();
+    boolean isWallpaperSelected = WallpaperFactory.isWallpaperThemeSelected(getActivity());
     Drawable black = new ColorDrawable(Color.BLACK);


Input:
public void testUnsortedElementInSortedTree() {
    SimpleTree<String> tree = new SimpleTree<String>();
    Element<String> e = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    Element<String> g = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    Element<String> i = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    Element<String> k = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    Element<String> m = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    Element<String> o = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    k.setSorted(false);
    k.set("String_Node_Str");
    Element<String> h = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    Element<String> n = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
    List<String> asList = new SimpleTreeAsList<String>(tree);
    assertEquals(GlazedListsTests.stringToList("String_Node_Str"), asList);
}

Output:
     Element<String> o = tree.addInSortedOrder(Tree1Test.allColors, "String_Node_Str", 1);
-    k.setSorted(false);
+    k.setSorted(Element.UNSORTED);
     k.set("String_Node_Str");


Input:
public void remove(File file) {
    for (int i = 0; i < mFiles.size(); i++) {
        if (mFiles.get(i).getPath().equals(file.getPath())) {
            mFiles.remove(i);
            break;
        }
    }
    notifyDataSetChanged();
}

Output:
     }
-    notifyDataSetChanged();
+    if (notify)
+        notifyDataSetChanged();
 }


Input:
public List<IMember> getMembers() throws BBException {
    if (cachedMembers.isEmpty()) {
        WebRequest request = createMemberListRequest();
        try {
            request.execute();
            String str = request.getResponseBodyAsString();
            request.releaseConnection();
            cachedMembers = parser.parseMembers(str);
            for (IMember member : cachedMembers.values()) {
                ((AbstractBBObject) member).setBulletinBoard(this);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return new ArrayList<IMember>(cachedMembers.values());
}

Output:
     if (cachedMembers.isEmpty()) {
-        WebRequest request = createMemberListRequest();
+        final WebRequest request = createMemberListRequest();
         try {


Input:
public void setEntryAsProcessed(IcapMessageElementEnum entryName) {
    Entry entry = getEntryByName(entryName);
    entry.setIsProcessed();
}

Output:
     Entry entry = getEntryByName(entryName);
-    entry.setIsProcessed();
+    if (entry != null) {
+        entry.setIsProcessed();
+    }
 }


Input:
public void delete() throws Exception {
    if (auxInfo != null) {
        String ruta = PelpConfiguracionBO.getSingletonConfiguration().get(PelpConfiguracionBO.TEMP_PATH);
        File directorioPracticas = new File(ruta);
        File[] ficheros = directorioPracticas.listFiles();
        if (ficheros != null && ficheros.length > 0) {
            fileDim = ficheros.length;
            for (int i = 0; i < ficheros.length; i++) {
                File file = ficheros[i];
                String nameFileHas = auxInfo.replaceAll("String_Node_Str", "String_Node_Str");
                String nameFileFolder = String.valueOf(file.getName().hashCode()).replaceFirst("String_Node_Str", "String_Node_Str");
                if (nameFileHas.equals(nameFileFolder)) {
                    log.info("String_Node_Str" + file.getName() + "String_Node_Str" + nameFileHas);
                    file.delete();
                }
            }
        }
    }
}

Output:
     if (auxInfo != null) {
-        String ruta = PelpConfiguracionBO.getSingletonConfiguration().get(PelpConfiguracionBO.TEMP_PATH);
+        String ruta = this.rutaFile();
         File directorioPracticas = new File(ruta);


Input:
public void startRanging() {
    assertServiceReady();
    if (fullScanStarted)
        throw new RuntimeException("String_Node_Str");
    if (rangingStarted)
        return;
    beaconManager.setRangeNotifier(new RangeNotifier() {
        public void didRangeBeaconsInRegion(Collection<Beacon> iBeacons, Region region) {
            if (iBeacons.size() == 1) {
                Beacon beacon = iBeacons.iterator().next();
                Log.d(TAG, "String_Node_Str" + beacon);
                postOnMainThread(new BeaconScanCompleteEvent(Calendar.getInstance(), beacon));
            }
        }
    });
    try {
        Region selectedRegion = persistentState.getSelectedRegion();
        if (selectedRegion == null)
            return;
        beaconManager.startRangingBeaconsInRegion(persistentState.getSelectedRegion());
        rangingStarted = true;
        Log.i(TAG, "String_Node_Str");
    } catch (RemoteException e) {
        Log.e(TAG, "String_Node_Str", e);
    }
}

Output:
     assertServiceReady();
-    if (fullScanStarted)
-        throw new RuntimeException("String_Node_Str");
-    if (rangingStarted)
+    if (beaconManager.getRangedRegions().contains(region))
         return;


Input:
public void parse(IParserManager pm, IToken token) throws SyntaxError {
    if (this.mode == ACTION) {
        pm.pushParser(pm.newExpressionParser(this), true);
        this.mode = CATCH;
        return;
    }
    int type = token.type();
    if (this.mode == CATCH) {
        if (type == Keywords.CATCH) {
            this.statement.addCatchBlock(this.catchBlock = new CatchBlock(token.raw()));
            this.mode = CATCH_OPEN;
            return;
        }
        if (type == Keywords.FINALLY) {
            pm.popParser();
            pm.pushParser(pm.newExpressionParser(this));
            this.mode = 0;
            return;
        }
        if (ParserUtil.isTerminator(type)) {
            int next = token.next().type();
            if (next != Keywords.CATCH && next != Keywords.FINALLY) {
                pm.popParser(true);
            }
            return;
        }
        pm.popParser(true);
    }
    if (this.mode == CATCH_OPEN) {
        this.mode = CATCH_VAR;
        pm.pushParser(pm.newTypeParser(this.catchBlock));
        if (type == Symbols.OPEN_PARENTHESIS) {
            return;
        }
        throw new SyntaxError(token, "String_Node_Str", true);
    }
    if (this.mode == CATCH_VAR) {
        this.mode = CATCH_CLOSE;
        if (ParserUtil.isIdentifier(type)) {
            this.catchBlock.varName = token.nameValue();
            return;
        }
        throw new SyntaxError(token, "String_Node_Str", true);
    }
    if (this.mode == CATCH_CLOSE) {
        this.mode = CATCH;
        pm.pushParser(pm.newExpressionParser(this.catchBlock));
        if (type == Symbols.CLOSE_PARENTHESIS) {
            return;
        }
        throw new SyntaxError(token, "String_Node_Str");
    }
}

Output:
         if (ParserUtil.isTerminator(type)) {
-            int next = token.next().type();
-            if (next != Keywords.CATCH && next != Keywords.FINALLY) {
+            IToken next = token.getNext();
+            if (next == null) {
+                pm.popParser(true);
+                return;
+            }
+            int nextType = token.next().type();
+            if (nextType != Keywords.CATCH && nextType != Keywords.FINALLY) {
                 pm.popParser(true);


Input:
public INDArray linearViewColumnOrder() {
    ensureNotCleanedUp();
    return Nd4j.create(data, new int[] { length, 1 }, offset());
}

Output:
     ensureNotCleanedUp();
-    return Nd4j.create(data, new int[] { length, 1 }, offset());
+    return create(data, new int[] { length, 1 }, offset());
 }


Input:
public boolean isTerminated() {
    SchedulerManager sm = singleThreadScheduler.sManager.get();
    if (sm == null || sm.isRunning()) {
        return false;
    } else {
        return !sm.execThread.isAlive();
    }
}

Output:
     SchedulerManager sm = singleThreadScheduler.sManager.get();
-    if (sm == null || sm.isRunning()) {
+    if (sm == null || !sm.hasBeenStopped()) {
         return false;


Input:
public void addAccount(ProtocolProviderService protocolProvider) {
    OperationSetPersistentPresence presenceOpSet = (OperationSetPersistentPresence) protocolProvider.getOperationSet(OperationSetPresence.class);
    boolean isHidden = protocolProvider.getAccountID().getAccountProperty(ProtocolProviderFactory.IS_PROTOCOL_HIDDEN) != null;
    if (isHidden)
        return;
    StatusSelectorMenu statusSelectorMenu = null;
    if (presenceOpSet != null) {
        statusSelectorMenu = new PresenceStatusMenu(mainFrame, protocolProvider);
    } else {
        statusSelectorMenu = new SimpleStatusMenu(protocolProvider);
    }
    this.add(statusSelectorMenu);
    this.accountMenus.put(protocolProvider, statusSelectorMenu);
}

Output:
         return;
-    StatusSelectorMenu statusSelectorMenu = null;
-    if (presenceOpSet != null) {
-        statusSelectorMenu = new PresenceStatusMenu(mainFrame, protocolProvider);
-    } else {
-        statusSelectorMenu = new SimpleStatusMenu(protocolProvider);
-    }
+    OperationSetPersistentPresence presenceOpSet = (OperationSetPersistentPresence) protocolProvider.getOperationSet(OperationSetPresence.class);
+    StatusSelectorMenu statusSelectorMenu = (presenceOpSet != null) ? new PresenceStatusMenu(mainFrame, protocolProvider) : new SimpleStatusMenu(protocolProvider);
     this.add(statusSelectorMenu);


Input:
public Path generateRootPath() {
    final org.kie.workbench.java.nio.file.Path _path = fs.getPath("String_Node_Str" + escapePathEntry("String_Node_Str"));
    final Path path = PathFactory.newPath(paths.convert(_path.getFileSystem()), _path.getFileName().toString(), _path.toUri().toString());
    return path;
}

Output:
 public Path generateRootPath() {
-    final org.kie.workbench.java.nio.file.Path _path = fs.getPath("String_Node_Str" + escapePathEntry("String_Node_Str"));
+    final org.kie.commons.java.nio.file.Path _path = fs.getPath("String_Node_Str" + escapePathEntry("String_Node_Str"));
     final Path path = PathFactory.newPath(paths.convert(_path.getFileSystem()), _path.getFileName().toString(), _path.toUri().toString());


Input:
protected Data putInternal(final Data key, final Data value, final long ttl, final TimeUnit timeunit) {
    PutOperation operation = new PutOperation(name, key, value, getTimeInMillis(ttl, timeunit));
    Data previousValue = (Data) invokeOperation(key, operation);
    invalidateLocalNearCache(key);
    return previousValue;
}

Output:
     Data previousValue = (Data) invokeOperation(key, operation);
-    invalidateLocalNearCache(key);
+    invalidateNearCache(key);
     return previousValue;


Input:
private void readKeyDefinition(final Element elem, final Map<String, KeyDef> keyDefs) {
    final String keyName = elem.getAttribute(ATTRIBUTE_NAME_KEYS);
    if (!keyName.isEmpty()) {
        for (final String key : keyName.trim().split("String_Node_Str")) {
            if (!keyDefs.containsKey(key)) {
                final Document d = builder.newDocument();
                final Element copy = (Element) d.importNode(elem, true);
                d.appendChild(copy);
                final String h = copy.getAttribute(ATTRIBUTE_NAME_HREF);
                final URI href = h.isEmpty() ? null : toURI(h);
                final String s = copy.getAttribute(ATTRIBUTE_NAME_SCOPE);
                final String scope = s.isEmpty() ? null : s;
                final KeyDef keyDef = new KeyDef(key, href, scope, null, copy);
                keyDefs.put(key, keyDef);
            }
        }
    }
}

Output:
                 final String scope = s.isEmpty() ? null : s;
-                final KeyDef keyDef = new KeyDef(key, href, scope, null, copy);
+                final KeyDef keyDef = new KeyDef(key, href, scope, currentFile, copy);
                 keyDefs.put(key, keyDef);


Input:
public Set<Long> getAvailableIps(Network network, String requestedIp) {
    String[] cidr = network.getCidr().split("String_Node_Str");
    List<String> ips = _nicDao.listIpAddressInNetwork(network.getId());
    List<String> secondaryIps = _nicSecondaryIpDao.listSecondaryIpAddressInNetwork(network.getId());
    ips.addAll(secondaryIps);
    Set<Long> allPossibleIps = NetUtils.getAllIpsFromCidr(cidr[0], Integer.parseInt(cidr[1]));
    Set<Long> usedIps = new TreeSet<Long>();
    for (String ip : ips) {
        if (requestedIp != null && requestedIp.equals(ip)) {
            s_logger.warn("String_Node_Str" + requestedIp + "String_Node_Str" + network);
            return null;
        }
        usedIps.add(NetUtils.ip2Long(ip));
    }
    if (usedIps.size() != 0) {
        allPossibleIps.removeAll(usedIps);
    }
    String gateway = network.getGateway();
    if ((gateway != null) && (allPossibleIps.contains(NetUtils.ip2Long(gateway))))
        allPossibleIps.remove(NetUtils.ip2Long(gateway));
    return allPossibleIps;
}

Output:
     }
-    if (usedIps.size() != 0) {
-        allPossibleIps.removeAll(usedIps);
-    }
+    Set<Long> allPossibleIps = NetUtils.getAllIpsFromCidr(cidr[0], Integer.parseInt(cidr[1]), usedIps);
     String gateway = network.getGateway();


Input:
public synchronized void quit() {
    try {
        for (Object handler : handlers) {
            SmtpHandler smtpHandler = (SmtpHandler) handler;
            smtpHandler.quit();
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    try {
        if (null != serverSocket && !serverSocket.isClosed()) {
            serverSocket.close();
            serverSocket = null;
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Output:
     try {
-        for (Object handler : handlers) {
-            SmtpHandler smtpHandler = (SmtpHandler) handler;
-            smtpHandler.quit();
+        synchronized (handlers) {
+            for (SmtpHandler handler : handlers) {
+                handler.quit();
+            }
         }


Input:
public void initTextures(ArrayList<Float> uncertaintyVA) {
    if (dimensionVA == null || recordVA == null)
        return;
    int textureWidth = dimensionVA.size();
    int textureHeight = numberOfElements = recordVA.size();
    if (uncertaintyVA != null) {
        textureHeight = numberOfElements = uncertaintyVA.size();
    }
    numberOfTextures = (int) Math.ceil((double) numberOfElements / MAX_SAMPLES_PER_TEXTURE);
    if (numberOfTextures <= 1)
        samplesPerTexture = numberOfElements;
    else
        samplesPerTexture = MAX_SAMPLES_PER_TEXTURE;
    textures.clear();
    numberSamples.clear();
    Texture tempTexture;
    samplesPerTexture = (int) Math.ceil((double) textureHeight / numberOfTextures);
    FloatBuffer[] floatBuffer = new FloatBuffer[numberOfTextures];
    for (int iTexture = 0; iTexture < numberOfTextures; iTexture++) {
        if (iTexture == numberOfTextures - 1) {
            numberSamples.add(textureHeight - samplesPerTexture * iTexture);
            floatBuffer[iTexture] = FloatBuffer.allocate((textureHeight - samplesPerTexture * iTexture) * textureWidth * 4);
        } else {
            numberSamples.add(samplesPerTexture);
            floatBuffer[iTexture] = FloatBuffer.allocate(samplesPerTexture * textureWidth * 4);
        }
    }
    int contentCount = 0;
    int textureCounter = 0;
    for (int index = 0; index < numberOfElements; index++) {
        float uncertainty;
        contentCount++;
        if (uncertaintyVA != null) {
            uncertainty = uncertaintyVA.get(index);
        } else {
            uncertainty = glUncHeatmap.getMaxUncertainty(recordVA.get(index));
        }
        for (int i = 0; i < textureWidth; i++) {
            float[] rgba = new float[4];
            if (((float) i / textureWidth) > uncertainty) {
                if (uncertainty >= 1)
                    rgba = this.lightCertain;
                else
                    rgba = this.lightUncertain;
            } else {
                rgba = GLUncertaintyHeatMap.BACKGROUND;
            }
            floatBuffer[textureCounter].put(rgba);
        }
        if (contentCount >= numberSamples.get(textureCounter)) {
            floatBuffer[textureCounter].rewind();
            TextureData texData = new TextureData(GLProfile.getDefault(), GL2.GL_RGBA, textureWidth, numberSamples.get(textureCounter), 0, GL2.GL_RGBA, GL2.GL_FLOAT, false, false, false, floatBuffer[textureCounter], null);
            tempTexture = TextureIO.newTexture(0);
            tempTexture.updateImage(texData);
            textures.add(tempTexture);
            textureCounter++;
            contentCount = 0;
        }
    }
}

Output:
             uncertainty = uncertaintyVA.get(index);
-        } else {
+        } else if (glUncHeatmap.isMaxUncertaintyCalculated()) {
             uncertainty = glUncHeatmap.getMaxUncertainty(recordVA.get(index));


Input:
public boolean equals(final Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (getClass() != obj.getClass()) {
        return false;
    }
    final Configuration other = (Configuration) obj;
    if (APIKey == null) {
        if (other.APIKey != null) {
            return false;
        }
    } else if (!APIKey.equals(other.APIKey)) {
        return false;
    }
    if (http404Strategy == null) {
        if (other.http404Strategy != null) {
            return false;
        }
    } else if (!http404Strategy.equals(other.http404Strategy)) {
        return false;
    }
    if (http429Strategy == null) {
        if (other.http429Strategy != null) {
            return false;
        }
    } else if (!http429Strategy.equals(other.http429Strategy)) {
        return false;
    }
    if (http500Strategy == null) {
        if (other.http500Strategy != null) {
            return false;
        }
    } else if (!http500Strategy.equals(other.http500Strategy)) {
        return false;
    }
    if (http503Strategy == null) {
        if (other.http503Strategy != null) {
            return false;
        }
    } else if (!http503Strategy.equals(other.http503Strategy)) {
        return false;
    }
    if (httpTimeoutStrategy == null) {
        if (other.httpTimeoutStrategy != null) {
            return false;
        }
    } else if (!httpTimeoutStrategy.equals(other.httpTimeoutStrategy)) {
        return false;
    }
    if (Double.doubleToLongBits(limitingShare) != Double.doubleToLongBits(other.limitingShare)) {
        return false;
    }
    if (limitingType != other.limitingType) {
        return false;
    }
    if (rateLimiterTimeoutStrategy == null) {
        if (other.rateLimiterTimeoutStrategy != null) {
            return false;
        }
    } else if (!rateLimiterTimeoutStrategy.equals(other.rateLimiterTimeoutStrategy)) {
        return false;
    }
    if (requests == null) {
        if (other.requests != null) {
            return false;
        }
    } else if (!requests.equals(other.requests)) {
        return false;
    }
    if (services == null) {
        if (other.services != null) {
            return false;
        }
    } else if (!services.equals(other.services)) {
        return false;
    }
    return true;
}

Output:
     final Configuration other = (Configuration) obj;
-    if (APIKey == null) {
-        if (other.APIKey != null) {
+    if (apiKey == null) {
+        if (other.apiKey != null) {
             return false;


Input:
public Object visitConversionExpressionTerm(cqlParser.ConversionExpressionTermContext ctx) {
    TypeSpecifier targetType = parseTypeSpecifier(ctx.typeSpecifier());
    Expression operand = parseExpression(ctx.expression());
    Conversion conversion = libraryBuilder.findConversion(operand.getResultType(), targetType.getResultType(), false);
    if (conversion == null) {
        throw new IllegalArgumentException(String.format("String_Node_Str", operand.getResultType(), targetType.getResultType()));
    }
    return libraryBuilder.convertExpression(operand, conversion);
}

Output:
     Expression operand = parseExpression(ctx.expression());
-    Conversion conversion = libraryBuilder.findConversion(operand.getResultType(), targetType.getResultType(), false);
-    if (conversion == null) {
-        throw new IllegalArgumentException(String.format("String_Node_Str", operand.getResultType(), targetType.getResultType()));
+    if (!DataTypes.equal(operand.getResultType(), targetType.getResultType())) {
+        Conversion conversion = libraryBuilder.findConversion(operand.getResultType(), targetType.getResultType(), false);
+        if (conversion == null) {
+            throw new IllegalArgumentException(String.format("String_Node_Str", operand.getResultType(), targetType.getResultType()));
+        }
+        return libraryBuilder.convertExpression(operand, conversion);
     }


Input:
protected void drawVerticalGrid() {
    if (!mDrawVerticalGrid || mCurrentData == null)
        return;
    float[] position = new float[] { 0f, 0f };
    BarData bd = (BarData) mCurrentData;
    int step = mCurrentData.getDataSetCount();
    for (int i = 0; i < mCurrentData.getXValCount(); i += mXLabels.mXAxisLabelModulus) {
        position[0] = i * step + i * bd.getGroupSpace();
        transformPointArray(position);
        if (position[0] >= mOffsetLeft && position[0] <= getWidth()) {
            mDrawCanvas.drawLine(position[0], mOffsetTop, position[0], getHeight() - mOffsetBottom, mGridPaint);
        }
    }
}

Output:
     for (int i = 0; i < mCurrentData.getXValCount(); i += mXLabels.mXAxisLabelModulus) {
-        position[0] = i * step + i * bd.getGroupSpace();
+        position[0] = i * step + i * mOriginalData.getGroupSpace();
         transformPointArray(position);


Input:
public void add(String fieldExpression, String orderExpression, CassandraClassMetaData metaData) {
    String[] decs = Strings.split(orderExpression, "String_Node_Str", 0);
    IndexOrder[] orders = new IndexOrder[decs.length];
    int spc;
    boolean asc;
    for (int i = 0; i < decs.length; i++) {
        decs[i] = decs[i].trim();
        spc = decs[i].indexOf(' ');
        if (spc == -1)
            asc = true;
        else {
            asc = decs[i].substring(spc + 1).trim().toLowerCase().startsWith("String_Node_Str");
            decs[i] = decs[i].substring(0, spc);
        }
        orders[i] = new IndexOrder(decs[i], asc);
        FieldMetaData fmd = metaData.getDeclaredField(decs[i]);
        if (fmd != null)
            fmd.setUsedInOrderBy(true);
    }
    decs = Strings.split(fieldExpression, "String_Node_Str", 0);
    FieldOrder[] fields = new FieldOrder[decs.length];
    for (int i = 0; i < fields.length; i++) {
        decs[i] = decs[i].trim();
        spc = decs[i].indexOf(' ');
        if (spc == -1)
            asc = true;
        else {
            asc = decs[i].substring(spc + 1).trim().toLowerCase().startsWith("String_Node_Str");
            decs[i] = decs[i].substring(0, spc);
        }
        fields[i] = new FieldOrder(decs[i], asc);
    }
    IndexDefinition indexDef = new IndexDefinition(metaData, fields, orders);
    indexDefs.add(indexDef);
}

Output:
     }
-    IndexDefinition indexDef = new IndexDefinition(metaData, fields, orders);
+    IndexDefinition indexDef = new IndexDefinition(fields, orders);
     indexDefs.add(indexDef);


Input:
public boolean isRecording() {
    return status == GOPRO_HEARTBEAT_STATUS.GOPRO_HEARTBEAT_STATUS_RECORDING;
}

Output:
 public boolean isRecording() {
-    return status == GOPRO_HEARTBEAT_STATUS.GOPRO_HEARTBEAT_STATUS_RECORDING;
+    return isRecording;
 }


Input:
public Sound transform(Sound input) {
    double compression = input.getSamples().length / this.length;
    this.sb = new StringBuffer();
    float lastSample = input.getSamples().length;
    long maxMagn = 128;
    int step = (int) lastSample / this.length;
    int[] valuesOnPlot = new int[this.length];
    int maxPlotValue = 0;
    double minValuePlotted = -1;
    for (int i = 0; i < valuesOnPlot.length; i++) {
        double maxValue = 0;
        for (int j = 0; j < step; j++) {
            int x = i * step + j;
            if (x < input.getSamples().length && maxValue < input.getSamples()[x]) {
                maxValue = 20.0 * Math.log10(input.getSamples()[x]);
            }
        }
        if (minValuePlotted == -1 || minValuePlotted > maxValue) {
            minValuePlotted = maxValue;
        }
        valuesOnPlot[i] = (int) (maxValue * height / (maxMagn));
        if (maxPlotValue < valuesOnPlot[i] && i > 0) {
            maxPlotValue = valuesOnPlot[i];
        }
    }
    for (int i = 0; i < valuesOnPlot.length; i++) {
        valuesOnPlot[i] -= minValuePlotted * height / maxMagn;
    }
    for (int j = height; j >= 0; j--) {
        if (j == height) {
            sb.append("String_Node_Str" + maxMagn + "String_Node_Str");
            continue;
        } else {
            sb.append("String_Node_Str");
        }
        for (int i = 0; i < this.length; i++) {
            if (valuesOnPlot[i] == j) {
                sb.append("String_Node_Str");
            } else if (valuesOnPlot[i] > j) {
                sb.append("String_Node_Str");
            } else {
                sb.append("String_Node_Str");
            }
        }
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    for (int i = 0; i < this.length; i++) {
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str" + (int) (this.length * compression / input.getFreq()) + "String_Node_Str");
    return input;
}

Output:
     float lastSample = input.getSamples().length;
-    long maxMagn = 128;
+    long maxMagn = (long) Math.pow(256, input.getNbBytesPerSample()) / 2;
     int step = (int) lastSample / this.length;


Input:
public Object getItem(int position) {
    if (mCursor.moveToPosition(position)) {
        return mAppLib.get(position).mAppCode;
    }
    return null;
}

Output:
     if (mCursor.moveToPosition(position)) {
-        return mAppLib.get(position).mAppCode;
+        return mCursor.getString(mCodeId);
     }


Input:
public org.hl7.fhir.dstu2.model.ImplementationGuide convertImplementationGuide(org.hl7.fhir.dstu3.model.ImplementationGuide src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.ImplementationGuide tgt = new org.hl7.fhir.dstu2.model.ImplementationGuide();
    copyDomainResource(src, tgt);
    tgt.setUrl(src.getUrl());
    tgt.setVersion(src.getVersion());
    tgt.setName(src.getName());
    tgt.setStatus(convertConformanceResourceStatus(src.getStatus()));
    tgt.setExperimental(src.getExperimental());
    tgt.setPublisher(src.getPublisher());
    for (org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuideContactComponent t : src.getContact()) tgt.addContact(convertImplementationGuideContactComponent(t));
    tgt.setDate(src.getDate());
    tgt.setDescription(src.getDescription());
    for (org.hl7.fhir.dstu3.model.CodeableConcept t : src.getUseContext()) tgt.addUseContext(convertCodeableConcept(t));
    tgt.setCopyright(src.getCopyright());
    tgt.setFhirVersion(src.getFhirVersion());
    for (org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuideDependencyComponent t : src.getDependency()) tgt.addDependency(convertImplementationGuideDependencyComponent(t));
    for (org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuidePackageComponent t : src.getPackage()) tgt.addPackage(convertImplementationGuidePackageComponent(t));
    for (org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuideGlobalComponent t : src.getGlobal()) tgt.addGlobal(convertImplementationGuideGlobalComponent(t));
    for (org.hl7.fhir.dstu3.model.UriType t : src.getBinary()) tgt.addBinary(t.getValue());
    tgt.setPage(convertImplementationGuidePageComponent(src.getPage()));
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.ImplementationGuide convertImplementationGuide(org.hl7.fhir.dstu3.model.ImplementationGuide src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public List<VjoSemanticProblem> getVjoSemanticProblemOnDemand(String testFolderName, String pacakgeName, String checkedFileName, Class<? extends VjoValidationBaseTester> currentClass) {
    m_jstType = null;
    m_unit = null;
    m_unitList.clear();
    if (testFolderName == null) {
        testFolderName = VjoValidationBaseTester.TEST_FOLDER;
    }
    URL testFile = null;
    if (pacakgeName == null) {
        try {
            testFile = ResourceUtil.getResource(currentClass, checkedFileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    } else {
        pacakgeName = pacakgeName.replace('.', '/');
        testFile = this.getClass().getClassLoader().getResource(pacakgeName + checkedFileName);
    }
    if (testFile == null) {
        System.out.println("String_Node_Str" + pacakgeName);
        System.out.println("String_Node_Str" + currentClass.getName());
        System.out.println("String_Node_Str" + checkedFileName);
        System.out.println("String_Node_Str" + System.getProperty("String_Node_Str"));
        System.out.println("String_Node_Str" + System.getProperty("String_Node_Str"));
        throw new RuntimeException("String_Node_Str");
    }
    String typeName = getTypeName(testFile.getFile());
    IScriptUnit unit = m_c.parse(ONDEMAND, typeName, VjoParser.getContent(testFile));
    final JstTypeSpaceMgr mgr = new JstTypeSpaceMgr(m_c, new OnDemandValidationTestLoader(ONDEMAND, unit.getType(), testFile));
    mgr.getConfig().setSynchronousEvents(true);
    mgr.initialize();
    TsLibLoader.loadDefaultLibs(mgr);
    List<String> libs = new ArrayList<String>();
    libs.addAll(Arrays.asList(TsLibLoader.getDefaultLibNames()));
    mgr.registerTypeSpaceEventListener(new ITypeSpaceEventListener() {
        private volatile boolean done = false;
        public void onUpdated(TypeSpaceEvent event, EventListenerStatus status) {
            if (!done && EventId.Updated == event.getId()) {
                final Object trigger = event.getTrigger();
                if (trigger instanceof AddGroupEvent) {
                    final AddGroupEvent addGroupEvt = (AddGroupEvent) trigger;
                    final String groupName = addGroupEvt.getGroupName();
                    final Group<IJstType> group = (Group<IJstType>) mgr.getTypeSpace().getGroup(groupName);
                    if (group != null && ONDEMAND.equals(group.getName())) {
                        final String[] libraries = { JstTypeSpaceMgr.JAVA_PRIMITIVE_GRP, JstTypeSpaceMgr.JS_BROWSER_GRP, JstTypeSpaceMgr.JS_NATIVE_GRP, JstTypeSpaceMgr.VJO_BASE_LIB_NAME, JstTypeSpaceMgr.VJO_SELF_DESCRIBED };
                        for (String lib : libraries) {
                            final IGroup<IJstType> libGroup = mgr.getTypeSpace().getGroup(lib);
                            if (lib != null) {
                                group.addGroupDependency(libGroup);
                            }
                        }
                        done = true;
                    }
                }
            }
        }
        public void onUnloaded(TypeSpaceEvent event, EventListenerStatus status) {
        }
        public void onLoaded(TypeSpaceEvent event, EventListenerStatus status) {
        }
    });
    mgr.processEvent(new AddGroupEvent(ONDEMAND, null, Collections.EMPTY_LIST, Collections.EMPTY_LIST, libs));
    unit = m_c.parseAndResolve(ONDEMAND, typeName, VjoParser.getContent(testFile));
    TestCase.assertNotNull(mgr.getTypeSpace().getGroup(ONDEMAND));
    TestCase.assertNotNull(mgr.getQueryExecutor().findAllTypesInPackage(unit.getType().getPackage().getName()));
    VjoValidationResult result = doValidate(unit, mgr);
    return result.getAllProblems();
}

Output:
     String typeName = getTypeName(testFile.getFile());
-    IScriptUnit unit = m_c.parse(ONDEMAND, typeName, VjoParser.getContent(testFile));
-    final JstTypeSpaceMgr mgr = new JstTypeSpaceMgr(m_c, new OnDemandValidationTestLoader(ONDEMAND, unit.getType(), testFile));
+    IScriptUnit unit = m_c.parse(grpName, typeName, VjoParser.getContent(testFile));
+    final JstTypeSpaceMgr mgr = new JstTypeSpaceMgr(m_c, new OnDemandValidationTestLoader(grpName, unit.getType(), testFile));
     mgr.getConfig().setSynchronousEvents(true);


Input:
public DependencyTree buildDependency(ParentComponent component) throws DependencyBuilderException {
    String identifier = component.getUniqueIdentifier();
    DependencyTree dependencyTree = new DependencyTree(identifier);
    DependencyOrder dependencyOrder = component.getDependencyOrder();
    if (dependencyOrder != null) {
        log.info(String.format("String_Node_Str", identifier));
        String terminationBehaviour = dependencyOrder.getTerminationBehaviour();
        if (AutoscalerConstants.TERMINATE_NONE.equals(terminationBehaviour)) {
            dependencyTree.setTerminationBehavior(DependencyTree.TerminationBehavior.TERMINATE_NONE);
        } else if (AutoscalerConstants.TERMINATE_ALL.equals(terminationBehaviour)) {
            dependencyTree.setTerminationBehavior(DependencyTree.TerminationBehavior.TERMINATE_ALL);
        } else if (AutoscalerConstants.TERMINATE_DEPENDENTS.equals(terminationBehaviour)) {
            dependencyTree.setTerminationBehavior(DependencyTree.TerminationBehavior.TERMINATE_DEPENDENT);
        }
        log.info(String.format("String_Node_Str", identifier, dependencyTree.getTerminationBehavior()));
        Set<StartupOrder> startupOrders = dependencyOrder.getStartupOrders();
        ApplicationChildContext parentContext;
        if (startupOrders != null) {
            log.debug(String.format("String_Node_Str", identifier, startupOrders));
            for (StartupOrder startupOrder : startupOrders) {
                parentContext = null;
                log.debug(String.format("String_Node_Str" + "String_Node_Str", identifier, startupOrder));
                for (String startupOrderComponent : startupOrder.getStartupOrderComponentList()) {
                    if (startupOrderComponent != null) {
                        log.debug(String.format("String_Node_Str" + "String_Node_Str", identifier, startupOrder, startupOrderComponent));
                        ApplicationChildContext applicationChildContext = ApplicationChildContextFactory.createApplicationChildContext(identifier, startupOrderComponent, component, dependencyTree);
                        String parentContextId = null;
                        ApplicationChildContext tmpParentContext = null;
                        if (parentContext != null) {
                            parentContextId = parentContext.getId();
                            tmpParentContext = dependencyTree.getApplicationChildContextByIdInPrimaryTree(parentContextId);
                        }
                        applicationChildContext.setParent(tmpParentContext);
                        String applicationChildContextId = applicationChildContext.getId();
                        ApplicationChildContext existingApplicationChildContext = dependencyTree.getApplicationChildContextByIdInPrimaryTree(applicationChildContextId);
                        if (existingApplicationChildContext == null) {
                            if (parentContext != null) {
                                parentContext.addApplicationChildContext(applicationChildContext);
                                if (log.isDebugEnabled()) {
                                    log.debug(String.format("String_Node_Str" + "String_Node_Str", applicationChildContext.getId(), parentContext.getId(), dependencyTree));
                                }
                                parentContext = applicationChildContext;
                            } else {
                                dependencyTree.addPrimaryApplicationContext(applicationChildContext);
                                if (log.isDebugEnabled()) {
                                    log.debug(String.format("String_Node_Str", applicationChildContext.getId(), dependencyTree));
                                }
                                parentContext = applicationChildContext;
                            }
                        } else {
                            if (parentContext == null) {
                                parentContext = existingApplicationChildContext;
                                if (log.isDebugEnabled()) {
                                    log.debug(String.format("String_Node_Str" + "String_Node_Str", existingApplicationChildContext.getId(), dependencyTree));
                                }
                            } else {
                                ApplicationChildContext existingParentContext = dependencyTree.findParentContextWithId(applicationChildContext.getId());
                                if ((existingParentContext != null) && (existingParentContext.getId().equals(existingApplicationChildContext.getId()))) {
                                    if (log.isDebugEnabled()) {
                                        log.debug(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str", existingParentContext.getId(), dependencyTree));
                                    }
                                    parentContext = existingParentContext;
                                } else {
                                    String msg = "String_Node_Str" + "String_Node_Str" + startupOrder;
                                    throw new DependencyBuilderException(msg);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    Collection<Group> groups = component.getAliasToGroupMap().values();
    for (Group group : groups) {
        if (dependencyTree.getApplicationChildContextByIdInPrimaryTree(group.getAlias()) == null) {
            ApplicationChildContext context = ApplicationChildContextFactory.createGroupChildContext(group.getAlias(), dependencyTree.isTerminateDependent());
            dependencyTree.addPrimaryApplicationContext(context);
        }
    }
    Collection<ClusterDataHolder> clusterData = component.getClusterDataMap().values();
    for (ClusterDataHolder dataHolder : clusterData) {
        if (dependencyTree.getApplicationChildContextByIdInPrimaryTree(dataHolder.getClusterId()) == null) {
            ApplicationChildContext context = ApplicationChildContextFactory.createClusterChildContext(dataHolder, dependencyTree.isTerminateDependent());
            dependencyTree.addPrimaryApplicationContext(context);
        }
    }
    if (log.isDebugEnabled()) {
        log.debug(String.format("String_Node_Str", component.getUniqueIdentifier(), dependencyTree.toString()));
    }
    return dependencyTree;
}

Output:
                                 ApplicationChildContext existingParentContext = dependencyTree.findParentContextWithId(applicationChildContext.getId());
-                                if ((existingParentContext != null) && (existingParentContext.getId().equals(existingApplicationChildContext.getId()))) {
+                                if ((existingParentContext != null) && (existingApplicationChildContext.getParent()) != null && (existingParentContext.getId().equals(existingApplicationChildContext.getParent().getId()))) {
                                     if (log.isDebugEnabled()) {


Input:
private void addNode(List<Piece> list, XhtmlNode c) {
    if (c.getNodeType() == NodeType.Text)
        list.add(new Piece(null, c.getContent(), null));
    else if (c.getNodeType() == NodeType.Element) {
        if (c.getName().equals("String_Node_Str")) {
            list.add(new Piece(c.getAttribute("String_Node_Str"), c.allText(), c.getAttribute("String_Node_Str")));
        } else if (c.getName().equals("String_Node_Str") || c.getName().equals("String_Node_Str") || c.getName().equals("String_Node_Str")) {
            list.add(new Piece(null, c.allText(), null).setStyle("String_Node_Str"));
        } else if (c.getName().equals("String_Node_Str")) {
            list.add(new Piece(null, c.allText(), null).setStyle("String_Node_Str"));
        } else if (c.getName().equals("String_Node_Str")) {
            list.add(new Piece(null, c.allText(), null).setStyle("String_Node_Str"));
        } else if (c.getName().equals("String_Node_Str")) {
            Piece p = new Piece(c.getName()).setStyle("String_Node_Str");
            list.add(p);
            p.getChildren().addAll(c.getChildNodes());
        } else if (c.getName().equals("String_Node_Str") || c.getName().equals("String_Node_Str")) {
            Piece p = new Piece(c.getName());
            list.add(p);
            p.getChildren().addAll(c.getChildNodes());
        } else if (c.getName().equals("String_Node_Str")) {
            list.add(new Piece(null, c.allText(), null).setStyle("String_Node_Str"));
        } else
            throw new Error("String_Node_Str" + c.getName());
    } else
        throw new Error("String_Node_Str" + c.getNodeType().toString());
}

Output:
             list.add(new Piece(null, c.allText(), null).setStyle("String_Node_Str"));
-        } else
+        } else if (c.getName().equals("String_Node_Str") || c.getName().equals("String_Node_Str") || c.getName().equals("String_Node_Str") || c.getName().equals("String_Node_Str")) {
+            Piece p = new Piece(c.getName());
+            list.add(p);
+            p.getChildren().addAll(c.getChildNodes());
+        } else {
             throw new Error("String_Node_Str" + c.getName());


Input:
public void clearTestedObjects() {
    injectionState.lifecycleMethods.executeTerminationMethodsIfAny();
    injectionState.clearTestedObjectsAndInstantiatedDependencies();
    Object testClassInstance = injectionState.getCurrentTestClassInstance();
    for (TestedObject testedField : testedFields) {
        testedField.clearIfAutomaticCreation(testClassInstance);
    }
}

Output:
     injectionState.clearTestedObjectsAndInstantiatedDependencies();
-    Object testClassInstance = injectionState.getCurrentTestClassInstance();
-    for (TestedObject testedField : testedFields) {
-        testedField.clearIfAutomaticCreation(testClassInstance);
-    }
+    resetTestedFields(false);
 }


Input:
public void shouldLogMessageIncludingSession() throws Exception {
    IoSessionEx session = context.mock(IoSessionEx.class, "String_Node_Str");
    IoServiceEx service = context.mock(IoServiceEx.class, "String_Node_Str");
    TransportMetadata metadata = context.mock(TransportMetadata.class, "String_Node_Str");
    ResourceAddressFactory addressFactory = ResourceAddressFactory.newResourceAddressFactory();
    String addressURI = "String_Node_Str";
    SocketAddress address = addressFactory.newResourceAddress(addressURI);
    Subject subject = new Subject();
    context.checking(new Expectations() {
        {
            allowing(session).getService();
            will(returnValue(service));
            oneOf(session).getId();
            will(returnValue(TEST_SESSION_NUMBER));
            oneOf(service).getTransportMetadata();
            will(returnValue(metadata));
            oneOf(session).getTransportMetadata();
            will(returnValue(metadata));
            allowing(metadata).getName();
            will(returnValue("String_Node_Str"));
            oneOf(session).getAttribute(with(any(Object.class)));
            will(returnValue(null));
            oneOf(session).getLocalAddress();
            will(returnValue(address));
            oneOf(session).getRemoteAddress();
            will(returnValue(address));
            oneOf(session).getSubject();
            will(returnValue(subject));
            oneOf(session).setAttribute(with(any(Object.class)), with(any(String.class)));
        }
    });
    new TransportExceptionMonitor().exceptionCaught(new NullPointerException(EXCEPTION_MESSAGE), session);
    expectedPatterns = Arrays.asList("String_Node_Str");
}

Output:
     new TransportExceptionMonitor().exceptionCaught(new NullPointerException(EXCEPTION_MESSAGE), session);
-    expectedPatterns = Arrays.asList("String_Node_Str");
+    checkLogMessageRule.setExpectedPatterns(Arrays.asList("String_Node_Str"));
 }


Input:
public Identifier getMetadataIdentifier() {
    return metadataIdentifier;
}

Output:
 public Identifier getMetadataIdentifier() {
-    return metadataIdentifier;
+    return NonMarshalledAuthority.getMarshallable(identifiers);
 }


Input:
public void setUp() {
    root = Root.create(new ChangeReporterImpl());
    state = StateImpl.create(root, STATE_ID, null);
    model = ModelImpl.create(root, MODEL_ID, null);
    state_model = StateImpl.create(model, STATE_ID, null);
}

Output:
 public void setUp() {
-    root = Root.create(new ChangeReporterImpl());
+    root = Root.create();
     state = StateImpl.create(root, STATE_ID, null);


Input:
public void resetMonitors() {
    for (ResultListener listener : monitors) {
        if (listener instanceof Resetable)
            ((Resetable) listener).reset();
    }
}

Output:
 public void resetMonitors() {
-    for (ResultListener listener : monitors) {
+    for (Monitor listener : monitors) {
         if (listener instanceof Resetable)


Input:
public Iterable<DBObject> getComplianceOnDate(Date targetDate, List<String> consumerIds, List<String> owners, List<String> statusFilers) {
    BasicDBObjectBuilder queryBuilder = BasicDBObjectBuilder.start();
    queryBuilder.add("String_Node_Str", new BasicDBObject("String_Node_Str", consumerCurator.getUuidsOnDate(targetDate, owners, consumerIds)));
    if (owners != null && !owners.isEmpty()) {
        queryBuilder.add("String_Node_Str", new BasicDBObject("String_Node_Str", owners));
    }
    queryBuilder.add("String_Node_Str", new BasicDBObject("String_Node_Str", targetDate));
    BasicDBObjectBuilder filterBuilder = BasicDBObjectBuilder.start();
    if (statusFilers != null && !statusFilers.isEmpty()) {
        filterBuilder.add("String_Node_Str", new BasicDBObject("String_Node_Str", statusFilers));
    }
    BasicDBObject projections = new BasicDBObject();
    projections.put("String_Node_Str", 1);
    projections.put("String_Node_Str", 1);
    projections.put("String_Node_Str", 0);
    BasicDBObject project = new BasicDBObject("String_Node_Str", projections);
    BasicDBObject groups = new BasicDBObject("String_Node_Str", "String_Node_Str");
    groups.put("String_Node_Str", new BasicDBObject("String_Node_Str", "String_Node_Str"));
    groups.put("String_Node_Str", new BasicDBObject("String_Node_Str", "String_Node_Str"));
    DBObject query = new BasicDBObject("String_Node_Str", queryBuilder.get());
    DBObject postResultFilter = new BasicDBObject("String_Node_Str", filterBuilder.get());
    DBObject group = new BasicDBObject("String_Node_Str", groups);
    DBObject sort = new BasicDBObject("String_Node_Str", new BasicDBObject("String_Node_Str", -1));
    AggregationOutput output = collection.aggregate(Arrays.asList(query, project, sort, group, postResultFilter));
    return output.results();
}

Output:
     queryBuilder.add("String_Node_Str", new BasicDBObject("String_Node_Str", targetDate));
-    BasicDBObjectBuilder filterBuilder = BasicDBObjectBuilder.start();
+    StringBuffer m = new StringBuffer();
+    m.append("String_Node_Str");
+    m.append("String_Node_Str");
+    m.append("String_Node_Str");
+    StringBuffer r = new StringBuffer();
+    r.append("String_Node_Str");
+    r.append("String_Node_Str");
+    r.append("String_Node_Str");
+    r.append("String_Node_Str");
+    MapReduceCommand command = new MapReduceCommand(collection, m.toString(), r.toString(), null, MapReduceCommand.OutputType.INLINE, queryBuilder.get());
+    List<ObjectId> ids = new LinkedList<ObjectId>();
+    MapReduceOutput output = collection.mapReduce(command);
+    for (DBObject row : output.results()) {
+        DBObject value = (DBObject) row.get("String_Node_Str");
+        ids.add((ObjectId) value.get("String_Node_Str"));
+    }
+    BasicDBObjectBuilder filterQueryBuilder = BasicDBObjectBuilder.start();
+    filterQueryBuilder.add("String_Node_Str", new BasicDBObject("String_Node_Str", ids));
     if (statusFilers != null && !statusFilers.isEmpty()) {


Input:
public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
    LttngProcessState process = traceSt.getRunning_process().get(trcEvent.getCpuId());
    if (process != null) {
        TimeRangeEventProcess localProcess = procContainer.findProcess(process.getPid(), process.getCpu(), traceSt.getTraceId(), process.getCreation_time());
        if (localProcess == null) {
            if ((process.getPid() == 0) || (process.getPid() != process.getPpid())) {
                TmfTimeRange timeRange = traceSt.getContext().getTraceTimeWindow();
                localProcess = addLocalProcess(process, timeRange.getStartTime().getValue(), timeRange.getEndTime().getValue(), traceSt.getTraceId());
            } else {
                TraceDebug.debug("String_Node_Str");
            }
        } else {
            localProcess.setBrand(process.getBrand());
        }
    } else {
        TraceDebug.debug("String_Node_Str");
    }
    return false;
}

Output:
         if (localProcess == null) {
-            if ((process.getPid() == 0) || (process.getPid() != process.getPpid())) {
+            if (process.getPid().equals(0) || !process.getPid().equals(process.getPpid())) {
                 TmfTimeRange timeRange = traceSt.getContext().getTraceTimeWindow();


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.ZONE_CHANGE && event.getSourceId() != null && event.getSourceId().equals(getSourceId())) {
        ZoneChangeEvent zEvent = (ZoneChangeEvent) event;
        if (zEvent.getFromZone() == Zone.BATTLEFIELD && zEvent.getToZone() == Zone.EXILED) {
            MageObject object = game.getObject(event.getTargetId());
            if (object != null && object.getSubtype().contains("String_Node_Str")) {
                return true;
            }
        }
    }
    return false;
}

Output:
         if (zEvent.getFromZone() == Zone.BATTLEFIELD && zEvent.getToZone() == Zone.EXILED) {
-            MageObject object = game.getObject(event.getTargetId());
-            if (object != null && object.getSubtype().contains("String_Node_Str")) {
+            if (zEvent.getTarget() != null && zEvent.getTarget().getSubtype().contains("String_Node_Str")) {
                 return true;


Input:
public static NiftyDialogBuilder getInstance(Context context) {
    int ort = context.getResources().getConfiguration().orientation;
    if (mOrientation != ort) {
        mOrientation = ort;
        instance = null;
    }
    if (instance == null && !((Activity) context).isFinishing()) {
        synchronized (NiftyDialogBuilder.class) {
            if (instance == null) {
                instance = new NiftyDialogBuilder(context, R.style.dialog_untran);
            }
        }
    }
    return instance;
}

Output:
     }
-    if (instance == null && !((Activity) context).isFinishing()) {
+    if (instance == null || ((Activity) context).isFinishing()) {
         synchronized (NiftyDialogBuilder.class) {


Input:
private boolean doCollectItemFiles(File directory, boolean interruptable) {
    File[] contents = directory.listFiles();
    Thread currentThread = Thread.currentThread();
    if (contents != null) {
        for (File content : contents) {
            if (interruptable && currentThread.isInterrupted()) {
                return false;
            }
            File file = content;
            if (file.isFile()) {
                add(file.getAbsolutePath(), file);
            }
            if (file.isDirectory()) {
                if ((!FilesUtils.isSVNFolder(file))) {
                    collectPath2Object(content);
                }
            }
        }
    }
    return true;
}

Output:
                 if ((!FilesUtils.isSVNFolder(file))) {
-                    collectPath2Object(content);
+                    collectPath2Object(content, interruptable);
                 }


Input:
public int hashCode() {
    if (hashCode == null) {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((buildDate == null) ? 0 : buildDate.hashCode());
        result = prime * result + ((extraInfo == null) ? 0 : extraInfo.hashCode());
        result = prime * result + ((gaeCompliant == null) ? 0 : gaeCompliant.hashCode());
        result = prime * result + ((hashCode == null) ? 0 : hashCode.hashCode());
        result = prime * result + intValue;
        result = prime * result + ((stringValue == null) ? 0 : stringValue.hashCode());
        hashCode = new Integer(result);
    }
    return hashCode.intValue();
}

Output:
 public int hashCode() {
-    if (hashCode == null) {
-        final int prime = 31;
-        int result = 1;
-        result = prime * result + ((buildDate == null) ? 0 : buildDate.hashCode());
-        result = prime * result + ((extraInfo == null) ? 0 : extraInfo.hashCode());
-        result = prime * result + ((gaeCompliant == null) ? 0 : gaeCompliant.hashCode());
-        result = prime * result + ((hashCode == null) ? 0 : hashCode.hashCode());
-        result = prime * result + intValue;
-        result = prime * result + ((stringValue == null) ? 0 : stringValue.hashCode());
-        hashCode = new Integer(result);
+    synchronized (this) {
+        if (hashCode == null) {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result + (buildDate == null ? 0 : buildDate.hashCode());
+            result = prime * result + (extraInfo == null ? 0 : extraInfo.hashCode());
+            result = prime * result + (gaeCompliant == null ? 0 : gaeCompliant.hashCode());
+            result = prime * result + (hashCode == null ? 0 : hashCode.hashCode());
+            result = prime * result + intValue;
+            String stringValue = getStringValue();
+            result = prime * result + (stringValue == null ? 0 : stringValue.hashCode());
+            hashCode = new Integer(result);
+        }
+        return hashCode.intValue();
     }


Input:
ObjectType specialize(ObjectType other) {
    Preconditions.checkState(areRelatedClasses(this.nominalType, other.nominalType));
    NominalType resultNominalType = NominalType.pickSubclass(this.nominalType, other.nominalType);
    return ObjectType.makeObjectType(resultNominalType, meetPropsHelper(true, resultNominalType, this.props, other.props), (fn == null) ? null : fn.specialize(other.fn), this.isLoose || other.isLoose, ObjectKind.meet(this.objectKind, other.objectKind));
}

Output:
     NominalType resultNominalType = NominalType.pickSubclass(this.nominalType, other.nominalType);
-    return ObjectType.makeObjectType(resultNominalType, meetPropsHelper(true, resultNominalType, this.props, other.props), (fn == null) ? null : fn.specialize(other.fn), this.isLoose || other.isLoose, ObjectKind.meet(this.objectKind, other.objectKind));
+    return ObjectType.makeObjectType(resultNominalType, meetPropsHelper(true, resultNominalType, this.props, other.props), (fn == null) ? null : fn.specialize(other.fn), resultNominalType == null && this.isLoose, ObjectKind.meet(this.objectKind, other.objectKind));
 }


Input:
protected boolean checkPool(ExcludeList avoid, StoragePoolVO pool, DiskProfile dskCh, VMTemplateVO template, List<VMTemplateStoragePoolVO> templatesInPool, StatsCollector sc) {
    if (s_logger.isDebugEnabled()) {
        s_logger.debug("String_Node_Str" + pool.getName() + "String_Node_Str" + pool.getId());
    }
    if (avoid.shouldAvoid(pool)) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str");
        }
        return false;
    }
    if (dskCh.getType().equals(VolumeType.ROOT) && pool.getPoolType().equals(StoragePoolType.Iscsi)) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str");
        }
        return false;
    }
    if (!pool.getStatus().equals(StoragePoolStatus.Up)) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str" + pool.getStatus().name() + "String_Node_Str");
        }
        return false;
    }
    if (!poolIsCorrectType(dskCh, pool)) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str");
        }
        return false;
    }
    Long clusterId = pool.getClusterId();
    ClusterVO cluster = _clusterDao.findById(clusterId);
    if (!(cluster.getHypervisorType() == dskCh.getHypersorType())) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str");
        }
        return false;
    }
    if (sc != null) {
        long totalSize = pool.getCapacityBytes();
        StorageStats stats = sc.getStorageStats(pool.getId());
        if (stats != null) {
            double usedPercentage = ((double) stats.getByteUsed() / (double) totalSize);
            if (s_logger.isDebugEnabled()) {
                s_logger.debug("String_Node_Str" + pool.getId() + "String_Node_Str" + pool.getCapacityBytes() + "String_Node_Str" + stats.getByteUsed() + "String_Node_Str" + usedPercentage + "String_Node_Str" + _storageUsedThreshold);
            }
            if (usedPercentage >= _storageUsedThreshold) {
                return false;
            }
        }
    }
    Pair<Long, Long> sizes = _volumeDao.getCountAndTotalByPool(pool.getId());
    long totalAllocatedSize = sizes.second() + sizes.first() * _extraBytesPerVolume;
    boolean tmpinstalled = false;
    List<VMTemplateStoragePoolVO> templatePoolVOs;
    if (templatesInPool != null) {
        templatePoolVOs = templatesInPool;
    } else {
        templatePoolVOs = _templatePoolDao.listByPoolId(pool.getId());
    }
    for (VMTemplateStoragePoolVO templatePoolVO : templatePoolVOs) {
        if ((template != null) && !tmpinstalled && (templatePoolVO.getTemplateId() == template.getId())) {
            tmpinstalled = true;
        }
        long templateSize = templatePoolVO.getTemplateSize();
        totalAllocatedSize += templateSize + _extraBytesPerVolume;
    }
    if ((template != null) && !tmpinstalled) {
        HostVO secondaryStorageHost = _storageMgr.getSecondaryStorageHost(pool.getDataCenterId());
        if (secondaryStorageHost == null) {
            return false;
        } else {
            VMTemplateHostVO templateHostVO = _templateHostDao.findByHostTemplate(secondaryStorageHost.getId(), template.getId());
            if (templateHostVO == null) {
                return false;
            } else {
                s_logger.debug("String_Node_Str" + template.getName() + "String_Node_Str" + 2);
                long templateSize = templateHostVO.getSize();
                long templatePhysicalSize = templateHostVO.getPhysicalSize();
                totalAllocatedSize += (templateSize + _extraBytesPerVolume) + (templatePhysicalSize + _extraBytesPerVolume);
            }
        }
    }
    long askingSize = dskCh.getSize();
    int storageOverprovisioningFactor = 1;
    if (pool.getPoolType() == StoragePoolType.NetworkFilesystem) {
        storageOverprovisioningFactor = _storageOverprovisioningFactor;
    }
    if (s_logger.isDebugEnabled()) {
        s_logger.debug("String_Node_Str" + pool.getId() + "String_Node_Str" + (pool.getCapacityBytes() * storageOverprovisioningFactor) + "String_Node_Str" + totalAllocatedSize + "String_Node_Str" + askingSize);
    }
    if ((pool.getCapacityBytes() * storageOverprovisioningFactor) < (totalAllocatedSize + askingSize)) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("String_Node_Str" + pool.getId() + "String_Node_Str" + (pool.getCapacityBytes() * storageOverprovisioningFactor) + "String_Node_Str" + totalAllocatedSize + "String_Node_Str" + askingSize);
        }
        return false;
    }
    return true;
}

Output:
         long totalSize = pool.getCapacityBytes();
-        StorageStats stats = sc.getStorageStats(pool.getId());
+        StorageStats stats = sc.getStoragePoolStats(pool.getId());
+        if (stats == null) {
+            stats = sc.getStorageStats(pool.getId());
+        }
         if (stats != null) {