Input:
public DecimalType getProcessThreads(int pid) throws DeviceNotFoundException {
    OSProcess process = operatingSystem.getProcess(pid);
    int threadCount = process.getThreadCount();
    return new DecimalType(threadCount);
}

Output:
 public DecimalType getProcessThreads(int pid) throws DeviceNotFoundException {
-    OSProcess process = operatingSystem.getProcess(pid);
+    OSProcess process = getProcess(pid);
     int threadCount = process.getThreadCount();


Input:
private boolean isValidDirectory(File file) {
    String absolutePath = file.getAbsolutePath();
    boolean tdqProject = false;
    File[] listFiles = file.listFiles();
    if (listFiles != null) {
        for (File afile : listFiles) {
            if (StringUtils.equals(afile.getName(), "String_Node_Str")) {
                tdqProject = true;
                break;
            }
        }
    }
    return (absolutePath.indexOf(EResourceConstant.DATA_PROFILING.getName()) > 0 || absolutePath.indexOf(EResourceConstant.LIBRARIES.getName()) > 0 || absolutePath.indexOf(EResourceConstant.METADATA.getName()) > 0 || absolutePath.indexOf("String_Node_Str") > 0 || StringUtils.equals(file.getName(), ReponsitoryContextBridge.PROJECT_DEFAULT_NAME) || tdqProject) && !file.getName().startsWith("String_Node_Str");
}

Output:
 private boolean isValidDirectory(File file) {
-    String absolutePath = file.getAbsolutePath();
-    boolean tdqProject = false;
-    File[] listFiles = file.listFiles();
-    if (listFiles != null) {
-        for (File afile : listFiles) {
-            if (StringUtils.equals(afile.getName(), "String_Node_Str")) {
-                tdqProject = true;
-                break;
+    if (!file.getName().startsWith("String_Node_Str")) {
+        String absolutePath = file.getAbsolutePath();
+        for (EResourceConstant constant : EResourceConstant.getTopConstants()) {
+            if (absolutePath.indexOf(constant.getPath()) > 0) {
+                return true;
             }


Input:
void getTasksLocked(List<RunningTaskInfo> list, int callingUid, boolean allowed) {
    for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
        final TaskRecord task = mTaskHistory.get(taskNdx);
        ActivityRecord r = null;
        ActivityRecord top = null;
        int numActivities = 0;
        int numRunning = 0;
        final ArrayList<ActivityRecord> activities = task.mActivities;
        if (activities.isEmpty()) {
            continue;
        }
        if (!allowed && !task.isHomeTask() && task.creatorUid != callingUid) {
            continue;
        }
        for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
            r = activities.get(activityNdx);
            if (top == null || (top.state == ActivityState.INITIALIZING)) {
                top = r;
                numActivities = numRunning = 0;
            }
            numActivities++;
            if (r.app != null && r.app.thread != null) {
                numRunning++;
            }
            if (localLOGV)
                Slog.v(TAG, r.intent.getComponent().flattenToShortString() + "String_Node_Str" + r.task);
        }
        RunningTaskInfo ci = new RunningTaskInfo();
        ci.id = task.taskId;
        ci.baseActivity = r.intent.getComponent();
        ci.topActivity = top.intent.getComponent();
        ci.lastActiveTime = task.lastActiveTime;
        if (top.task != null) {
            ci.description = top.task.lastDescription;
        }
        ci.numActivities = numActivities;
        ci.numRunning = numRunning;
        list.add(ci);
    }
}

Output:
         }
-        if (!allowed && !task.isHomeTask() && task.creatorUid != callingUid) {
+        if (!allowed && !task.isHomeTask() && task.effectiveUid != callingUid) {
             continue;


Input:
public void testMerge() throws Exception {
    properties = new HashMap<String, Object>();
    properties.put("String_Node_Str", "String_Node_Str");
    discoveryService.runDiscovery(documentManager, discoveredEndpointId, properties, null, "String_Node_Str");
    documentManager.save();
    DocumentModel foundEndpoint = documentService.find(documentManager, discoveredEndpointId);
    Assert.assertEquals("String_Node_Str", foundEndpoint.getPropertyValue(Endpoint.XPATH_URL));
    Assert.assertEquals("String_Node_Str", foundEndpoint.getPropertyValue("String_Node_Str"));
}

Output:
     properties.put("String_Node_Str", "String_Node_Str");
-    discoveryService.runDiscovery(documentManager, discoveredEndpointId, properties, null, "String_Node_Str");
+    discoveryService.runDiscovery(documentManager, discoveredEndpointId, properties, null, ContextVisibility.DEPTH.getValue());
     documentManager.save();


Input:
public byte[] read(SocketChannel ch) throws IOException {
    if (_readHeader) {
        if (_readBuffer.position() == 0) {
            _readBuffer.limit(4);
        }
        if (ch.read(_readBuffer) == -1) {
            throw new IOException("String_Node_Str");
        }
        if (_readBuffer.hasRemaining()) {
            s_logger.trace("String_Node_Str");
            return null;
        }
        _readBuffer.flip();
        int header = _readBuffer.getInt();
        int readSize = (short) header;
        if (s_logger.isTraceEnabled()) {
            s_logger.trace("String_Node_Str" + readSize);
        }
        if (readSize > MAX_SIZE_PER_PACKET) {
            throw new IOException("String_Node_Str" + readSize);
        }
        if (!_gotFollowingPacket) {
            _plaintextBuffer = ByteBuffer.allocate(2000);
        }
        if ((header & HEADER_FLAG_FOLLOWING) != 0) {
            _gotFollowingPacket = true;
        } else {
            _gotFollowingPacket = false;
        }
        _readBuffer.clear();
        _readHeader = false;
        if (_readBuffer.capacity() < readSize) {
            if (s_logger.isTraceEnabled()) {
                s_logger.trace("String_Node_Str" + _readBuffer.capacity());
            }
            _readBuffer = ByteBuffer.allocate(readSize);
        }
        _readBuffer.limit(readSize);
    }
    if (ch.read(_readBuffer) == -1) {
        throw new IOException("String_Node_Str");
    }
    if (_readBuffer.hasRemaining()) {
        if (s_logger.isTraceEnabled()) {
            s_logger.trace("String_Node_Str" + _readBuffer.remaining());
        }
        return null;
    }
    _readBuffer.flip();
    ByteBuffer appBuf;
    SSLSession sslSession = _sslEngine.getSession();
    SSLEngineResult engResult;
    appBuf = ByteBuffer.allocate(sslSession.getApplicationBufferSize() + 40);
    engResult = _sslEngine.unwrap(_readBuffer, appBuf);
    if (engResult.getHandshakeStatus() != HandshakeStatus.FINISHED && engResult.getHandshakeStatus() != HandshakeStatus.NOT_HANDSHAKING && engResult.getStatus() != SSLEngineResult.Status.OK) {
        throw new IOException("String_Node_Str" + engResult);
    }
    appBuf.flip();
    if (_plaintextBuffer.remaining() < appBuf.limit()) {
        ByteBuffer newBuffer = ByteBuffer.allocate(_plaintextBuffer.capacity() + appBuf.limit() * 5);
        _plaintextBuffer.flip();
        newBuffer.put(_plaintextBuffer);
        _plaintextBuffer = newBuffer;
    }
    _plaintextBuffer.put(appBuf);
    _readBuffer.clear();
    _readHeader = true;
    if (s_logger.isTraceEnabled()) {
        s_logger.trace("String_Node_Str" + appBuf.limit());
    }
    if (!_gotFollowingPacket) {
        _plaintextBuffer.flip();
        byte[] result = new byte[_plaintextBuffer.limit()];
        _plaintextBuffer.get(result);
        return result;
    } else {
        if (s_logger.isTraceEnabled()) {
            s_logger.trace("String_Node_Str");
        }
        return null;
    }
}

Output:
     SSLEngineResult engResult;
-    appBuf = ByteBuffer.allocate(sslSession.getApplicationBufferSize() + 40);
-    engResult = _sslEngine.unwrap(_readBuffer, appBuf);
-    if (engResult.getHandshakeStatus() != HandshakeStatus.FINISHED && engResult.getHandshakeStatus() != HandshakeStatus.NOT_HANDSHAKING && engResult.getStatus() != SSLEngineResult.Status.OK) {
-        throw new IOException("String_Node_Str" + engResult);
+    int remaining = 0;
+    while (_readBuffer.hasRemaining()) {
+        remaining = _readBuffer.remaining();
+        appBuf = ByteBuffer.allocate(sslSession.getApplicationBufferSize() + 40);
+        engResult = _sslEngine.unwrap(_readBuffer, appBuf);
+        if (engResult.getHandshakeStatus() != HandshakeStatus.FINISHED && engResult.getHandshakeStatus() != HandshakeStatus.NOT_HANDSHAKING && engResult.getStatus() != SSLEngineResult.Status.OK) {
+            throw new IOException("String_Node_Str" + engResult);
+        }
+        if (remaining == _readBuffer.remaining()) {
+            throw new IOException("String_Node_Str" + remaining + "String_Node_Str");
+        }
+        appBuf.flip();
+        if (_plaintextBuffer.remaining() < appBuf.limit()) {
+            ByteBuffer newBuffer = ByteBuffer.allocate(_plaintextBuffer.capacity() + appBuf.limit() * 5);
+            _plaintextBuffer.flip();
+            newBuffer.put(_plaintextBuffer);
+            _plaintextBuffer = newBuffer;
+        }
+        _plaintextBuffer.put(appBuf);
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("String_Node_Str" + appBuf.limit());
+        }
     }


Input:
protected void initDataLoader(int id) {
    getLoaderManager().initLoader(id, null, this);
}

Output:
 protected void initDataLoader(int id) {
-    getLoaderManager().initLoader(id, null, this);
+    getLoaderManager().initLoader(id, null, this).forceLoad();
 }


Input:
public void onBindViewHolder(MovieViewHolder holder, int position) {
    Glide.with(mContext.getApplicationContext()).load(Constant.IMAGE_LOADING_BASE_URL_1000 + mMovies.get(position).getBackdropPath()).asBitmap().centerCrop().diskCacheStrategy(DiskCacheStrategy.ALL).into(holder.moviePosterImageView);
    holder.movieTitleTextView.setText(mMovies.get(position).getTitle());
    if (mMovies.get(position).getVoteAverage() > 0)
        holder.movieRatingTextView.setText(mMovies.get(position).getVoteAverage() + Constant.RATING_SYMBOL);
    else
        holder.movieRatingTextView.setVisibility(View.GONE);
    setGenres(holder, mMovies.get(position).getId());
}

Output:
         holder.movieRatingTextView.setVisibility(View.GONE);
-    setGenres(holder, mMovies.get(position).getId());
+    setGenres(holder, mMovies.get(position));
 }


Input:
public static boolean isSoilValid(IBlockAccess world, BlockPos pos) {
    FuzzyStack soil = new FuzzyStack(world.getBlockState(pos));
    return soils.contains(soil) || defaultSoils.contains(soil);
}

Output:
     FuzzyStack soil = new FuzzyStack(world.getBlockState(pos));
-    return soils.contains(soil) || defaultSoils.contains(soil);
+    return SoilRegistry.getInstance().isSoil(soil) || defaultSoils.contains(soil);
 }


Input:
public void widgetSelected(SelectionEvent e) {
    IStructuredSelection selection = (IStructuredSelection) corpuses.getSelection();
    try {
        Object selectedObj = selection.getFirstElement();
        if (selectedObj instanceof ICorpus) {
            ICorpus selectedCorpus = (ICorpus) selection.getFirstElement();
            corpusList.remove(selectedCorpus);
            ManageCorpora.removeCorpus((Corpus) selectedCorpus, true);
        } else if (selectedObj instanceof ICorpusClass) {
            ITreeSelection classSelection = (ITreeSelection) selection;
            ICorpusClass selectedClass = (ICorpusClass) selection.getFirstElement();
            Corpus parentCorpus = (Corpus) classSelection.getPaths()[0].getParentPath().getLastSegment();
            parentCorpus.removeClass(selectedClass);
            ManageCorpora.removeCorpus(parentCorpus, false);
        }
        corpuses.refresh();
    } catch (Exception exp) {
    }
}

Output:
 public void widgetSelected(SelectionEvent e) {
-    IStructuredSelection selection = (IStructuredSelection) corpuses.getSelection();
+    IStructuredSelection selection = (IStructuredSelection) corpusViewer.getSelection();
     try {


Input:
public void onNext(final IdleClock idleClock) {
    LOG.log(Level.INFO, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", new Object[] { idleClock, runtimeStatusProto.getState(), runtimeStatusProto.getOutstandingContainerRequests(), runtimeStatusProto.getContainerAllocationCount() });
    synchronized (DriverManager.this.evaluators) {
        if (ReefServiceProtos.State.RUNNING == runtimeStatusProto.getState() && 0 == runtimeStatusProto.getOutstandingContainerRequests() && 0 == runtimeStatusProto.getContainerAllocationCount()) {
            LOG.log(Level.FINEST, "String_Node_Str");
            DriverManager.this.clockFuture.get().close();
        }
    }
}

Output:
     synchronized (DriverManager.this.evaluators) {
-        if (ReefServiceProtos.State.RUNNING == runtimeStatusProto.getState() && 0 == runtimeStatusProto.getOutstandingContainerRequests() && 0 == runtimeStatusProto.getContainerAllocationCount()) {
+        if (ReefServiceProtos.State.RUNNING == runtimeStatusProto.getState() && 0 == runtimeStatusProto.getOutstandingContainerRequests() && 0 == runtimeStatusProto.getContainerAllocationCount() && DriverManager.this.evaluatorsClosed()) {
+            try {
+                Thread.sleep(500);
+            } catch (final InterruptedException ex) {
+                LOG.log(Level.WARNING, "String_Node_Str", ex);
+            }
             LOG.log(Level.FINEST, "String_Node_Str");


Input:
public static PrimaryIndex createIndex(final PropertyManagement propertyManagement) throws Exception {
    PersistableStore store = (PersistableStore) StoreParameters.StoreParam.STORE.getHelper().getValue(propertyManagement);
    final IndexStore indexStore = store.getDataStoreOptions().createIndexStore();
    return (PrimaryIndex) indexStore.getIndex(new ByteArrayId(propertyManagement.getPropertyAsString(CentroidParameters.Centroid.INDEX_ID)));
}

Output:
 public static PrimaryIndex createIndex(final PropertyManagement propertyManagement) throws Exception {
-    PersistableStore store = (PersistableStore) StoreParameters.StoreParam.STORE.getHelper().getValue(propertyManagement);
+    PersistableStore store = (PersistableStore) StoreParameters.StoreParam.INPUT_STORE.getHelper().getValue(propertyManagement);
     final IndexStore indexStore = store.getDataStoreOptions().createIndexStore();


Input:
public void testSendBasicBytesMessageWithContent() throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer(IntegrationTestFixture.PORT)) {
        Connection connection = testFixture.establishConnecton(testPeer);
        testPeer.expectBegin(true);
        testPeer.expectSenderAttach();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("String_Node_Str");
        MessageProducer producer = session.createProducer(queue);
        byte[] content = "String_Node_Str".getBytes();
        MessageHeaderSectionMatcher headersMatcher = new MessageHeaderSectionMatcher(true).withDurable(equalTo(true));
        MessageAnnotationsSectionMatcher msgAnnotationsMatcher = new MessageAnnotationsSectionMatcher(true);
        msgAnnotationsMatcher.withEntry(Symbol.valueOf(AmqpMessageSupport.JMS_MSG_TYPE), equalTo(AmqpMessageSupport.JMS_BYTES_MESSAGE));
        MessagePropertiesSectionMatcher propertiesMatcher = new MessagePropertiesSectionMatcher(true);
        propertiesMatcher.withContentType(equalTo(Symbol.valueOf(AmqpMessageSupport.OCTET_STREAM_CONTENT_TYPE)));
        TransferPayloadCompositeMatcher messageMatcher = new TransferPayloadCompositeMatcher();
        messageMatcher.setHeadersMatcher(headersMatcher);
        messageMatcher.setMessageAnnotationsMatcher(msgAnnotationsMatcher);
        messageMatcher.setPropertiesMatcher(propertiesMatcher);
        messageMatcher.setMessageContentMatcher(new EncodedDataMatcher(new Binary(content)));
        testPeer.expectTransfer(messageMatcher);
        BytesMessage message = session.createBytesMessage();
        message.writeBytes(content);
        producer.send(message);
    }
}

Output:
 public void testSendBasicBytesMessageWithContent() throws Exception {
-    try (TestAmqpPeer testPeer = new TestAmqpPeer(IntegrationTestFixture.PORT)) {
+    try (TestAmqpPeer testPeer = new TestAmqpPeer(testFixture.getAvailablePort())) {
         Connection connection = testFixture.establishConnecton(testPeer);


Input:
public void restartSuggestionsOnWordTouchedByCursor(final SettingsValues settingsValues, final boolean includeResumedWordInSuggestions) {
    if (settingsValues.isBrokenByRecorrection())
        return;
    if (!settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces)
        return;
    if (!settingsValues.isSuggestionsRequested())
        return;
    if (mConnection.hasSelection())
        return;
    if (mConnection.getExpectedSelectionStart() < 0)
        return;
    final int expectedCursorPosition = mConnection.getExpectedSelectionStart();
    if (!mConnection.isCursorTouchingWord(settingsValues.mSpacingAndPunctuations))
        return;
    final TextRange range = mConnection.getWordRangeAtCursor(settingsValues.mSpacingAndPunctuations.mSortedWordSeparators, 0);
    if (null == range)
        return;
    if (range.length() <= 0)
        return;
    if (range.mHasUrlSpans)
        return;
    final int numberOfCharsInWordBeforeCursor = range.getNumberOfCharsInWordBeforeCursor();
    if (numberOfCharsInWordBeforeCursor > expectedCursorPosition)
        return;
    final ArrayList<SuggestedWordInfo> suggestions = CollectionUtils.newArrayList();
    final String typedWord = range.mWord.toString();
    if (includeResumedWordInSuggestions) {
        suggestions.add(new SuggestedWordInfo(typedWord, SuggestedWords.MAX_SUGGESTIONS + 1, SuggestedWordInfo.KIND_TYPED, Dictionary.DICTIONARY_USER_TYPED, SuggestedWordInfo.NOT_AN_INDEX, SuggestedWordInfo.NOT_A_CONFIDENCE));
    }
    if (!isResumableWord(settingsValues, typedWord))
        return;
    int i = 0;
    for (final SuggestionSpan span : range.getSuggestionSpansAtWord()) {
        for (final String s : span.getSuggestions()) {
            ++i;
            if (!TextUtils.equals(s, typedWord)) {
                suggestions.add(new SuggestedWordInfo(s, SuggestedWords.MAX_SUGGESTIONS - i, SuggestedWordInfo.KIND_RESUMED, Dictionary.DICTIONARY_RESUMED, SuggestedWordInfo.NOT_AN_INDEX, SuggestedWordInfo.NOT_A_CONFIDENCE));
            }
        }
    }
    final int[] codePoints = StringUtils.toCodePointArray(typedWord);
    mWordComposer.setComposingWord(codePoints, mLatinIME.getCoordinatesForCurrentKeyboard(codePoints), getNthPreviousWordForSuggestion(settingsValues.mSpacingAndPunctuations, 0 == numberOfCharsInWordBeforeCursor ? 1 : 2));
    mWordComposer.setCursorPositionWithinWord(typedWord.codePointCount(0, numberOfCharsInWordBeforeCursor));
    mConnection.setComposingRegion(expectedCursorPosition - numberOfCharsInWordBeforeCursor, expectedCursorPosition + range.getNumberOfCharsInWordAfterCursor());
    if (suggestions.isEmpty()) {
        mInputLogicHandler.getSuggestedWords(Suggest.SESSION_TYPING, SuggestedWords.NOT_A_SEQUENCE_NUMBER, new OnGetSuggestedWordsCallback() {
            public void onGetSuggestedWords(final SuggestedWords suggestedWordsIncludingTypedWord) {
                final SuggestedWords suggestedWords;
                if (suggestedWordsIncludingTypedWord.size() > 1 && !includeResumedWordInSuggestions) {
                    suggestedWords = suggestedWordsIncludingTypedWord.getSuggestedWordsExcludingTypedWord();
                } else {
                    suggestedWords = suggestedWordsIncludingTypedWord;
                }
                mIsAutoCorrectionIndicatorOn = false;
                mLatinIME.mHandler.showSuggestionStrip(suggestedWords);
            }
        });
    } else {
        final SuggestedWords suggestedWords = new SuggestedWords(suggestions, null, typedWord, true, false, false, false, SuggestedWords.NOT_A_SEQUENCE_NUMBER);
        mIsAutoCorrectionIndicatorOn = false;
        mLatinIME.mHandler.showSuggestionStrip(suggestedWords);
    }
}

Output:
 public void restartSuggestionsOnWordTouchedByCursor(final SettingsValues settingsValues, final boolean includeResumedWordInSuggestions) {
-    if (settingsValues.isBrokenByRecorrection())
-        return;
-    if (!settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces)
-        return;
-    if (!settingsValues.isSuggestionsRequested())
-        return;
-    if (mConnection.hasSelection())
-        return;
-    if (mConnection.getExpectedSelectionStart() < 0)
+    if (settingsValues.isBrokenByRecorrection() || !settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces || !settingsValues.isSuggestionsRequested() || mConnection.hasSelection() || mConnection.getExpectedSelectionStart() < 0) {
+        mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
         return;


Input:
private void doAddWord(final CharSequence word, final boolean ignoreCase, final int index) {
    if (word.length() == index) {
        fullWord = true;
        return;
    }
    char c;
    TrieNodeBuilder builder;
    c = word.charAt(index);
    builder = subnodes.get(c);
    if (builder == null) {
        builder = new TrieNodeBuilder();
        subnodes.put(c, builder);
    }
    builder.doAddWord(word, ignoreCase, index + 1);
    if (!ignoreCase)
        return;
    final boolean upper = Character.isUpperCase(c);
    final boolean lower = Character.isLowerCase(c);
    if (upper == lower)
        return;
    if (Character.isUpperCase(c)) {
        c = Character.toLowerCase(c);
        builder = subnodes.get(c);
        if (builder == null) {
            builder = new TrieNodeBuilder();
            subnodes.put(c, builder);
        }
        builder.doAddWord(word, ignoreCase, index + 1);
    }
    if (Character.isLowerCase(c)) {
        c = Character.toUpperCase(c);
        builder = subnodes.get(c);
        if (builder == null) {
            builder = new TrieNodeBuilder();
            subnodes.put(c, builder);
        }
        builder.doAddWord(word, ignoreCase, index + 1);
    }
}

Output:
     }
-    char c;
-    TrieNodeBuilder builder;
-    c = word.charAt(index);
-    builder = subnodes.get(c);
+    final char c = buffer.get();
+    TrieNodeBuilder builder = subnodes.get(c);
     if (builder == null) {


Input:
public void stateChanged(ChangeEvent event) {
    JSlider source = (JSlider) event.getSource();
    double value = (double) source.getValue();
    output.setScale(value);
}

Output:
     JSlider source = (JSlider) event.getSource();
-    double value = (double) source.getValue();
-    output.setScale(value);
+    int value = (int) source.getValue();
+    osc.setTimeDelta(0.001 * value);
 }


Input:
private TextView getTextView(final MarkdownList pMarkdownList, final CharSequence pText, final int pIndex) {
    final TextView textView = new TextView(mContext, null, R.attr.MarkdownListStyle);
    textView.setMovementMethod(LinkMovementMethod.getInstance());
    if (pMarkdownList.isOrdered()) {
        textView.setText(String.format(Locale.getDefault(), "String_Node_Str", pIndex + 1, pText));
    } else {
        Drawable bullet = mContext.getResources().getDrawable(getDrawable(pMarkdownList.getNestedLevel()));
        TopCompoundDrawable gravityDrawable = new TopCompoundDrawable(bullet, textView.getLineHeight());
        bullet.setBounds(0, 0, bullet.getIntrinsicWidth(), bullet.getIntrinsicHeight());
        gravityDrawable.setBounds(0, 0, bullet.getIntrinsicWidth(), bullet.getIntrinsicHeight());
        textView.setCompoundDrawables(gravityDrawable, null, null, null);
        textView.setCompoundDrawablePadding(mIndicatorSpacingPixels);
        textView.setText(pText);
    }
    return textView;
}

Output:
     textView.setMovementMethod(LinkMovementMethod.getInstance());
-    if (pMarkdownList.isOrdered()) {
-        textView.setText(String.format(Locale.getDefault(), "String_Node_Str", pIndex + 1, pText));
+    if (pMarkDownList.isOrdered()) {
+        SpannableString string = new SpannableString(pText);
+        string.setSpan(new NumberSpan(mListMargin, pIndex + 1), 0, string.length(), Spanned.SPAN_INCLUSIVE_INCLUSIVE);
+        textView.setText(string);
     } else {


Input:
public EtcdResponse get(String key) throws EtcdClientException {
    URI uri = buildUriWithKeyAndParams(key, null);
    HttpGet httpGet = new HttpGet(uri);
    EtcdResponse response = execute(httpGet);
    if (response.isError()) {
        if (response.errorCode == 100) {
            return null;
        }
    }
    return response;
}

Output:
     URI uri = buildUriWithKeyAndParams(key, null);
-    HttpGet httpGet = new HttpGet(uri);
-    EtcdResponse response = execute(httpGet);
-    if (response.isError()) {
-        if (response.errorCode == 100) {
-            return null;
-        }
-    }
-    return response;
+    HttpGet httpGet;
+    httpGet = new HttpGet(uri);
+    return execute(httpGet);
 }


Input:
public static int moveItem(IInventory fromInventory, int slot, IInventory targetInventory, int maxAmount) {
    int merged = 0;
    ItemStack stack = fromInventory.getStackInSlot(slot);
    if (stack == null) {
        return 0;
    }
    ItemStack clonedStack = stack.copy();
    clonedStack.stackSize = Math.min(clonedStack.stackSize, maxAmount);
    int amountToMerge = clonedStack.stackSize;
    InventoryUtils.insertItemIntoInventory(targetInventory, clonedStack);
    merged = (amountToMerge - clonedStack.stackSize);
    fromInventory.decrStackSize(slot, merged);
    return merged;
}

Output:
     int amountToMerge = clonedStack.stackSize;
-    InventoryUtils.insertItemIntoInventory(targetInventory, clonedStack);
+    InventoryUtils.insertItemIntoInventory(targetInventory, clonedStack, side.getOpposite());
     merged = (amountToMerge - clonedStack.stackSize);


Input:
private Address scanFrame(int verbosity) {
    if (!setUpFrame(verbosity))
        return fp;
    scanFrameForObjects(verbosity);
    if (processCodeLocations && compiledMethodType != CompiledMethod.TRAP)
        processFrameForCode(verbosity);
    iterator.cleanupPointers();
    if (compiledMethodType != CompiledMethod.TRAP && compiledMethod.getMethod().getDeclaringClass().hasBridgeFromNativeAnnotation()) {
        fp = RuntimeEntrypoints.unwindNativeStackFrameForGC(fp);
        if (verbosity >= 1)
            Log.write("String_Node_Str");
    }
    return fp;
}

Output:
         fp = RuntimeEntrypoints.unwindNativeStackFrameForGC(fp);
-        if (verbosity >= 1)
+        if (verbosity >= 2)
             Log.write("String_Node_Str");


Input:
public void reset() {
    int lastLevel = getLevel();
    exp = 0;
    Bukkit.getServer().getPluginManager().callEvent(new MyPetLevelUpEvent(myPet, lastLevel, getLevel(), true));
}

Output:
     exp = 0;
-    Bukkit.getServer().getPluginManager().callEvent(new MyPetLevelUpEvent(myPet, lastLevel, getLevel(), true));
+    Bukkit.getServer().getPluginManager().callEvent(new MyPetLevelUpEvent(myPet, getLevel(), 0, true));
 }


Input:
public String get() {
    if (formatString == null)
        return "String_Node_Str";
    String s = ChatColor.translateAlternateColorCodes('&', formatString);
    for (Map.Entry<String, String> stringStringEntry : modifiers.entrySet()) {
        String value = stringStringEntry.getValue();
        if (coloredInputs)
            value = ChatColor.translateAlternateColorCodes('&', value);
        s = s.replaceAll(String.format("String_Node_Str", stringStringEntry.getKey()), value);
        s = s.replaceAll("String_Node_Str" + stringStringEntry.getKey() + "String_Node_Str", value);
    }
    if (prefix && loadedPrefix != null)
        return loadedPrefix + s;
    return s;
}

Output:
             value = ChatColor.translateAlternateColorCodes('&', value);
-        s = s.replaceAll(String.format("String_Node_Str", stringStringEntry.getKey()), value);
+        s = s.replaceAll("String_Node_Str" + stringStringEntry.getKey() + "String_Node_Str", value);
         s = s.replaceAll("String_Node_Str" + stringStringEntry.getKey() + "String_Node_Str", value);


Input:
public void testForceDeleteClusterWhenStopFailed() {
    AmbariImpl spy = Mockito.spy(provider);
    Mockito.when(spy.echo()).thenReturn(false);
    Mockito.when(spy.isProvisioned(Mockito.anyString())).thenReturn(true);
    Mockito.doReturn(false).when(spy).onStopCluster(Mockito.<ClusterBlueprint>any(), Mockito.<ClusterReportQueue>any());
    Assert.assertTrue(spy.onDeleteCluster(blueprint, reportQueue));
}

Output:
     AmbariImpl spy = Mockito.spy(provider);
-    Mockito.when(spy.echo()).thenReturn(false);
+    Mockito.when(spy.echo()).thenReturn(true);
     Mockito.when(spy.isProvisioned(Mockito.anyString())).thenReturn(true);


Input:
public Wallet getWallet() {
    return wallet;
}

Output:
 public Wallet getWallet() {
-    return wallet;
+    return walletInMem;
 }


Input:
public boolean onInterceptTouchEvent(MotionEvent ev) {
    if (DEBUG)
        Log.d(TAG, "String_Node_Str" + ev);
    ensureTarget();
    boolean handled = false;
    float curY = ev.getY();
    if (mReturningToStart && ev.getAction() == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;
    }
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        mCurrPercentage = 0;
        mDownEvent = MotionEvent.obtain(ev);
        mPrevY = mDownEvent.getY();
        mCheckValidMotionFlag = true;
        checkHorizontalMove = true;
    } else if (ev.getAction() == MotionEvent.ACTION_MOVE) {
        float yDiff = curY - mDownEvent.getY();
        if (yDiff < 0)
            yDiff = -yDiff;
        if (enableHorizontalScroll) {
            MotionEvent event = MotionEvent.obtain(ev);
            int horizontalScrollDirection = ev.getX() > mDownEvent.getX() ? -1 : 1;
            float xDiff = Math.abs(ev.getX() - mDownEvent.getX());
            if (DEBUG) {
                Log.d(TAG, "String_Node_Str" + xDiff + "String_Node_Str" + yDiff + "String_Node_Str" + canViewScrollHorizontally(mTarget, event, 0) + "String_Node_Str" + checkHorizontalMove + "String_Node_Str" + horizontalScrollDirection);
            }
            if (isHorizontalScroll) {
                if (DEBUG)
                    Log.d(TAG, "String_Node_Str");
                mPrevY = curY;
                checkHorizontalMove = false;
                return false;
            } else if (xDiff <= mTouchSlop) {
                checkHorizontalMove = true;
            } else if (canViewScrollHorizontally(mTarget, event, horizontalScrollDirection) && checkHorizontalMove && xDiff > 2 * yDiff) {
                if (DEBUG)
                    Log.d(TAG, "String_Node_Str");
                mPrevY = curY;
                isHorizontalScroll = true;
                checkHorizontalMove = false;
                return false;
            } else {
                checkHorizontalMove = false;
            }
        }
        if (yDiff < mTouchSlop) {
            mPrevY = curY;
            return false;
        }
    } else if (ev.getAction() == MotionEvent.ACTION_UP) {
        if (enableHorizontalScroll && isHorizontalScroll) {
            if (DEBUG)
                Log.d(TAG, "String_Node_Str");
            isHorizontalScroll = false;
            return false;
        }
    }
    if (isEnabled()) {
        MotionEvent event = MotionEvent.obtain(ev);
        if (!mReturningToStart && !canViewScrollUp(mTarget, event)) {
            handled = onTouchEvent(ev);
            if (DEBUG)
                Log.d(TAG, "String_Node_Str" + handled);
        } else {
            mPrevY = ev.getY();
        }
    }
    boolean ret = !handled ? super.onInterceptTouchEvent(ev) : handled;
    if (DEBUG)
        Log.d(TAG, "String_Node_Str" + ret);
    return ret;
}

Output:
             if (DEBUG) {
-                Log.d(TAG, "String_Node_Str" + xDiff + "String_Node_Str" + yDiff + "String_Node_Str" + canViewScrollHorizontally(mTarget, event, 0) + "String_Node_Str" + checkHorizontalMove + "String_Node_Str" + horizontalScrollDirection);
+                Log.d(TAG, "String_Node_Str" + xDiff + "String_Node_Str" + mTouchSlop + "String_Node_Str" + yDiff + "String_Node_Str" + canViewScrollHorizontally(mTarget, MotionEvent.obtain(event), horizontalScrollDirection) + "String_Node_Str" + checkHorizontalMove + "String_Node_Str" + horizontalScrollDirection);
             }


Input:
public void onUpdate(ItemStack stack, World world, Entity entity, int par4, boolean par5) {
    if (world.isRemote || par4 > 8 || !(entity instanceof EntityPlayer)) {
        return;
    }
    super.onUpdate(stack, world, entity, par4, par5);
    EntityPlayer player = (EntityPlayer) entity;
    if (stack.getItemDamage() != 0) {
        if (!canStore(stack)) {
            this.changeMode(player, stack);
            return;
        }
        if (player.experienceTotal > 0) {
            int toAdd = player.experienceTotal >= TRANSFER_RATE ? TRANSFER_RATE : player.experienceTotal;
            addStoredXP(stack, toAdd);
            removeXP(player, TRANSFER_RATE);
        }
    }
}

Output:
         }
-        if (player.experienceTotal > 0) {
-            int toAdd = player.experienceTotal >= TRANSFER_RATE ? TRANSFER_RATE : player.experienceTotal;
+        if (getXP(player) > 0) {
+            int toAdd = getXP(player) >= TRANSFER_RATE ? TRANSFER_RATE : getXP(player);
             addStoredXP(stack, toAdd);


Input:
public IPreparedCubeQuery prepare(ICubeQueryDefinition query, Map appContext) throws BirtException {
    stopSign.start();
    if (this.cubeHandleMap.get(query.getName()) != null) {
        this.materializeCube((CubeHandle) this.cubeHandleMap.get(query.getName()), appContext, stopSign);
        this.cubeHandleMap.remove(query.getName());
    }
    if (this.sessionContext.getDataEngineContext().getMode() == DataEngineContext.DIRECT_PRESENTATION) {
        int size = 0;
        if (appContext != null) {
            size = populateFetchLimitSize(appContext.get(DataEngine.CUBECURSOR_FETCH_LIMIT_ON_LEVEL));
            if (size >= 0) {
                query.getFilters().addAll(fetchFilterList(query.getEdge(ICubeQueryDefinition.COLUMN_EDGE), size));
                query.getFilters().addAll(fetchFilterList(query.getEdge(ICubeQueryDefinition.ROW_EDGE), size));
            }
        }
    }
    return this.dataEngine.prepare(query, appContext);
}

Output:
 public IPreparedCubeQuery prepare(ICubeQueryDefinition query, Map appContext) throws BirtException {
-    stopSign.start();
+    if (stopSign != null)
+        stopSign.start();
     if (this.cubeHandleMap.get(query.getName()) != null) {


Input:
private void populateFromCentralDirectory() throws IOException {
    positionAtCentralDirectory();
    byte[] cfh = new byte[CFH_LEN];
    byte[] signatureBytes = new byte[WORD];
    archive.readFully(signatureBytes);
    long sig = ZipLong.getValue(signatureBytes);
    final long cfhSig = ZipLong.getValue(ZipOutputStream.CFH_SIG);
    if (sig != cfhSig && startsWithLocalFileHeader()) {
        throw new IOException("String_Node_Str" + "String_Node_Str");
    }
    while (sig == cfhSig) {
        archive.readFully(cfh);
        int off = 0;
        ZipEntry ze = new ZipEntry();
        int versionMadeBy = ZipShort.getValue(cfh, off);
        off += SHORT;
        ze.setPlatform((versionMadeBy >> BYTE_SHIFT) & NIBLET_MASK);
        off += WORD;
        ze.setMethod(ZipShort.getValue(cfh, off));
        off += SHORT;
        long time = dosToJavaTime(ZipLong.getValue(cfh, off));
        ze.setTime(time);
        off += WORD;
        ze.setCrc(ZipLong.getValue(cfh, off));
        off += WORD;
        ze.setCompressedSize(ZipLong.getValue(cfh, off));
        off += WORD;
        ze.setSize(ZipLong.getValue(cfh, off));
        off += WORD;
        int fileNameLen = ZipShort.getValue(cfh, off);
        off += SHORT;
        int extraLen = ZipShort.getValue(cfh, off);
        off += SHORT;
        int commentLen = ZipShort.getValue(cfh, off);
        off += SHORT;
        off += SHORT;
        ze.setInternalAttributes(ZipShort.getValue(cfh, off));
        off += SHORT;
        ze.setExternalAttributes(ZipLong.getValue(cfh, off));
        off += WORD;
        byte[] fileName = new byte[fileNameLen];
        archive.readFully(fileName);
        ze.setName(getString(fileName));
        OffsetEntry offset = new OffsetEntry();
        offset.headerOffset = ZipLong.getValue(cfh, off);
        entries.put(ze, offset);
        nameMap.put(ze.getName(), ze);
        archive.skipBytes(extraLen);
        byte[] comment = new byte[commentLen];
        archive.readFully(comment);
        ze.setComment(getString(comment));
        archive.readFully(signatureBytes);
        sig = ZipLong.getValue(signatureBytes);
    }
}

Output:
         nameMap.put(ze.getName(), ze);
-        archive.skipBytes(extraLen);
+        int lenToSkip = extraLen;
+        while (lenToSkip > 0) {
+            int skipped = archive.skipBytes(lenToSkip);
+            if (skipped <= 0) {
+                throw new RuntimeException("String_Node_Str" + "String_Node_Str");
+            }
+            lenToSkip -= skipped;
+        }
         byte[] comment = new byte[commentLen];


Input:
public void initListViewComponents() {
    mainTable = new JTable();
    mainModel = new TableModel();
    mainModel.addListeners(mainTable);
    mainTable.setModel(mainModel);
    mainTable.setForeground(Color.white);
    DefaultTableCellRenderer myRenderer = (DefaultTableCellRenderer) mainTable.getDefaultRenderer(String.class);
    myRenderer.setBackground(new Color(0, 0, 0, 100));
    mainTable.getColumnModel().getColumn(0).setMaxWidth(25);
    mainTable.getColumnModel().getColumn(0).setPreferredWidth(25);
    mainTable.getColumnModel().getColumn(1).setPreferredWidth(110);
    mainTable.getColumnModel().getColumn(2).setPreferredWidth(90);
    mainTable.getColumnModel().getColumn(3).setPreferredWidth(50);
    mainTable.getColumnModel().getColumn(4).setPreferredWidth(170);
    mainTable.getColumnModel().getColumn(5).setPreferredWidth(30);
    mainTable.getColumnModel().getColumn(6).setPreferredWidth(15);
    mainTable.getColumnModel().getColumn(7).setPreferredWidth(15);
    if (PreferencesDialog.getCachedValue(PreferencesDialog.KEY_DRAFT_PILES_TOGGLE, "String_Node_Str").equals("String_Node_Str")) {
        jScrollPane1.setViewportView(mainTable);
        cbSortBy.setEnabled(false);
        chkPiles.setEnabled(false);
    } else {
        jToggleCardView.setSelected(true);
        jToggleListView.setSelected(false);
        currentView = this;
        jScrollPane1.setViewportView(cardArea);
        cbSortBy.setEnabled(true);
        chkPiles.setEnabled(true);
    }
    mainTable.setOpaque(false);
    mainTable.addMouseListener(new MouseAdapter() {
        public void mousePressed(MouseEvent e) {
            if (e.getClickCount() == 2 && !e.isConsumed()) {
                e.consume();
                handleDoubleClick();
            }
        }
    });
    mainModel.setUpdateCountsCallback(new UpdateCountsCallback(lblCount, lblCreatureCount, lblLandCount));
}

Output:
     mainTable.getColumnModel().getColumn(7).setPreferredWidth(15);
-    if (PreferencesDialog.getCachedValue(PreferencesDialog.KEY_DRAFT_PILES_TOGGLE, "String_Node_Str").equals("String_Node_Str")) {
+    if (PreferencesDialog.getCachedValue(PreferencesDialog.KEY_DRAFT_VIEW, "String_Node_Str").equals("String_Node_Str")) {
         jScrollPane1.setViewportView(mainTable);


Input:
public void testTransform1() throws Throwable {
    userRegexPatterns.add("String_Node_Str");
    userRegexPatterns.add("String_Node_Str");
    userNameRegEx.populateReplacementPatterns(userNameBaseProperty, userRegexPatterns);
    groupRegexPatterns.add("String_Node_Str");
    groupRegexPatterns.add("String_Node_Str");
    groupRegexPatterns.add("String_Node_Str");
    groupNameRegEx.populateReplacementPatterns(userNameBaseProperty, groupRegexPatterns);
    assertEquals("String_Node_Str", userNameRegEx.transform("String_Node_Str"));
    assertEquals("String_Node_Str", groupNameRegEx.transform("String_Node_Str"));
}

Output:
     groupRegexPatterns.add("String_Node_Str");
-    groupNameRegEx.populateReplacementPatterns(userNameBaseProperty, groupRegexPatterns);
+    groupNameRegEx.populateReplacementPatterns(groupNameBaseProperty, groupRegexPatterns);
     assertEquals("String_Node_Str", userNameRegEx.transform("String_Node_Str"));


Input:
public ASBSession getASBSession(Context context) {
    if (isBeforeFirst() || isAfterLast()) {
        return null;
    }
    ASBSession session = new ASBSession(context);
    long id = getLong(getColumnIndex(S.COLUMN_ASB_SET_ID));
    ASBSet set = DataManager.get(context).getASBSet(id);
    session.setASBSet(set);
    long headId = getLong(getColumnIndex(S.COLUMN_HEAD_ARMOR_ID));
    long headDecoration1Id = getLong(getColumnIndex(S.COLUMN_HEAD_DECORATION_1_ID));
    long headDecoration2Id = getLong(getColumnIndex(S.COLUMN_HEAD_DECORATION_2_ID));
    long headDecoration3Id = getLong(getColumnIndex(S.COLUMN_HEAD_DECORATION_3_ID));
    Armor headArmor = getArmorById(context, headId);
    Decoration headDecoration1 = getDecorationById(context, headDecoration1Id);
    Decoration headDecoration2 = getDecorationById(context, headDecoration2Id);
    Decoration headDecoration3 = getDecorationById(context, headDecoration3Id);
    long bodyId = getLong(getColumnIndex(S.COLUMN_BODY_ARMOR_ID));
    long bodyDecoration1Id = getLong(getColumnIndex(S.COLUMN_BODY_DECORATION_1_ID));
    long bodyDecoration2Id = getLong(getColumnIndex(S.COLUMN_BODY_DECORATION_2_ID));
    long bodyDecoration3Id = getLong(getColumnIndex(S.COLUMN_BODY_DECORATION_3_ID));
    Armor bodyArmor = getArmorById(context, bodyId);
    Decoration bodyDecoration1 = getDecorationById(context, bodyDecoration1Id);
    Decoration bodyDecoration2 = getDecorationById(context, bodyDecoration2Id);
    Decoration bodyDecoration3 = getDecorationById(context, bodyDecoration3Id);
    long armsId = getLong(getColumnIndex(S.COLUMN_ARMS_ARMOR_ID));
    long armsDecoration1Id = getLong(getColumnIndex(S.COLUMN_ARMS_DECORATION_1_ID));
    long armsDecoration2Id = getLong(getColumnIndex(S.COLUMN_ARMS_DECORATION_2_ID));
    long armsDecoration3Id = getLong(getColumnIndex(S.COLUMN_ARMS_DECORATION_3_ID));
    Armor armsArmor = getArmorById(context, armsId);
    Decoration armsDecoration1 = getDecorationById(context, armsDecoration1Id);
    Decoration armsDecoration2 = getDecorationById(context, armsDecoration2Id);
    Decoration armsDecoration3 = getDecorationById(context, armsDecoration3Id);
    long waistId = getLong(getColumnIndex(S.COLUMN_WAIST_ARMOR_ID));
    long waistDecoration1Id = getLong(getColumnIndex(S.COLUMN_WAIST_DECORATION_1_ID));
    long waistDecoration2Id = getLong(getColumnIndex(S.COLUMN_WAIST_DECORATION_2_ID));
    long waistDecoration3Id = getLong(getColumnIndex(S.COLUMN_WAIST_DECORATION_3_ID));
    Armor waistArmor = getArmorById(context, waistId);
    Decoration waistDecoration1 = getDecorationById(context, waistDecoration1Id);
    Decoration waistDecoration2 = getDecorationById(context, waistDecoration2Id);
    Decoration waistDecoration3 = getDecorationById(context, waistDecoration3Id);
    long legsId = getLong(getColumnIndex(S.COLUMN_LEGS_ARMOR_ID));
    long legsDecoration1Id = getLong(getColumnIndex(S.COLUMN_LEGS_DECORATION_1_ID));
    long legsDecoration2Id = getLong(getColumnIndex(S.COLUMN_LEGS_DECORATION_2_ID));
    long legsDecoration3Id = getLong(getColumnIndex(S.COLUMN_LEGS_DECORATION_3_ID));
    Armor legsArmor = getArmorById(context, legsId);
    Decoration legsDecoration1 = getDecorationById(context, legsDecoration1Id);
    Decoration legsDecoration2 = getDecorationById(context, legsDecoration2Id);
    Decoration legsDecoration3 = getDecorationById(context, legsDecoration3Id);
    int talismanExists = getInt(getColumnIndex(S.COLUMN_TALISMAN_EXISTS));
    long talismanSkill1Id = getLong(getColumnIndex(S.COLUMN_TALISMAN_SKILL_1_ID));
    int talismanSkill1Points = getInt(getColumnIndex(S.COLUMN_TALISMAN_SKILL_1_POINTS));
    long talismanSkill2Id = getLong(getColumnIndex(S.COLUMN_TALISMAN_SKILL_2_ID));
    int talismanSkill2Points = getInt(getColumnIndex(S.COLUMN_TALISMAN_SKILL_2_POINTS));
    int talismanType = getInt(getColumnIndex(S.COLUMN_TALISMAN_TYPE));
    int talismanSlots = getInt(getColumnIndex(S.COLUMN_TALISMAN_SLOTS));
    long talismanDecoration1Id = getLong(getColumnIndex(S.COLUMN_TALISMAN_DECORATION_1_ID));
    long talismanDecoration2Id = getLong(getColumnIndex(S.COLUMN_TALISMAN_DECORATION_2_ID));
    long talismanDecoration3Id = getLong(getColumnIndex(S.COLUMN_TALISMAN_DECORATION_3_ID));
    Decoration talismanDecoration1 = getDecorationById(context, talismanDecoration1Id);
    Decoration talismanDecoration2 = getDecorationById(context, talismanDecoration2Id);
    Decoration talismanDecoration3 = getDecorationById(context, talismanDecoration3Id);
    if (headArmor != null) {
        session.setEquipment(ASBSession.HEAD, headArmor, false);
    }
    if (headDecoration1 != null) {
        session.addDecoration(ASBSession.HEAD, headDecoration1, false);
    }
    if (headDecoration2 != null) {
        session.addDecoration(ASBSession.HEAD, headDecoration2, false);
    }
    if (headDecoration3 != null) {
        session.addDecoration(ASBSession.HEAD, headDecoration3, false);
    }
    if (bodyArmor != null) {
        session.setEquipment(ASBSession.BODY, bodyArmor, false);
    }
    if (bodyDecoration1 != null) {
        session.addDecoration(ASBSession.BODY, bodyDecoration1, false);
    }
    if (bodyDecoration2 != null) {
        session.addDecoration(ASBSession.BODY, bodyDecoration2, false);
    }
    if (bodyDecoration3 != null) {
        session.addDecoration(ASBSession.BODY, bodyDecoration3, false);
    }
    if (armsArmor != null) {
        session.setEquipment(ASBSession.ARMS, armsArmor, false);
    }
    if (armsDecoration1 != null) {
        session.addDecoration(ASBSession.ARMS, armsDecoration1, false);
    }
    if (armsDecoration2 != null) {
        session.addDecoration(ASBSession.ARMS, armsDecoration2, false);
    }
    if (armsDecoration3 != null) {
        session.addDecoration(ASBSession.ARMS, armsDecoration3, false);
    }
    if (waistArmor != null) {
        session.setEquipment(ASBSession.WAIST, waistArmor, false);
    }
    if (waistDecoration1 != null) {
        session.addDecoration(ASBSession.WAIST, waistDecoration1, false);
    }
    if (waistDecoration2 != null) {
        session.addDecoration(ASBSession.WAIST, waistDecoration2, false);
    }
    if (waistDecoration3 != null) {
        session.addDecoration(ASBSession.WAIST, waistDecoration3, false);
    }
    if (legsArmor != null) {
        session.setEquipment(ASBSession.LEGS, legsArmor, false);
    }
    if (legsDecoration1 != null) {
        session.addDecoration(ASBSession.LEGS, legsDecoration1, false);
    }
    if (legsDecoration2 != null) {
        session.addDecoration(ASBSession.LEGS, legsDecoration2, false);
    }
    if (legsDecoration3 != null) {
        session.addDecoration(ASBSession.LEGS, legsDecoration3, false);
    }
    if (talismanExists == 1) {
        ASBTalisman talisman = new ASBTalisman();
        talisman.setName(ResourceUtils.splitStringInArrayByComma(R.array.talisman_names, talismanType, 0, context) + "String_Node_Str");
        talisman.setTypeIndex(talismanType);
        talisman.setNumSlots(talismanSlots);
        talisman.setSkill1(getSkillTreeById(context, talismanSkill1Id));
        talisman.setSkill1Points(talismanSkill1Points);
        if (talismanSkill2Id != -1) {
            talisman.setSkill2(getSkillTreeById(context, talismanSkill2Id));
            talisman.setSkill2Points(talismanSkill2Points);
        }
        session.setEquipment(ASBSession.TALISMAN, talisman, false);
        if (talismanDecoration1 != null) {
            session.addDecoration(ASBSession.TALISMAN, talismanDecoration1, false);
        }
        if (talismanDecoration2 != null) {
            session.addDecoration(ASBSession.TALISMAN, talismanDecoration2, false);
        }
        if (talismanDecoration3 != null) {
            session.addDecoration(ASBSession.TALISMAN, talismanDecoration2, false);
        }
    }
    session.updateSkillTreePointsSets();
    return session;
}

Output:
         if (talismanDecoration3 != null) {
-            session.addDecoration(ASBSession.TALISMAN, talismanDecoration2, false);
+            session.addDecoration(ASBSession.TALISMAN, talismanDecoration3, false);
         }


Input:
private List<INode> getAllChildren(INode child) {
    INode parentElement = child.parentNode();
    List<INode> childrenUnmodifiable = parentElement.childNodes();
    List<INode> children = new ArrayList<INode>(childrenUnmodifiable.size());
    for (INode iNode : childrenUnmodifiable) {
        if (iNode instanceof IElementNode)
            children.add(iNode);
    }
    return children;
}

Output:
     INode parentElement = child.parentNode();
-    List<INode> childrenUnmodifiable = parentElement.childNodes();
-    List<INode> children = new ArrayList<INode>(childrenUnmodifiable.size());
-    for (INode iNode : childrenUnmodifiable) {
-        if (iNode instanceof IElementNode)
-            children.add(iNode);
+    if (parentElement != null) {
+        List<INode> childrenUnmodifiable = parentElement.childNodes();
+        List<INode> children = new ArrayList<INode>(childrenUnmodifiable.size());
+        for (INode iNode : childrenUnmodifiable) {
+            if (iNode instanceof IElementNode)
+                children.add(iNode);
+        }
+        return children;
     }


Input:
public List<KVDocument> createListFrom(InputStream is) {
    return converter.convert((List<Map<String, Object>>) gson.fromJson(new InputStreamReader(is, Charsets.UTF_8), new TypeToken<List<HashMap<String, Object>>>() {
    }.getType()));
}

Output:
 public List<KVDocument> createListFrom(InputStream is) {
-    return converter.convert((List<Map<String, Object>>) gson.fromJson(new InputStreamReader(is, Charsets.UTF_8), new TypeToken<List<HashMap<String, Object>>>() {
-    }.getType()));
+    return converter.convert((List<Map<String, Object>>) gson.fromJson(new InputStreamReader(is, Charsets.UTF_8), type));
 }


Input:
private void _setupPreviewPage() {
    int pageIndex = 1;
    IFile file = (IFile) getEditorInput().getAdapter(IFile.class);
    try {
        CompilationUnit compilationUnit = _getCompilationUnit();
        String packageName = null;
        if (compilationUnit.getPackage() != null)
            packageName = compilationUnit.getPackage().getName().toString();
        IPath refactoredFile = Environment.getRefactoredFile(file.getLocation().toOSString(), packageName);
        IFile previewFile = Environment.getContainer(refactoredFile).getFile(null);
        _preview = new CompilationUnitEditor();
        _preview.init(_editor.getEditorSite(), new FileEditorInput(previewFile) {

            public boolean exists() {
                return true;
            }
        });
    } catch (Exception e) {
        OutputConsole.outputError(e.getMessage());
    }
}

Output:
     int pageIndex = 1;
-    IFile file = (IFile) getEditorInput().getAdapter(IFile.class);
-    try {
-        CompilationUnit compilationUnit = _getCompilationUnit();
-        String packageName = null;
-        if (compilationUnit.getPackage() != null)
-            packageName = compilationUnit.getPackage().getName().toString();
-        IPath refactoredFile = Environment.getRefactoredFile(file.getLocation().toOSString(), packageName);
-        IFile previewFile = Environment.getContainer(refactoredFile).getFile(null);
-        _preview = new CompilationUnitEditor();
-        _preview.init(_editor.getEditorSite(), new FileEditorInput(previewFile) {
+    _preview = new CompilationUnitEditor();
+    IFile previewFile = _getPreviewFile();
+    if (previewFile != null) {
+        try {
+            _preview.init(_editor.getEditorSite(), new FileEditorInput(previewFile) {


Input:
public AtCommandResult handleSetCommand(Object[] args) {
    if (args[0].equals(0)) {
        mAudioManager.setParameter(HEADSET_NREC, "String_Node_Str");
        return new AtCommandResult(AtCommandResult.OK);
    } else if (args[0].equals(1)) {
        mAudioManager.setParameter(HEADSET_NREC, "String_Node_Str");
        return new AtCommandResult(AtCommandResult.OK);
    }
    return new AtCommandResult(AtCommandResult.ERROR);
}

Output:
     if (args[0].equals(0)) {
-        mAudioManager.setParameter(HEADSET_NREC, "String_Node_Str");
+        mAudioManager.setParameters(HEADSET_NREC + "String_Node_Str");
         return new AtCommandResult(AtCommandResult.OK);


Input:
public static void main(String[] args) {
    try {
        new RandomDifferentialStackTest().runDifferentialTest(95521);
    } catch (Throwable e) {
        for (String call : calls) {
            System.out.println(call);
        }
        throw e;
    }
}

Output:
     try {
-        new RandomDifferentialStackTest().runDifferentialTest(95521);
+        new RandomDifferentialStackTest().runDifferentialTest(22796);
     } catch (Throwable e) {


Input:
void makeExpandedVisible(boolean force) {
    if (SPEW)
        Log.d(TAG, "String_Node_Str" + mExpandedVisible);
    if (!force && (mExpandedVisible || !panelsEnabled())) {
        return;
    }
    mExpandedVisible = true;
    if (mNavigationBarView != null)
        mNavigationBarView.setSlippery(true);
    mStatusBarWindowManager.setStatusBarExpanded(true);
    mStatusBarView.setFocusable(false);
    visibilityChanged(true);
    mWaitingForKeyguardExit = false;
    disable(mDisabledUnmodified1, mDisabledUnmodified2, !force);
    setInteracting(StatusBarManager.WINDOW_STATUS_BAR, true);
}

Output:
         mNavigationBarView.setSlippery(true);
-    mStatusBarWindowManager.setStatusBarExpanded(true);
+    mStatusBarWindowManager.setPanelVisible(true);
     mStatusBarView.setFocusable(false);


Input:
public Port newPort(String name) throws NameDuplicationException {
    try {
        _workspace.getWriteAccess();
        Port port = new ModalPort(this, name);
        Iterator entities = entityList().iterator();
        while (entities.hasNext()) {
            Entity entity = (Entity) entities.next();
            if (entity instanceof ModalController) {
                if (entity.getPort(name) == null) {
                    try {
                        ((ModalController) entity)._mirrorDisable = true;
                        entity.newPort(name);
                    } finally {
                        ((ModalController) entity)._mirrorDisable = false;
                    }
                }
            } else if (entity instanceof Refinement) {
                if (entity.getPort(name) == null) {
                    try {
                        ((Refinement) entity)._mirrorDisable = true;
                        entity.newPort(name);
                    } finally {
                        ((Refinement) entity)._mirrorDisable = false;
                    }
                }
            }
        }
        return port;
    } catch (IllegalActionException ex) {
        throw new InternalErrorException("String_Node_Str" + ex.getMessage());
    } finally {
        _workspace.doneWriting();
    }
}

Output:
         _workspace.getWriteAccess();
-        Port port = new ModalPort(this, name);
+        ModalPort port = new ModalPort(this, name);
         Iterator entities = entityList().iterator();


Input:
public synchronized void save() throws Exception {
    streamingFailoverDao.save(new FailoverPersistenceStoreModel(streamStatusDao.getAll(), null));
}

Output:
 public synchronized void save() throws Exception {
-    streamingFailoverDao.save(new FailoverPersistenceStoreModel(streamStatusDao.getAll(), null));
+    streamingFailoverDao.save(new FailoverPersistenceStoreModel(streamStatusDao.getAll(), streamMetadataService.getSnapshot()));
 }


Input:
private static List<S3ObjectSummary> listDirectory(final String bucketName, final String directory, final AmazonS3 client) {
    List<S3ObjectSummary> objects = new ArrayList<S3ObjectSummary>();
    ListObjectsRequest listObjectsRequest = new ListObjectsRequest().withBucketName(bucketName).withPrefix(directory + SEPARATOR);
    ObjectListing ol = client.listObjects(listObjectsRequest);
    while (ol != null && ol.isTruncated()) {
        objects.addAll(ol.getObjectSummaries());
        listObjectsRequest.setMarker(ol.getNextMarker());
        ol = client.listObjects(listObjectsRequest);
    }
    if (objects.isEmpty()) {
        return emptyList();
    }
    return unmodifiableList(objects);
}

Output:
     ObjectListing ol = client.listObjects(listObjectsRequest);
-    while (ol != null && ol.isTruncated()) {
+    if (ol.isTruncated()) {
+        do {
+            objects.addAll(ol.getObjectSummaries());
+            listObjectsRequest.setMarker(ol.getNextMarker());
+            ol = client.listObjects(listObjectsRequest);
+        } while (ol.isTruncated());
+    } else {
         objects.addAll(ol.getObjectSummaries());


Input:
private Address scanFrame(int verbosity) {
    if (!setUpFrame(verbosity))
        return fp;
    scanFrameForObjects(verbosity);
    if (processCodeLocations)
        processFrameForCode(verbosity);
    iterator.cleanupPointers();
    if (compiledMethod.getMethod().getDeclaringClass().isBridgeFromNative()) {
        fp = VM_Runtime.unwindNativeStackFrameForGC(fp);
        if (verbosity >= 1)
            Log.write("String_Node_Str");
    }
    return fp;
}

Output:
     scanFrameForObjects(verbosity);
-    if (processCodeLocations)
+    if (processCodeLocations && compiledMethodType != VM_CompiledMethod.TRAP)
         processFrameForCode(verbosity);


Input:
public int compareTo(SortableKey o) {
    return mapping.getAttributeName().compareTo(o.getMapping().getAttributeName());
}

Output:
 public int compareTo(SortableKey o) {
-    return mapping.getAttributeName().compareTo(o.getMapping().getAttributeName());
+    if (this.equals(o)) {
+        return 0;
+    } else if (mapping.getAttributeName().equals(o.getMapping().getAttributeName())) {
+        return Integer.compare(index, o.getIndex());
+    } else {
+        return mapping.getAttributeName().compareTo(o.getMapping().getAttributeName());
+    }
 }


Input:
public Bitstream addItemBitstream(String itemId, InputStream inputStream, String name, String description, String groupId, Integer year, Integer month, Integer day, String user_ip, String user_agent, String xforwardedfor, HttpHeaders headers, HttpServletRequest request) throws WebApplicationException {
    log.info("String_Node_Str" + itemId + "String_Node_Str");
    org.dspace.core.Context context = null;
    Bitstream bitstream = null;
    try {
        context = createContext(getUser(headers));
        org.dspace.content.Item dspaceItem = findItem(context, itemId, org.dspace.core.Constants.WRITE);
        writeStats(dspaceItem, UsageEvent.Action.UPDATE, user_ip, user_agent, xforwardedfor, headers, request, context);
        log.trace("String_Node_Str");
        org.dspace.content.Bundle bundle = null;
        org.dspace.content.Bitstream dspaceBitstream = null;
        List<Bundle> bundles = itemService.getBundles(dspaceItem, org.dspace.core.Constants.CONTENT_BUNDLE_NAME);
        if (bundles != null && bundles.size() != 0) {
            bundle = bundles.get(0);
        }
        if (bundle == null) {
            log.trace("String_Node_Str");
            dspaceBitstream = itemService.createSingleBitstream(context, inputStream, dspaceItem);
        } else {
            log.trace("String_Node_Str");
            dspaceBitstream = bitstreamService.create(context, bundle, inputStream);
        }
        dspaceBitstream.setSource(context, "String_Node_Str");
        if (name != null) {
            if (BitstreamResource.getMimeType(name) == null) {
                dspaceBitstream.setFormat(context, bitstreamFormatService.findUnknown(context));
            } else {
                bitstreamService.setFormat(context, dspaceBitstream, bitstreamFormatService.findByMIMEType(context, BitstreamResource.getMimeType(name)));
            }
            dspaceBitstream.setName(context, name);
        }
        if (description != null) {
            dspaceBitstream.setDescription(context, description);
        }
        if (groupId != null) {
            List<BundleBitstream> bundleBitstreams = dspaceBitstream.getBundles();
            for (Bundle dspaceBundle : bundles) {
                List<org.dspace.authorize.ResourcePolicy> bitstreamsPolicies = bundleService.getBitstreamPolicies(context, dspaceBundle);
                List<org.dspace.authorize.ResourcePolicy> policiesToRemove = new ArrayList<org.dspace.authorize.ResourcePolicy>();
                for (org.dspace.authorize.ResourcePolicy policy : bitstreamsPolicies) {
                    if (policy.getdSpaceObject().getID() == dspaceBitstream.getID()) {
                        policiesToRemove.add(policy);
                    }
                }
                for (org.dspace.authorize.ResourcePolicy policy : policiesToRemove) {
                    bitstreamsPolicies.remove(policy);
                }
                org.dspace.authorize.ResourcePolicy dspacePolicy = resourcePolicyService.create(context);
                dspacePolicy.setAction(org.dspace.core.Constants.READ);
                dspacePolicy.setGroup(groupService.findByIdOrLegacyId(context, groupId));
                dspacePolicy.setdSpaceObject(dspaceBitstream);
                if ((year != null) || (month != null) || (day != null)) {
                    Date date = new Date();
                    if (year != null) {
                        date.setYear(year - 1900);
                    }
                    if (month != null) {
                        date.setMonth(month - 1);
                    }
                    if (day != null) {
                        date.setDate(day);
                    }
                    date.setHours(0);
                    date.setMinutes(0);
                    date.setSeconds(0);
                    dspacePolicy.setStartDate(date);
                }
                resourcePolicyService.update(context, dspacePolicy);
                bitstreamService.updateLastModified(context, dspaceBitstream);
            }
        }
        dspaceBitstream = bitstreamService.find(context, dspaceBitstream.getID());
        bitstream = new Bitstream(dspaceBitstream, "String_Node_Str", context);
        context.complete();
    } catch (SQLException e) {
        processException("String_Node_Str" + itemId + "String_Node_Str" + e, context);
    } catch (AuthorizeException e) {
        processException("String_Node_Str" + itemId + "String_Node_Str" + e, context);
    } catch (IOException e) {
        processException("String_Node_Str" + itemId + "String_Node_Str" + e, context);
    } catch (ContextException e) {
        processException("String_Node_Str" + itemId + "String_Node_Str" + e.getMessage(), context);
    } finally {
        processFinally(context);
    }
    log.info("String_Node_Str" + bitstream.getId() + "String_Node_Str" + itemId + "String_Node_Str");
    return bitstream;
}

Output:
                 for (org.dspace.authorize.ResourcePolicy policy : bitstreamsPolicies) {
-                    if (policy.getdSpaceObject().getID() == dspaceBitstream.getID()) {
+                    if (policy.getdSpaceObject().getID().equals(dspaceBitstream.getID())) {
                         policiesToRemove.add(policy);


Input:
private void claimPledges(Project p) {
    log.info("String_Node_Str", p);
    try {
        CompletableFuture<Transaction> tx = Main.wallet.completeContractWithFee(p, pledges);
        tx.handle((t, ex) -> {
            if (ex != null) {
                GuiUtils.crashAlert(ex);
            } else {
                informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str");
            }
            return null;
        });
    } catch (Ex.ValueMismatch e) {
        informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", Coin.valueOf(e.byAmount).toFriendlyString());
    } catch (InsufficientMoneyException e) {
        informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str");
    }
}

Output:
     log.info("String_Node_Str", p);
-    try {
-        CompletableFuture<Transaction> tx = Main.wallet.completeContractWithFee(p, pledges);
-        tx.handle((t, ex) -> {
-            if (ex != null) {
-                GuiUtils.crashAlert(ex);
-            } else {
-                informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str");
-            }
-            return null;
-        });
-    } catch (Ex.ValueMismatch e) {
-        informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", Coin.valueOf(e.byAmount).toFriendlyString());
-    } catch (InsufficientMoneyException e) {
-        informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str");
-    }
+    Main.OverlayUI<RevokeAndClaimWindow> overlay = RevokeAndClaimWindow.openForClaim(p, pledges);
+    overlay.controller.onSuccess = () -> {
+        mode = Mode.OPEN_FOR_PLEDGES;
+        updateGUIForState();
+    };
 }


Input:
public int getPostscriptLevel() {
    Object value = options.get(PS_LEVEL);
    if (value instanceof Integer) {
        return ((Integer) value).intValue();
    }
    return 1;
}

Output:
 public int getPostscriptLevel() {
-    Object value = options.get(PS_LEVEL);
-    if (value instanceof Integer) {
-        return ((Integer) value).intValue();
-    }
-    return 1;
+    return getIntOption(PS_LEVEL, 1);
 }


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ((WordPress) getApplication()).component().inject(this);
    mDispatcher.register(this);
    String pluginName;
    if (savedInstanceState == null) {
        mSite = (SiteModel) getIntent().getSerializableExtra(WordPress.SITE);
        pluginName = getIntent().getStringExtra(KEY_PLUGIN_NAME);
    } else {
        mSite = (SiteModel) savedInstanceState.getSerializable(WordPress.SITE);
        pluginName = savedInstanceState.getString(KEY_PLUGIN_NAME);
    }
    if (mSite == null) {
        ToastUtils.showToast(this, R.string.blog_not_found, Duration.SHORT);
        finish();
        return;
    }
    mPlugin = mPluginStore.getSitePluginByName(mSite, pluginName);
    if (mPlugin == null) {
        ToastUtils.showToast(this, R.string.plugin_not_found, Duration.SHORT);
        finish();
        return;
    }
    if (savedInstanceState == null) {
        mIsActive = mPlugin.isActive();
        mIsAutoUpdateEnabled = mPlugin.isAutoUpdateEnabled();
        mDispatcher.dispatch(PluginActionBuilder.newFetchWporgPluginAction(mPlugin.getSlug()));
    } else {
        mIsConfiguringPlugin = savedInstanceState.getBoolean(KEY_IS_CONFIGURING_PLUGIN);
        mIsUpdatingPlugin = savedInstanceState.getBoolean(KEY_IS_UPDATING_PLUGIN);
        mIsRemovingPlugin = savedInstanceState.getBoolean(KEY_IS_REMOVING_PLUGIN);
        mIsActive = savedInstanceState.getBoolean(KEY_IS_ACTIVE);
        mIsAutoUpdateEnabled = savedInstanceState.getBoolean(KEY_IS_AUTO_UPDATE_ENABLED);
        mIsShowingRemovePluginConfirmationDialog = savedInstanceState.getBoolean(KEY_IS_SHOWING_REMOVE_PLUGIN_CONFIRMATION_DIALOG);
    }
    mPluginInfo = PluginUtils.getPluginInfo(mPluginStore, mPlugin);
    setContentView(R.layout.plugin_detail_activity);
    Toolbar toolbar = findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);
    ActionBar actionBar = getSupportActionBar();
    if (actionBar != null) {
        actionBar.setTitle(mPlugin.getDisplayName());
        actionBar.setHomeButtonEnabled(true);
        actionBar.setDisplayHomeAsUpEnabled(true);
        actionBar.setElevation(0);
    }
    setupViews();
    if (mIsShowingRemovePluginConfirmationDialog) {
        confirmRemovePlugin();
    }
    if (mIsRemovingPlugin) {
        showRemovePluginProgressDialog();
    }
}

Output:
     }
-    mPluginInfo = PluginUtils.getPluginInfo(mPluginStore, mPlugin);
+    mWPOrgPlugin = PluginUtils.getWPOrgPlugin(mPluginStore, mPlugin);
     setContentView(R.layout.plugin_detail_activity);


Input:
public static void setNumberMinMaxToScale(AutoScale sc, Object oMinimum, Object oMaximum, final RunTimeContext rtc, final OneAxis ax) throws ChartException {
    if (oMinimum != null) {
        if (oMinimum instanceof NumberDataElement) {
            sc.setMinimum(new Double(((NumberDataElement) oMinimum).getValue()));
        } else {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { oMinimum, ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
        }
        sc.info.bMinimumFixed(true);
    }
    if (oMaximum != null) {
        if (oMaximum instanceof NumberDataElement) {
            sc.setMaximum(Double.valueOf(((NumberDataElement) oMaximum).getValue()));
        } else {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { oMaximum, ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
        }
        sc.info.bMaximumFixed(true);
    }
    if (sc.info.bMaximumFixed && sc.info.bMinimumFixed) {
        if (((Double) sc.getMinimum()).doubleValue() > ((Double) sc.getMaximum()).doubleValue()) {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { sc.getMinimum(), sc.getMaximum() }, Messages.getResourceBundle(rtc.getULocale()));
        }
    }
}

Output:
 public static void setNumberMinMaxToScale(AutoScale sc, Object oMinimum, Object oMaximum, final RunTimeContext rtc, final OneAxis ax) throws ChartException {
-    if (oMinimum != null) {
-        if (oMinimum instanceof NumberDataElement) {
-            sc.setMinimum(new Double(((NumberDataElement) oMinimum).getValue()));
-        } else {
-            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { oMinimum, ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
-        }
+    if (oMinimum instanceof NumberDataElement) {
+        sc.setMinimum(new Double(((NumberDataElement) oMinimum).getValue()));
         sc.info.bMinimumFixed(true);


Input:
public void run() {
    popupShell.setActive();
    final Menu menu = menuCreator.create(popupShell);
    menu.addListener(SWT.Hide, new Listener() {
        public void handleEvent(Event e) {
            activeShell.setActive();
        }
    });
    menu.addListener(SWT.Show, new Listener() {
        public void handleEvent(Event e) {
            count[0]++;
            if (!menu.isVisible() && count[0] > MAX_ATTEMPTS) {
                Runnable r = new Runnable() {
                    public void run() {
                        System.err.println("String_Node_Str" + MAX_ATTEMPTS + "String_Node_Str");
                        menu.setVisible(false);
                        menu.dispose();
                        System.err.println("String_Node_Str");
                        showMenu(menuCreator, retriesLeft - 1);
                    }
                };
                display.asyncExec(r);
                return;
            }
            Runnable runnable = new Runnable() {
                public void run() {
                    if (!menu.isDisposed() && !menu.isVisible())
                        menu.setVisible(true);
                    else {
                    }
                }
            };
            display.asyncExec(runnable);
        }
    });
    popupShell.addListener(SWT.Deactivate, new Listener() {

        public void handleEvent(Event event) {
            if (!popupShell.isDisposed()) {
                popupShell.close();
                popupShell.dispose();
            }
            menuCreator.getView().setLazyMode(false);
        }
    });
    menu.setVisible(true);
}

Output:
     });
-    popupShell.addListener(SWT.Deactivate, new Listener() {
+    if (!System.getProperty("String_Node_Str").contains("String_Node_Str") && !System.getProperty("String_Node_Str").contains("String_Node_Str")) {
+        popupShell.addListener(SWT.Deactivate, new Listener() {


Input:
public static X509Certificate createClientCert(String name, String email, PublicKey pubKey, PrivateKey caPrivKey, PublicKey caPubKey) throws Exception {
    String issuer = "String_Node_Str";
    Hashtable<DERObjectIdentifier, Object> attrs = new Hashtable<DERObjectIdentifier, Object>();
    Vector<DERObjectIdentifier> order = new Vector<DERObjectIdentifier>();
    attrs.put(X509Principal.C, "String_Node_Str");
    attrs.put(X509Principal.O, "String_Node_Str");
    attrs.put(X509Principal.L, "String_Node_Str");
    attrs.put(X509Principal.CN, name);
    attrs.put(X509Principal.EmailAddress, email);
    order.addElement(X509Principal.C);
    order.addElement(X509Principal.O);
    order.addElement(X509Principal.L);
    order.addElement(X509Principal.CN);
    order.addElement(X509Principal.EmailAddress);
    v3CertGen.reset();
    v3CertGen.setSerialNumber(BigInteger.valueOf(20));
    v3CertGen.setIssuerDN(new X509Principal(issuer));
    v3CertGen.setNotBefore(new Date(System.currentTimeMillis() - 1000L * 60 * 60 * 24 * 30));
    v3CertGen.setNotAfter(new Date(System.currentTimeMillis() + (1000L * 60 * 60 * 24 * 30)));
    v3CertGen.setSubjectDN(new X509Principal(order, attrs));
    v3CertGen.setPublicKey(pubKey);
    v3CertGen.setSignatureAlgorithm("String_Node_Str");
    new NetscapeCertType(NetscapeCertType.PRINTABLE_STRING);
    GeneralNames altnames = new GeneralNames(new GeneralName(GeneralName.rfc822Name, "String_Node_Str"));
    v3CertGen.addExtension(X509Extensions.SubjectAlternativeName, false, altnames);
    X509Certificate cert = v3CertGen.generate(caPrivKey);
    cert.checkValidity(new Date());
    cert.verify(caPubKey);
    return cert;
}

Output:
 public static X509Certificate createClientCert(String name, String email, PublicKey pubKey, PrivateKey caPrivKey, PublicKey caPubKey) throws Exception {
-    String issuer = "String_Node_Str";
+    String issuer = "String_Node_Str" + "String_Node_Str";
     Hashtable<DERObjectIdentifier, Object> attrs = new Hashtable<DERObjectIdentifier, Object>();


Input:
public void createContextObjects(String methodName) {
    if (contextItem != null && !contextItem.isDisposed() && currentEditObject != null && methodName != null) {
        contextItem.removeAll();
        DesignElementHandle handle = (DesignElementHandle) currentEditObject;
        Map argMap = DEUtil.getDesignElementMethodArguments(handle, methodName);
        for (Iterator iter = argMap.keySet().iterator(); iter.hasNext(); ) {
            String argName = (String) iter.next();
            createSubTreeItem(contextItem, argName, IMAGE_METHOD, argName, "String_Node_Str", true);
        }
    }
}

Output:
     if (contextItem != null && !contextItem.isDisposed() && currentEditObject != null && methodName != null) {
-        contextItem.removeAll();
+        removeTreeItem();
         DesignElementHandle handle = (DesignElementHandle) currentEditObject;


Input:
public void setMarshaller(XMLMarshaller marshaller) {
    super.setMarshaller(marshaller);
    attributePrefix = (String) marshaller.getProperty("String_Node_Str");
}

Output:
     super.setMarshaller(marshaller);
-    attributePrefix = (String) marshaller.getProperty("String_Node_Str");
+    attributePrefix = marshaller.getAttributePrefix();
+    namespaces = marshaller.getNamespaceResolver();
+    namespaceAware = marshaller.isNamespaceAware();
 }


Input:
public List<Catalog> fillCatalogs(Connection dbConn, DatabaseMetaData dbJDBCMetadata, IMetadataConnection metaConnection, List<String> catalogFilter) {
    List<Catalog> catalogList = new ArrayList<Catalog>();
    if (dbJDBCMetadata == null) {
        return null;
    }
    if (ConnectionUtils.isPostgresql(dbJDBCMetadata)) {
        return fillPostgresqlCatalogs(metaConnection, dbConn, dbJDBCMetadata, catalogList);
    }
    if (dbConn != null && dbConn.isContextMode()) {
        if (EDatabaseTypeName.MYSQL.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.MSSQL.getProduct().equals(((DatabaseConnection) dbConn).getProductId()) || EDatabaseTypeName.MSSQL05_08.getProduct().equals(((DatabaseConnection) dbConn).getProductId())) {
            IMetadataConnection iMetadataCon = metaConnection;
            if (iMetadataCon == null) {
                iMetadataCon = ConvertionHelper.convert(dbConn);
            }
            if (iMetadataCon != null) {
                String catalogTemp = iMetadataCon.getDatabase();
                if ("String_Node_Str".equals(catalogTemp)) {
                    catalogFilter.clear();
                }
            }
        }
    }
    try {
        if (dbJDBCMetadata.getDatabaseProductName() != null && dbJDBCMetadata.getDatabaseProductName().indexOf(EDatabaseTypeName.ORACLEFORSID.getProduct()) > -1) {
            return catalogList;
        }
        if (ConnectionUtils.isOdbcTeradata(dbJDBCMetadata)) {
            return catalogList;
        }
        ResultSet catalogNames = null;
        if (dbJDBCMetadata instanceof SybaseDatabaseMetaData) {
            catalogNames = ((SybaseDatabaseMetaData) dbJDBCMetadata).getCatalogs(((DatabaseConnection) dbConn).getUsername());
        } else {
            catalogNames = dbJDBCMetadata.getCatalogs();
        }
        List<String> schemaFilterList = new ArrayList<String>();
        if (catalogNames != null) {
            boolean isHive = MetadataConnectionUtils.isHive(dbJDBCMetadata);
            boolean isSybase = MetadataConnectionUtils.isSybase(dbJDBCMetadata);
            while (catalogNames.next()) {
                String catalogName = null;
                try {
                    String temp = null;
                    if (isHive) {
                        temp = MetaDataConstants.TABLE_CAT.name();
                    } else {
                        temp = MetadataConnectionUtils.isOdbcPostgresql(dbJDBCMetadata) ? DatabaseConstant.ODBC_POSTGRESQL_CATALOG_NAME : MetaDataConstants.TABLE_CAT.name();
                    }
                    catalogName = catalogNames.getString(temp);
                    if (!isHive && !MetadataConnectionUtils.isODBCCatalog(catalogName, dbJDBCMetadata)) {
                        continue;
                    }
                } catch (Exception e) {
                    log.warn(e, e);
                    if (dbJDBCMetadata.getDatabaseProductName() != null && dbJDBCMetadata.getDatabaseProductName().toLowerCase().indexOf(DatabaseConstant.POSTGRESQL_PRODUCT_NAME) > -1) {
                        catalogName = "String_Node_Str";
                    }
                }
                if (catalogName != null) {
                    if (!isNullSID(dbConn) && dbConn != null && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.AS400.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_IN_PROGRESS.getDisplayName())) {
                        String databaseOnConnWizard = ((DatabaseConnection) dbConn).getSID();
                        postFillCatalog(catalogList, catalogFilter, schemaFilterList, TalendCWMService.getReadableName(dbConn, databaseOnConnWizard), dbConn);
                        break;
                    } else if (isCreateElement(catalogFilter, catalogName)) {
                        postFillCatalog(catalogList, catalogFilter, schemaFilterList, catalogName, dbConn);
                    }
                }
            }
            catalogNames.close();
            if (!isHive) {
                List<Catalog> removeCatalogList = new ArrayList<Catalog>();
                for (Catalog catalog : catalogList) {
                    List<Schema> schemaList = new ArrayList<Schema>();
                    try {
                        schemaList = fillSchemaToCatalog(dbConn, dbJDBCMetadata, catalog, schemaFilterList);
                        if (!schemaList.isEmpty() && schemaList.size() > 0) {
                            CatalogHelper.addSchemas(schemaList, catalog);
                        }
                    } catch (Throwable e) {
                        removeCatalogList.add(catalog);
                    }
                }
                if (isSybase && catalogFilter != null && !catalogFilter.isEmpty() && catalogFilter.size() > 0 && catalogList.isEmpty() && catalogList.size() == 0) {
                    catalogFilter.clear();
                    return fillCatalogs(dbConn, dbJDBCMetadata, catalogFilter);
                }
                catalogList.removeAll(removeCatalogList);
            }
            Set<MetadataTable> tableSet = ConnectionHelper.getTables(dbConn);
            List<Catalog> replaceCatalogs = new ArrayList<Catalog>();
            List<String> catalogName = new ArrayList<String>();
            for (MetadataTable table : tableSet) {
                EObject eContainer = table.eContainer();
                if (eContainer != null) {
                    if (eContainer instanceof Catalog) {
                        Catalog c = (Catalog) eContainer;
                        String name = c.getName();
                        if (!catalogName.contains(name)) {
                            replaceCatalogs.add(c);
                            catalogName.add(name);
                        }
                    } else if (eContainer instanceof Schema) {
                        EObject parent = eContainer.eContainer();
                        if (parent != null && parent instanceof Catalog) {
                            Catalog c = (Catalog) parent;
                            String name = c.getName();
                            if (!catalogName.contains(name)) {
                                List<Schema> filterSchemas = new ArrayList<Schema>();
                                List<String> schemaName = new ArrayList<String>();
                                List<Schema> schemas = CatalogHelper.getSchemas(c);
                                for (Schema schema : schemas) {
                                    if (schemaFilterList != null) {
                                        if (schemaFilterList.contains(schema.getName())) {
                                            filterSchemas.add(schema);
                                            schemaName.add(schema.getName());
                                        } else if (schema.getOwnedElement() != null && !schema.getOwnedElement().isEmpty()) {
                                            filterSchemas.add(schema);
                                            schemaName.add(schema.getName());
                                        }
                                    }
                                }
                                for (Catalog catalog : catalogList) {
                                    if (catalog.getName().equals(name)) {
                                        boolean added = false;
                                        for (Schema schema : CatalogHelper.getSchemas(catalog)) {
                                            if (!schemaName.contains(schema.getName())) {
                                                filterSchemas.add(schema);
                                                added = true;
                                            }
                                        }
                                        if (added) {
                                            break;
                                        }
                                    }
                                }
                                c.getOwnedElement().clear();
                                CatalogHelper.addSchemas(filterSchemas, c);
                                replaceCatalogs.add(c);
                                catalogName.add(name);
                            }
                        }
                    }
                }
            }
            if (this.isLinked() && !catalogList.isEmpty()) {
                ConnectionHelper.addCatalogs(catalogList, dbConn);
            }
            for (Catalog catalog : replaceCatalogs) {
                List<Catalog> list = new ArrayList<Catalog>();
                String name = catalog.getName();
                Catalog c = (Catalog) ConnectionHelper.getPackage(name, dbConn, Catalog.class);
                if (c != null) {
                    list.add(c);
                    ConnectionHelper.removeCatalogs(list, dbConn);
                    ConnectionHelper.addCatalog(catalog, dbConn);
                } else {
                    ConnectionHelper.addCatalog(catalog, dbConn);
                }
            }
        }
    } catch (SQLException e) {
        log.warn("String_Node_Str", e);
    }
    return catalogList;
}

Output:
                 if (catalogName != null) {
-                    if (!isNullSID(dbConn) && dbConn != null && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.AS400.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_IN_PROGRESS.getDisplayName())) {
+                    if (!isNullSID(dbConn) && dbConn != null && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.AS400.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_IN_PROGRESS.getDisplayName()) && !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_SERVER.getDisplayName()) & !((DatabaseConnection) dbConn).getDatabaseType().equals(EDatabaseTypeName.HSQLDB_WEBSERVER.getDisplayName())) {
                         String databaseOnConnWizard = ((DatabaseConnection) dbConn).getSID();


Input:
public void testModifyFileset() throws Exception {
    ServerConfiguration config = server.getServerConfiguration();
    com.ibm.websphere.simplicity.config.File hazelcastFile = config.getLibraries().getById("String_Node_Str").getNestedFile();
    String originalName = hazelcastFile.getName();
    server.startServer(testName.getMethodName() + "String_Node_Str");
    List<String> session = new ArrayList<>();
    run("String_Node_Str", session);
    run("String_Node_Str", session);
    hazelcastFile.setName("String_Node_Str");
    server.setMarkToEndOfLog();
    server.updateServerConfiguration(config);
    server.waitForConfigUpdateInLogUsingMark(APP_NAMES);
    run("String_Node_Str", session);
    hazelcastFile.setName(originalName);
    server.setMarkToEndOfLog();
    server.updateServerConfiguration(config);
    server.waitForConfigUpdateInLogUsingMark(APP_NAMES);
    run("String_Node_Str", session);
    run("String_Node_Str", session);
    server.stopServer("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
}

Output:
     run("String_Node_Str", session);
-    server.stopServer("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
+    server.stopServer("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
 }


Input:
public static void main(final String[] args) throws ParseException, DataDefenderException, AnonymizerException, IOException, SAXException, TikaException, java.text.ParseException {
    final long startTime = System.currentTimeMillis();
    final ApplicationLock al = new ApplicationLock("String_Node_Str");
    if (al.isAppActive()) {
        log.error("String_Node_Str");
        System.exit(1);
    }
    log.info("String_Node_Str" + Arrays.toString(args));
    final Options options = createOptions();
    final CommandLine line = getCommandLine(options, args);
    List<String> unparsedArgs = line.getArgList();
    if (line.hasOption("String_Node_Str") || args.length == 0 || unparsedArgs.size() < 1) {
        help(options);
        return;
    }
    if (line.hasOption("String_Node_Str")) {
        LogManager.getRootLogger().setLevel(Level.DEBUG);
    } else {
        LogManager.getRootLogger().setLevel(Level.INFO);
    }
    final String cmd = unparsedArgs.get(0);
    unparsedArgs = unparsedArgs.subList(1, unparsedArgs.size());
    List<String> errors = new ArrayList();
    if ("String_Node_Str".equals(cmd)) {
        errors = PropertyCheck.check(cmd, ' ');
        if (errors.size() > 0) {
            displayErrors(errors);
            return;
        }
        final String fileDiscoveryPropertyFile = line.getOptionValue('F', "String_Node_Str");
        final Properties fileDiscoveryProperties = loadProperties(fileDiscoveryPropertyFile);
        final FileDiscoverer discoverer = new FileDiscoverer();
        discoverer.discover(fileDiscoveryProperties);
        return;
    }
    errors = PropertyCheck.checkDtabaseProperties();
    if (errors.size() > 0) {
        displayErrors(errors);
        return;
    }
    final Properties props = loadProperties(line.getOptionValue('P', "String_Node_Str"));
    try (final IDBFactory dbFactory = IDBFactory.get(props)) {
        switch(cmd) {
            case "String_Node_Str":
                errors = PropertyCheck.check(cmd, ' ');
                if (errors.size() > 0) {
                    displayErrors(errors);
                    return;
                }
                final String anonymizerPropertyFile = line.getOptionValue('A', "String_Node_Str");
                final Properties anonymizerProperties = loadProperties(anonymizerPropertyFile);
                final IAnonymizer anonymizer = new DatabaseAnonymizer();
                anonymizer.anonymize(dbFactory, anonymizerProperties, getTableNames(unparsedArgs, anonymizerProperties));
                break;
            case "String_Node_Str":
                errors = PropertyCheck.check(cmd, ' ');
                if (errors.size() > 0) {
                    displayErrors(errors);
                    return;
                }
                final IGenerator generator = new DataGenerator();
                final String generatorPropertyFile = line.getOptionValue('A', "String_Node_Str");
                final Properties generatorProperties = loadProperties(generatorPropertyFile);
                generator.generate(dbFactory, generatorProperties);
                break;
            case "String_Node_Str":
                if (line.hasOption('c')) {
                    errors = PropertyCheck.check(cmd, 'c');
                    if (errors.size() > 0) {
                        displayErrors(errors);
                        return;
                    }
                    final String columnPropertyFile = line.getOptionValue('C', "String_Node_Str");
                    final Properties columnProperties = loadProperties(columnPropertyFile);
                    final ColumnDiscoverer discoverer = new ColumnDiscoverer();
                    discoverer.discover(dbFactory, columnProperties, getTableNames(unparsedArgs, columnProperties));
                    log.debug("String_Node_Str" + line.getOptionValue('R', "String_Node_Str"));
                    if (line.hasOption('r')) {
                        discoverer.createRequirement(line.getOptionValue('R', "String_Node_Str"));
                    }
                } else if (line.hasOption('d')) {
                    errors = PropertyCheck.check(cmd, 'd');
                    if (errors.size() > 0) {
                        displayErrors(errors);
                        return;
                    }
                    final String datadiscoveryPropertyFile = line.getOptionValue('D', "String_Node_Str");
                    final Properties dataDiscoveryProperties = loadProperties(datadiscoveryPropertyFile);
                    final DatabaseDiscoverer discoverer = new DatabaseDiscoverer();
                    discoverer.discover(dbFactory, dataDiscoveryProperties, getTableNames(unparsedArgs, dataDiscoveryProperties));
                    if (line.hasOption('r')) {
                        discoverer.createRequirement(line.getOptionValue('R', "String_Node_Str"));
                    }
                }
                break;
            default:
                help(options);
                break;
        }
    }
    final long endTime = System.currentTimeMillis();
    final NumberFormat formatter = new DecimalFormat("String_Node_Str");
    log.info("String_Node_Str" + formatter.format((endTime - startTime) / 1000d) + "String_Node_Str");
    log.info("String_Node_Str");
}

Output:
                     if (line.hasOption('r')) {
-                        discoverer.createRequirement(line.getOptionValue('R', "String_Node_Str"));
+                        discoverer.createRequirement("String_Node_Str");
                     }


Input:
public boolean execCmd(String user, String privateKeyFile, String hostIP, int sshPort, String command) {
    AuAssert.check(command != null);
    connect(user, privateKeyFile, hostIP, sshPort);
    ChannelExec channel = null;
    BufferedReader in = null;
    logger.info("String_Node_Str");
    try {
        channel = (ChannelExec) session.openChannel("String_Node_Str");
        if (channel != null) {
            logger.debug("String_Node_Str");
            channel.setPty(true);
            channel.setCommand(command);
            in = new BufferedReader(new InputStreamReader(channel.getInputStream()));
            channel.connect();
            if (!channel.isConnected()) {
                logger.error("String_Node_Str");
            }
            StringBuilder buff = new StringBuilder();
            while (true) {
                String line = in.readLine();
                buff.append(line);
                if (channel.isClosed()) {
                    int exitStatus = channel.getExitStatus();
                    logger.debug("String_Node_Str" + exitStatus);
                    logger.debug("String_Node_Str" + buff.toString());
                    if (exitStatus == 0) {
                        return true;
                    }
                    return false;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                }
            }
        } else {
            logger.error("String_Node_Str" + hostIP + "String_Node_Str");
            return false;
        }
    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSchException e) {
        e.printStackTrace();
    } finally {
        if (channel != null && channel.isConnected()) {
            channel.disconnect();
        }
        if (session != null && session.isConnected()) {
            session.disconnect();
        }
        if (in != null) {
            try {
                in.close();
            } catch (IOException e) {
                String errorMsg = "String_Node_Str" + e.getMessage();
                logger.error(errorMsg);
            }
        }
    }
    return false;
}

Output:
             channel.setCommand(command);
-            in = new BufferedReader(new InputStreamReader(channel.getInputStream()));
+            channel.setInputStream(in);
+            channel.setOutputStream(out);
+            bufferedReader = new BufferedReader(new InputStreamReader(channel.getInputStream()));
             channel.connect();


Input:
public void resetPlayer(Player player) {
    if (Settings.clearInventory && (player.getWorld().getName().equalsIgnoreCase(Settings.worldName) || player.getWorld().getName().equalsIgnoreCase(Settings.worldName + "String_Node_Str"))) {
        player.getInventory().clear();
        player.getInventory().setArmorContents(null);
        player.getInventory().setHelmet(null);
        player.getInventory().setChestplate(null);
        player.getInventory().setLeggings(null);
        player.getInventory().setBoots(null);
        player.getEquipment().clear();
    }
    player.setGameMode(GameMode.SURVIVAL);
    if (Settings.resetChallenges) {
        players.resetAllChallenges(player.getUniqueId());
    }
    players.setIslandLevel(player.getUniqueId(), 0);
    players.clearStartIslandRating(player.getUniqueId());
    players.save(player.getUniqueId());
    TopTen.topTenAddEntry(player.getUniqueId(), 0);
    player.updateInventory();
    if (Settings.resetEnderChest) {
        final ItemStack[] items = new ItemStack[player.getEnderChest().getContents().length];
        player.getEnderChest().setContents(items);
    }
    for (PotionEffect effect : player.getActivePotionEffects()) player.removePotionEffect(effect.getType());
}

Output:
     }
-    player.setGameMode(GameMode.SURVIVAL);
+    if (!player.isOp()) {
+        player.setGameMode(GameMode.SURVIVAL);
+    }
     if (Settings.resetChallenges) {


Input:
void rollback() throws IllegalStateException {
    if (state == NO_TXN || state == ROLLED_BACK) {
        throw new IllegalStateException("String_Node_Str");
    }
    state = ROLLING_BACK;
    try {
        List<Future> futures = new ArrayList<Future>(partitions.size());
        for (Integer partitionId : partitions) {
            RollbackOperation op = new RollbackOperation(txnId);
            futures.add(nodeEngine.getOperationService().createInvocationBuilder(SERVICE_NAME, op, partitionId).build().invoke());
        }
        for (Future future : futures) {
            future.get(timeoutMillis, TimeUnit.MILLISECONDS);
        }
    } catch (Throwable e) {
        throw ExceptionUtil.rethrow(e);
    } finally {
        state = ROLLED_BACK;
    }
}

Output:
         for (Future future : futures) {
-            future.get(timeoutMillis, TimeUnit.MILLISECONDS);
+            future.get(5, TimeUnit.MINUTES);
         }


Input:
private IQ createIqResult(IQ iq, String status, String rid) {
    Element record = docFactory.createElement(ELEMENT_NAME, NAMESPACE);
    docFactory.createAttribute(record, "String_Node_Str", "String_Node_Str");
    docFactory.createAttribute(record, "String_Node_Str", status);
    docFactory.createAttribute(record, "String_Node_Str", "String_Node_Str");
    docFactory.createAttribute(record, "String_Node_Str", "String_Node_Str");
    docFactory.createAttribute(record, "String_Node_Str", rid);
    IQ result = IQ.createResultIQ(iq);
    result.addExtension(new PacketExtension(record));
    return result;
}

Output:
     IQ result = IQ.createResultIQ(iq);
-    result.addExtension(new PacketExtension(record));
+    Element record = docFactory.createElement(ELEMENT_NAME, NAMESPACE);
+    record.add(docFactory.createAttribute(record, "String_Node_Str", status));
+    record.add(docFactory.createAttribute(record, "String_Node_Str", rid));
+    result.setChildElement(record);
     return result;