Input:
public void testUnsupportedRequiredExtension() throws Exception {
    final DirCache dc = new DirCache(pathOf("String_Node_Str"));
    try {
        dc.read();
        fail("String_Node_Str");
    } catch (CorruptObjectException err) {
        assertEquals("String_Node_Str" + "String_Node_Str", err.getMessage());
    }
}

Output:
 public void testUnsupportedRequiredExtension() throws Exception {
-    final DirCache dc = new DirCache(pathOf("String_Node_Str"));
+    final DirCache dc = new DirCache(pathOf("String_Node_Str"), FS.DETECTED);
     try {


Input:
public void run() {
    RAM memory = Emulator.computer.memory;
    Emulator.computer.pause();
    int pos = memory.readWordRaw(startingAddressPointer);
    for (Line line : lines) {
        int nextPos = pos + line.getLength() + 1;
        memory.write(pos++, (byte) (nextPos & 0x0ff), false, true);
        memory.write(pos++, (byte) (nextPos >> 8 & 0x0ff), false, true);
        memory.write(pos++, (byte) (line.getNumber() & 0x0ff), false, true);
        memory.write(pos++, (byte) (line.getNumber() >> 8 & 0x0ff), false, true);
        boolean isFirst = true;
        for (Command command : line.getCommands()) {
            if (!isFirst) {
                memory.write(pos++, (byte) ':', false, true);
            }
            isFirst = false;
            for (Command.ByteOrToken part : command.parts) {
                memory.write(pos++, part.getByte(), false, true);
            }
        }
        memory.write(pos++, (byte) 0, false, true);
    }
    memory.write(pos++, (byte) 0, false, true);
    memory.write(pos++, (byte) 0, false, true);
    memory.write(pos++, (byte) 0, false, true);
    memory.write(pos++, (byte) 0, false, true);
    Emulator.computer.resume();
}

Output:
         int nextPos = pos + line.getLength() + 1;
-        memory.write(pos++, (byte) (nextPos & 0x0ff), false, true);
-        memory.write(pos++, (byte) (nextPos >> 8 & 0x0ff), false, true);
-        memory.write(pos++, (byte) (line.getNumber() & 0x0ff), false, true);
-        memory.write(pos++, (byte) (line.getNumber() >> 8 & 0x0ff), false, true);
+        memory.writeWord(pos, nextPos, false, true);
+        pos += 2;
+        memory.writeWord(pos, line.getNumber(), false, true);
+        pos += 2;
         boolean isFirst = true;


Input:
public AcceptorEventHandler start(String hostPortDescription, final AssetTree asset, WireType wireType) throws IOException {
    eg.start();
    AcceptorEventHandler eah = new AcceptorEventHandler(hostPortDescription, () -> new EngineWireHandler(wireType, asset, isClosed), VanillaSessionDetails::new);
    eg.addHandler(eah);
    this.eah = eah;
    return eah;
}

Output:
     eg.start();
-    AcceptorEventHandler eah = new AcceptorEventHandler(hostPortDescription, () -> new EngineWireHandler(wireType, asset, isClosed), VanillaSessionDetails::new);
+    AcceptorEventHandler eah = new AcceptorEventHandler(hostPortDescription, () -> new EngineWireHandler(wireType, asset), VanillaSessionDetails::new);
     eg.addHandler(eah);


Input:
public GetUserSettingsResponse getUserSettings(String userSmtpAddress, UserSettingName... userSettingNames) throws Exception {
    List<UserSettingName> requestedSettings = new ArrayList<UserSettingName>();
    requestedSettings.addAll(Arrays.asList(userSettingNames));
    if (userSmtpAddress == null || userSmtpAddress.isEmpty()) {
        throw new ServiceValidationException(Strings.InvalidAutodiscoverSmtpAddress);
    }
    if (requestedSettings.size() == 0) {
        throw new ServiceValidationException(Strings.InvalidAutodiscoverSettingsCount);
    }
    if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
        return this.internalGetLegacyUserSettings(userSmtpAddress, requestedSettings);
    } else {
        return this.internalGetSoapUserSettings(userSmtpAddress, requestedSettings);
    }
}

Output:
     if (userSmtpAddress == null || userSmtpAddress.isEmpty()) {
-        throw new ServiceValidationException(Strings.InvalidAutodiscoverSmtpAddress);
+        throw new ServiceValidationException("String_Node_Str");
     }


Input:
private void assertProjectInWorkingSet(String workingSetName, String projectName) {
    IWorkingSetManager workingSetManager = PlatformUI.getWorkbench().getWorkingSetManager();
    IWorkingSet workingSet = workingSetManager.getWorkingSet(workingSetName);
    IAdaptable[] elements = workingSet.getElements();
    assertEquals("String_Node_Str", 1, elements.length);
    IProject project = (IProject) elements[0].getAdapter(IProject.class);
    assertEquals("String_Node_Str", projectName, project.getName());
}

Output:
     assertEquals("String_Node_Str", 1, elements.length);
-    IProject project = (IProject) elements[0].getAdapter(IProject.class);
+    IProject project = Utils.getAdapter(elements[0], IProject.class);
     assertEquals("String_Node_Str", projectName, project.getName());


Input:
public void startRequest(DIRRequest rq) {
    try {
        final service_registerRequest request = (service_registerRequest) rq.getRequestMessage();
        final ServiceRegistry reg = request.getService();
        byte[] data = database.directLookup(DIRRequestDispatcher.DB_NAME, DIRRequestDispatcher.INDEX_ID_SERVREG, reg.getUuid().getBytes());
        long currentVersion = 0;
        if (data != null) {
            ServiceRegistry dbData = new ServiceRegistry();
            ReusableBuffer buf = ReusableBuffer.wrap(data);
            dbData.deserialize(buf);
            currentVersion = dbData.getVersion();
        }
        if (reg.getVersion() != currentVersion) {
            rq.sendException(new ConcurrentModificationException());
            return;
        }
        currentVersion++;
        reg.setVersion(currentVersion);
        reg.getData().add(new KeyValuePair("String_Node_Str", Long.toString(System.currentTimeMillis() / 1000l)));
        ONCRPCBufferWriter writer = new ONCRPCBufferWriter(reg.calculateSize());
        reg.serialize(writer);
        byte[] newData = writer.getBuffers().get(0).array();
        writer.freeBuffers();
        BabuDBInsertGroup ig = database.createInsertGroup(DIRRequestDispatcher.DB_NAME);
        ig.addInsert(DIRRequestDispatcher.INDEX_ID_SERVREG, reg.getUuid().getBytes(), newData);
        database.directInsert(ig);
        service_registerResponse response = new service_registerResponse(currentVersion);
        rq.sendSuccess(response);
    } catch (BabuDBException ex) {
        Logging.logMessage(Logging.LEVEL_ERROR, this, ex);
        rq.sendInternalServerError(ex);
    } catch (Throwable th) {
        Logging.logMessage(Logging.LEVEL_ERROR, this, th);
        rq.sendInternalServerError(th);
    }
}

Output:
         reg.getData().add(new KeyValuePair("String_Node_Str", Long.toString(System.currentTimeMillis() / 1000l)));
-        ONCRPCBufferWriter writer = new ONCRPCBufferWriter(reg.calculateSize());
+        final int dataSize = reg.calculateSize();
+        ONCRPCBufferWriter writer = new ONCRPCBufferWriter(dataSize);
         reg.serialize(writer);


Input:
private static void parseMetadata(XmlPullParser parser, String metadataType, Map<String, Parameter> parameters) throws XmlPullParserException, IOException {
    boolean parsing = false;
    int eventType = parser.getEventType();
    while (eventType != XmlPullParser.END_DOCUMENT) {
        switch(eventType) {
            case XmlPullParser.START_TAG:
                {
                    String name = parser.getName();
                    if (metadataType.equals(name)) {
                        parsing = true;
                    } else if (parsing) {
                        Parameter parameter = parameters.get(name);
                        if (parameter != null)
                            addMetaDataProperty(parameter, name, parser.nextText());
                    }
                    break;
                }
            case XmlPullParser.END_TAG:
                {
                    String name = parser.getName();
                    if (metadataType.equals(name)) {
                        return;
                    }
                    break;
                }
        }
        eventType = parser.next();
    }
}

Output:
                     } else if (parsing) {
-                        Parameter parameter = parameters.get(name);
-                        if (parameter != null)
+                        if (parameter == null) {
+                            parameter = parameters.get(name);
+                        } else {
                             addMetaDataProperty(parameter, name, parser.nextText());


Input:
public PhysicalNode getPhysicalNode(String cmd, byte[] key) {
    int slot = 0;
    if (key != null) {
        slot = ClusterCRC16Util.getSlot(key, false);
    }
    PhysicalNode node = getPhysicalNodeBySlot(slot);
    return node;
}

Output:
     if (key != null) {
-        slot = ClusterCRC16Util.getSlot(key, false);
+        slot = ClusterCRC16Util.getSlot(key);
     }


Input:
public void logout() throws paloexception {
    List<NameValuePair> qparams = new ArrayList<NameValuePair>();
    qparams.add(new BasicNameValuePair("String_Node_Str", this.strToken));
    try {
        HttpEntity entity = sendToServer(qparams, "String_Node_Str");
        CsvReader csv = new CsvReader(entity.getContent(), Charset.forName("String_Node_Str"));
        csv.setDelimiter(';');
        csv.setTextQualifier('"');
        csv.readRecord();
        csv.close();
        entity.consumeContent();
    } catch (Exception e) {
        throw new paloexception(e.getMessage());
    }
}

Output:
         HttpEntity entity = sendToServer(qparams, "String_Node_Str");
-        CsvReader csv = new CsvReader(entity.getContent(), Charset.forName("String_Node_Str"));
-        csv.setDelimiter(';');
-        csv.setTextQualifier('"');
-        csv.readRecord();
+        CSVReader csv = new CSVReader(entity.getContent(), "String_Node_Str", "String_Node_Str", ';', '"', '\\', false, 0);
+        csv.readNext();
         csv.close();


Input:
protected static List<IComponent> getRelatedComponents(final IComponentsFactory compFac) {
    Set<IComponent> componentSet = null;
    if (TalendEditorPaletteFactory.filter != null && 0 < TalendEditorPaletteFactory.filter.trim().length()) {
        Map<String, Map<String, Set<IComponent>>> componentNameMap = compFac.getComponentNameMap();
        String filterString = TalendEditorPaletteFactory.filter.trim();
        if (componentNameMap != null) {
            Map<String, Set<IComponent>> map = componentNameMap.get(filterString.toLowerCase());
            if (map != null) {
                Collection<Set<IComponent>> componentSets = map.values();
                Iterator<Set<IComponent>> componentSetIter = componentSets.iterator();
                while (componentSetIter.hasNext()) {
                    componentSet = new HashSet<IComponent>(componentSetIter.next());
                }
            }
        }
        if (componentSet == null && componentNameMap != null) {
            componentSet = new HashSet<IComponent>();
            addComponentsByNameFilter(compFac, componentSet);
            boolean shouldSearchFromHelpAPI = PaletteSettingsPreferencePage.isPaletteSearchFromHelp();
            if (shouldSearchFromHelpAPI) {
                Set<String> componentNames = getRelatedComponentNamesFromHelp(filterString);
                if (componentNames != null && 0 < componentNames.size()) {
                    Iterator<String> nameIter = componentNames.iterator();
                    while (nameIter.hasNext()) {
                        String componentName = nameIter.next();
                        Map<String, Set<IComponent>> map = componentNameMap.get(componentName.toLowerCase());
                        if (map == null) {
                            continue;
                        }
                        Set<IComponent> findedComponents = map.get(componentName);
                        if (findedComponents != null && !findedComponents.isEmpty()) {
                            componentSet.addAll(findedComponents);
                        }
                    }
                }
            }
            if (componentSet.isEmpty()) {
                componentSet = null;
            }
        }
    } else {
        componentSet = compFac.getComponents();
    }
    List<IComponent> relatedComponents = null;
    if (componentSet == null) {
        relatedComponents = new LinkedList<IComponent>();
    } else {
        relatedComponents = new LinkedList<IComponent>(componentSet);
    }
    return relatedComponents;
}

Output:
                 while (componentSetIter.hasNext()) {
-                    componentSet = new HashSet<IComponent>(componentSetIter.next());
+                    componentSet.addAll(componentSetIter.next());
                 }


Input:
public static int[] tokenizeCleanAndLinkify(final char[] rawArr) {
    final int[] passTwoResult = tokenizeAndClean(rawArr);
    final int passTwoResultLength = passTwoResult.length;
    final int[] passThreeResult = new int[rawArr.length * 3];
    int passThreeResultLength = 0;
    boolean ready = true;
    for (int i = 0; i < passTwoResultLength; i++) {
        final int token = passTwoResult[i];
        switch(token) {
            case TOKEN_BRACKET_SQUARE_OPEN:
            case TOKEN_PAREN_OPEN:
                passThreeResult[passThreeResultLength++] = token;
                ready = false;
                break;
            case TOKEN_BRACKET_SQUARE_CLOSE:
            case TOKEN_PAREN_CLOSE:
            case ' ':
                passThreeResult[passThreeResultLength++] = token;
                ready = true;
                break;
            case 'h':
            case 'w':
                if (ready) {
                    final int linkStartType = getLinkStartType(passThreeResult, i, passThreeResultLength);
                    if (linkStartType >= 0) {
                        int linkEndPos = i + linkPrefixes[linkStartType].length;
                    } else {
                        passThreeResult[passThreeResultLength++] = token;
                    }
                } else {
                    passThreeResult[passThreeResultLength++] = token;
                }
                ready = false;
                break;
            case 'r':
            case 'u':
            case '/':
                if (ready) {
                    final int linkStartType = getRedditLinkStartType(passThreeResult, i, passThreeResultLength);
                    if (linkStartType >= 0) {
                        final int linkStartPos = i;
                        final int linkPrefixEndPos = linkPrefixes_reddit[linkStartType].length + linkStartPos;
                        int linkEndPos = linkPrefixEndPos;
                        while (linkEndPos < passTwoResultLength) {
                            final int lToken = passThreeResult[linkEndPos];
                            final boolean isValidChar = (lToken >= 'a' && lToken <= 'z') || (lToken >= 'A' && lToken <= 'Z') || (lToken >= '0' && lToken <= '9') || lToken == '_' || lToken == '+' || lToken == '-';
                            linkEndPos++;
                        }
                        if (linkEndPos - linkPrefixEndPos > 2) {
                            final int[] reverted = revert(passTwoResult, linkStartPos, linkEndPos);
                            passThreeResult[passThreeResultLength++] = TOKEN_BRACKET_SQUARE_OPEN;
                            System.arraycopy(reverted, 0, passThreeResult, passThreeResultLength, reverted.length);
                            passThreeResultLength += reverted.length;
                            passThreeResult[passThreeResultLength++] = TOKEN_BRACKET_SQUARE_CLOSE;
                            passThreeResult[passThreeResultLength++] = TOKEN_PAREN_OPEN;
                            System.arraycopy(reverted, 0, passThreeResult, passThreeResultLength, reverted.length);
                            passThreeResultLength += reverted.length;
                            passThreeResult[passThreeResultLength++] = TOKEN_PAREN_CLOSE;
                            i = linkEndPos;
                        } else {
                            passThreeResult[passThreeResultLength++] = token;
                        }
                    } else {
                        passThreeResult[passThreeResultLength++] = token;
                    }
                } else {
                    passThreeResult[passThreeResultLength++] = token;
                }
                ready = false;
                break;
            default:
                ready = token < 0 || (!Character.isAlphabetic(token) && !Character.isDigit(token) && token != '/');
                passThreeResult[passThreeResultLength++] = token;
                break;
        }
    }
    return Arrays.copyOf(passThreeResult, passThreeResultLength);
}

Output:
                 if (ready) {
-                    final int linkStartType = getLinkStartType(passThreeResult, i, passThreeResultLength);
+                    final int linkStartType = getLinkStartType(passTwoResult, i, passTwoResultLength);
                     if (linkStartType >= 0) {


Input:
private void restoreDividerLocations() {
    Rectangle rec = MageFrame.getDesktop().getBounds();
    if (rec != null) {
        String size = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_MAGE_PANEL_LAST_SIZE, null);
        StringBuilder sb = new StringBuilder(Double.toString(rec.getWidth())).append("String_Node_Str").append(Double.toString(rec.getHeight()));
        if (size != null && size.equals(sb.toString())) {
            String location = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_TOURNAMENT_DIVIDER_LOCATION_1, null);
            if (location != null && jSplitPane1 != null) {
                jSplitPane1.setDividerLocation(Integer.parseInt(location));
            }
            location = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_TOURNAMENT_DIVIDER_LOCATION_2, null);
            if (location != null && jSplitPane2 != null) {
                jSplitPane2.setDividerLocation(Integer.parseInt(location));
            }
        }
    }
}

Output:
         String size = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_MAGE_PANEL_LAST_SIZE, null);
-        StringBuilder sb = new StringBuilder(Double.toString(rec.getWidth())).append("String_Node_Str").append(Double.toString(rec.getHeight()));
-        if (size != null && size.equals(sb.toString())) {
+        String sb = Double.toString(rec.getWidth()) + "String_Node_Str" + Double.toString(rec.getHeight());
+        if (size != null && size.equals(sb)) {
             String location = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_TOURNAMENT_DIVIDER_LOCATION_1, null);


Input:
public void itemClick(final PartnerInfo bean) {
    if (bean.getInfo() != null && bean.getInfo().length() > 0) {
        View custom = LayoutInflater.from(getActivity()).inflate(R.layout.main_recommendation_dialog_view, null, false);
        TextView part1 = (TextView) custom.findViewById(R.id.part1);
        int pointIndex = bean.getInfo().indexOf("String_Node_Str") + 1;
        part1.setText(bean.getInfo().substring(0, pointIndex));
        TextView part2 = (TextView) custom.findViewById(R.id.part2);
        part2.setText(bean.getInfo().substring(pointIndex));
        ((ImageView) custom.findViewById(R.id.image)).setImageResource(bean.getIcon());
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setTitle(warning_partner);
        builder.setView(custom);
        builder.setPositiveButton(ok, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                if (bean.getUri() != null) {
                    Intent intent = new Intent(Intent.ACTION_VIEW);
                    intent.setData(Uri.parse(bean.getUri()));
                    startActivity(intent);
                }
            }
        });
        builder.setNegativeButton(cancel, null);
        AlertDialog dialog = builder.create();
        dialog.show();
    } else {
        if (bean.getUri() != null) {
            Intent i = new Intent(Intent.ACTION_VIEW);
            i.setData(Uri.parse(bean.getUri()));
            startActivity(i);
        }
    }
}

Output:
         builder.setNegativeButton(cancel, null);
-        AlertDialog dialog = builder.create();
-        dialog.show();
+        alertDialog = builder.create();
+        alertDialog.show();
     } else {


Input:
public int compare(Object alpha, Object beta) {
    Object alphaProperty = null;
    if (alpha != null)
        alphaProperty = beanProperty.get(alpha);
    Object betaProperty = null;
    if (beta != null)
        alphaProperty = beanProperty.get(beta);
    return propertyComparator.compare(alphaProperty, betaProperty);
}

Output:
     if (beta != null)
-        alphaProperty = beanProperty.get(beta);
+        betaProperty = beanProperty.get(beta);
     return propertyComparator.compare(alphaProperty, betaProperty);


Input:
private boolean isOverThreshold(AttributeChange diff) {
    final Comparison comparison = diff.getMatch().getComparison();
    final EObject left = MatchUtil.getContainer(comparison, diff);
    final EObject right = MatchUtil.getOriginContainer(comparison, diff);
    if (left instanceof Bounds && right instanceof Bounds) {
        final int leftX = ((Bounds) left).getX();
        final int leftY = ((Bounds) left).getY();
        final int rightX = ((Bounds) right).getX();
        final int rightY = ((Bounds) right).getY();
        final int deltaX = Math.abs(leftX - rightX);
        final int deltaY = Math.abs(leftY - rightY);
        final int threshold = configuration.getMoveThreshold();
        return deltaX + deltaY > threshold;
    }
    return false;
}

Output:
         final int deltaY = Math.abs(leftY - rightY);
-        final int threshold = configuration.getMoveThreshold();
+        int threshold = 0;
+        if (configuration != null) {
+            threshold = configuration.getMoveThreshold();
+        }
         return deltaX + deltaY > threshold;


Input:
private void drawSeparationLines(Canvas canvas) {
    final PieChartData data = dataProvider.getPieChartData();
    if (data.getValues().size() < 2) {
        return;
    }
    final float sliceScale = 360f / maxSum;
    float lastAngle = rotation;
    final float circleRadius = originCircleOval.width() / 2f;
    final int sliceSpacing = ChartUtils.dp2px(density, data.getSlicesSpacing());
    separationLinesPaint.setStrokeWidth(sliceSpacing);
    for (SliceValue sliceValue : data.getValues()) {
        final float angle = Math.abs(sliceValue.getValue()) * sliceScale;
        sliceVector.set((float) (Math.cos(Math.toRadians(lastAngle))), (float) (Math.sin(Math.toRadians(lastAngle))));
        normalizeVector(sliceVector);
        float x1 = sliceVector.x * (circleRadius + touchAdditional) + originCircleOval.centerX();
        float y1 = sliceVector.y * (circleRadius + touchAdditional) + originCircleOval.centerY();
        if (sliceSpacing > 0) {
            canvas.drawLine(originCircleOval.centerX(), originCircleOval.centerY(), x1, y1, separationLinesPaint);
        }
        lastAngle += angle;
    }
}

Output:
         float y1 = sliceVector.y * (circleRadius + touchAdditional) + originCircleOval.centerY();
-        if (sliceSpacing > 0) {
-            canvas.drawLine(originCircleOval.centerX(), originCircleOval.centerY(), x1, y1, separationLinesPaint);
-        }
+        canvas.drawLine(originCircleOval.centerX(), originCircleOval.centerY(), x1, y1, separationLinesPaint);
         lastAngle += angle;


Input:
void addGuard(WarningsGuard guard) {
    if (guard instanceof ComposeWarningsGuard) {
        addGuards(((ComposeWarningsGuard) guard).guards);
    } else {
        int index = Collections.binarySearch(this.guards, guard, guardComparator);
        if (index < 0) {
            index = -index - 1;
        }
        this.guards.add(index, guard);
    }
}

Output:
     if (guard instanceof ComposeWarningsGuard) {
-        addGuards(((ComposeWarningsGuard) guard).guards);
+        addGuards(Iterables.reverse(((ComposeWarningsGuard) guard).guards));
     } else {


Input:
public String getUniqueName() {
    return Util.quoteMdxIdentifier(name);
}

Output:
 public String getUniqueName() {
-    return Util.quoteMdxIdentifier(name);
+    return uniqueName;
 }


Input:
public JobStatus finalizeJob(final String id, final int exitCode) throws GenieException {
    final Job job = this.jobRepo.findOne(id);
    if (job == null) {
        throw new GenieNotFoundException("String_Node_Str" + id + "String_Node_Str");
    }
    job.setExitCode(exitCode);
    if (job.getStatus() != null && job.getStatus() != JobStatus.KILLED) {
        if (exitCode != ProcessStatus.SUCCESS.getExitCode()) {
            LOG.error("String_Node_Str" + exitCode);
            String errMsg;
            try {
                errMsg = ProcessStatus.parse(exitCode).getMessage();
            } catch (final GenieException ge) {
                errMsg = "String_Node_Str";
            }
            job.setJobStatus(JobStatus.FAILED, "String_Node_Str" + errMsg);
            this.stats.incrGenieFailedJobs();
        } else {
            job.setJobStatus(JobStatus.SUCCEEDED, "String_Node_Str");
            this.stats.incrGenieSuccessfulJobs();
        }
        if (!job.isDisableLogArchival()) {
            job.setArchiveLocation(NetUtil.getArchiveURI(job.getId()));
        }
        job.setUpdated(new Date());
        return job.getStatus();
    } else {
        LOG.debug("String_Node_Str" + job.getId());
        return JobStatus.KILLED;
    }
}

Output:
     job.setExitCode(exitCode);
-    if (job.getStatus() != null && job.getStatus() != JobStatus.KILLED) {
+    if (exitCode == ProcessStatus.JOB_KILLED.getExitCode()) {
+        LOG.debug("String_Node_Str");
+        job.setJobStatus(JobStatus.KILLED, "String_Node_Str");
+        return JobStatus.KILLED;
+    } else {
         if (exitCode != ProcessStatus.SUCCESS.getExitCode()) {


Input:
public void testSaveXMLorJSONWithBinaryContent() throws Exception {
    RepositoryUser systemUser = getSystemUser();
    ContentObject contentObject = createContentObject(systemUser, "String_Node_Str", true);
    BinaryChannel logoBinaryChannel = loadManagedBinaryChannel(logo, "String_Node_Str");
    BinaryProperty imageProperty = (BinaryProperty) contentObject.getCmsProperty("String_Node_Str");
    imageProperty.addSimpleTypeValue(logoBinaryChannel);
    contentObject = contentService.save(contentObject, false, true, null);
    addEntityToBeDeletedAfterTestIsFinished(contentObject);
    String xml = contentObject.xml(false, true);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, xml, logo, "String_Node_Str", null);
    String json = contentObject.json(false, true);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, json, logo, "String_Node_Str", null);
    xml = contentService.getContentObject(contentObject.getId(), ResourceRepresentationType.XML, FetchLevel.FULL, CacheRegion.NONE, null, true);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, xml, logo, "String_Node_Str", null);
    json = contentService.getContentObject(contentObject.getId(), ResourceRepresentationType.JSON, FetchLevel.FULL, CacheRegion.NONE, null, true);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, json, logo, "String_Node_Str", null);
    Map<String, byte[]> binaryContent = new HashMap<String, byte[]>();
    String imageURL = logoBinaryChannel.buildResourceApiURL(null, null, null, null, null, false, false);
    byte[] contentCopy = Arrays.copyOf(logoBinaryChannel.getContent(), logoBinaryChannel.getContent().length);
    binaryContent.put(imageURL, contentCopy);
    logoBinaryChannel.setContent(null);
    xml = contentObject.xml(false, false);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, xml, logo, "String_Node_Str", binaryContent);
    json = contentObject.json(false, false);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, json, logo, "String_Node_Str", binaryContent);
    xml = contentObject.xml(false, false).replaceAll(Pattern.quote(imageURL), "String_Node_Str");
    binaryContent.put("String_Node_Str", contentCopy);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, xml, logo, "String_Node_Str", binaryContent);
    json = contentObject.json(false, false).replaceAll(Pattern.quote(imageURL), "String_Node_Str");
    binaryContent.put("String_Node_Str", contentCopy);
    contentObject = saveAndAssertBinaryContentIsSaved(contentObject, json, logo, "String_Node_Str", binaryContent);
}

Output:
     RepositoryUser systemUser = getSystemUser();
-    ContentObject contentObject = createContentObject(systemUser, "String_Node_Str", true);
+    ContentObject contentObject = createContentObjectForType(TEST_CONTENT_TYPE, systemUser, "String_Node_Str", true);
     BinaryChannel logoBinaryChannel = loadManagedBinaryChannel(logo, "String_Node_Str");


Input:
public ServerResponse<String> checkValid(String str, String type) {
    if (StringUtils.isNotBlank(type)) {
        if (Const.USERNAME.equals(type)) {
            int userCount = userMapper.checkUserName(str);
            if (userCount > 0) {
                return ServerResponse.createByErorrMessage("String_Node_Str");
            }
        }
        if (Const.EMAIL.equals(type)) {
            int emailCount = userMapper.checkEmail(str);
            if (emailCount > 0) {
                return ServerResponse.createByErorrMessage("String_Node_Str");
            }
        }
    } else {
        return ServerResponse.createByErorrMessage("String_Node_Str");
    }
    return ServerResponse.createBySuccessMessage("String_Node_Str");
}

Output:
             if (userCount > 0) {
-                return ServerResponse.createByErorrMessage("String_Node_Str");
+                return ServerResponse.createByErrorMessage("String_Node_Str");
             }


Input:
public void lovesChanged(MidasUser u, Playlist oldP, Playlist newP) throws IOException {
    long uid = u.getUserId();
    Set<String> curArtists = new HashSet<String>();
    for (String sid : oldP.getStreamIds()) {
        Stream s = streamDao.getStream(sid);
        curArtists.add(s.getArtist());
    }
    List<String> newArtists = new ArrayList<String>();
    for (String sid : newP.getStreamIds()) {
        if (!oldP.getStreamIds().contains(sid)) {
            Stream s = streamDao.getStream(sid);
            String artist = s.getArtist();
            if (!curArtists.contains(artist))
                newArtists.add(artist);
        }
    }
    if (newArtists.size() > 0) {
        List<String> al = new ArrayList<String>(newArtists);
        Collections.sort(al);
        int msgSizeLimit = 140;
        String okMsg = "String_Node_Str" + numItems(newArtists, "String_Node_Str") + "String_Node_Str";
        String url = appConfig.getInitParam("String_Node_Str") + "String_Node_Str" + Long.toHexString(uid) + "String_Node_Str";
        for (int i = 0; i < newArtists.size(); i++) {
            StringBuffer sb = new StringBuffer("String_Node_Str");
            for (int j = 0; j <= i; j++) {
                if (j != 0)
                    sb.append("String_Node_Str");
                sb.append(newArtists.get(j));
            }
            if (i < (newArtists.size() - 1)) {
                int numOtherArtists = newArtists.size() - (i + 1);
                sb.append("String_Node_Str").append(numItems(numOtherArtists, "String_Node_Str"));
            }
            sb.append("String_Node_Str");
            String msg = sb.toString();
            if ((msg.length() + url.length()) <= msgSizeLimit)
                okMsg = msg;
            else
                break;
        }
        MidasUserConfig muc = userConfigDao.getUserConfig(u.getUserId());
        if (muc != null) {
            if (muc.getItem("String_Node_Str") != null) {
                String fbStr = muc.getItem("String_Node_Str");
                if (fbStr == null || Boolean.valueOf(fbStr))
                    facebook.postSpecialPlaylistToFacebook(muc, uid, "String_Node_Str", okMsg);
            }
            if (muc.getItem("String_Node_Str") != null) {
                String twitStr = muc.getItem("String_Node_Str");
                if (twitStr == null || Boolean.valueOf(twitStr))
                    twitter.postSpecialPlaylistToTwitter(muc, uid, "String_Node_Str", okMsg);
            }
        }
        event.specialPlaylistPosted(u, uid, "String_Node_Str");
        notification.lovesAdded(u, al);
    }
}

Output:
     }
-    List<String> newArtists = new ArrayList<String>();
+    Set<String> newArtists = new HashSet<String>();
     for (String sid : newP.getStreamIds()) {


Input:
public Single<Response<ResponseBody>> downloadWmRelease(final int id, Context context) {
    final WhatManagerService wm = WhatManagerService.Creator.newWMApiService(mPreferencesHelper.getWmHost(), context);
    return wm.login(mPreferencesHelper.getWmUser(), mPreferencesHelper.getWmPassword()).flatMap(new Function<Response<ResponseBody>, Single<Response<ResponseBody>>>() {

        public Single<Response<ResponseBody>> apply(Response<ResponseBody> response) throws Exception {
            return wm.addTorrent(id);
        }
    });
}

Output:
 public Single<Response<ResponseBody>> downloadWmRelease(final int id, Context context) {
-    final WhatManagerService wm = WhatManagerService.Creator.newWMApiService(mPreferencesHelper.getWmHost(), context);
-    return wm.login(mPreferencesHelper.getWmUser(), mPreferencesHelper.getWmPassword()).flatMap(new Function<Response<ResponseBody>, Single<Response<ResponseBody>>>() {
+    try {
+        final WhatManagerService wm = WhatManagerService.Creator.newWMApiService(mPreferencesHelper.getWmHost(), context);
+        return wm.login(mPreferencesHelper.getWmUser(), mPreferencesHelper.getWmPassword()).flatMap(new Function<Response<ResponseBody>, Single<Response<ResponseBody>>>() {


Input:
public void readExternal(Element element) throws InvalidDataException {
    super.readExternal(element);
    environment = JDOMExternalizer.readString(element, "String_Node_Str");
    specsToExecute = JDOMExternalizer.readString(element, "String_Node_Str");
    tags = JDOMExternalizer.readString(element, "String_Node_Str");
    parallelNodes = JDOMExternalizer.readString(element, "String_Node_Str");
    execInParallel = JDOMExternalizer.readBoolean(element, "String_Node_Str");
    programParameters.setProgramParameters(JDOMExternalizer.readString(element, "String_Node_Str"));
    programParameters.setWorkingDirectory(JDOMExternalizer.readString(element, "String_Node_Str"));
    this.moduleName = JDOMExternalizer.readString(element, "String_Node_Str");
    HashMap<String, String> envMap = new HashMap<String, String>();
    JDOMExternalizer.readMap(element, envMap, "String_Node_Str", "String_Node_Str");
    programParameters.setEnvs(envMap);
    rowsRange = JDOMExternalizer.readString(element, "String_Node_Str");
}

Output:
     this.moduleName = JDOMExternalizer.readString(element, "String_Node_Str");
-    HashMap<String, String> envMap = new HashMap<String, String>();
+    HashMap<String, String> envMap = new HashMap<>();
     JDOMExternalizer.readMap(element, envMap, "String_Node_Str", "String_Node_Str");


Input:
private ConstructorInjections constructorInjections() {
    final Map<Parameter, BiFunction<? super S, ? super MappingContext<? super S>, ?>> injections = new HashMap<Parameter, BiFunction<? super S, ? super MappingContext<? super S>, ?>>();
    final List<FieldMapper<S, T>> fieldMappers = new ArrayList<FieldMapper<S, T>>();
    propertyMappingsBuilder.forEachConstructorProperties(new ForEachCallBack<PropertyMapping<T, ?, K, FieldMapperColumnDefinition<K>>>() {
        public void handle(PropertyMapping<T, ?, K, FieldMapperColumnDefinition<K>> propertyMapping) {
            if (!isTargetForMapperFieldMapper(propertyMapping)) {
                PropertyMeta<T, ?> pm = propertyMapping.getPropertyMeta();
                ConstructorPropertyMeta<T, ?> cProp = (ConstructorPropertyMeta<T, ?>) pm;
                Parameter parameter = cProp.getParameter();
                Getter<? super S, ?> getter = fieldMapperFactory.getGetterFromSource(propertyMapping.getColumnKey(), pm.getPropertyType(), propertyMapping.getColumnDefinition(), pm.getPropertyClassMetaSupplier());
                if (NullGetter.isNull(getter)) {
                    mapperConfig.mapperBuilderErrorHandler().accessorNotFound("String_Node_Str" + propertyMapping.getColumnKey() + "String_Node_Str" + propertyMapping.getPropertyMeta().getPropertyType() + "String_Node_Str" + propertyMapping.getPropertyMeta().getPath() + "String_Node_Str" + ErrorDoc.toUrl("String_Node_Str"));
                } else {
                    injections.put(parameter, new BiFunctionGetter<S, MappingContext<? super S>, Object>(getter));
                }
                if (!NullSetter.isNull(cProp.getSetter())) {
                    fieldMappers.add(fieldMapperFactory.newFieldMapper(propertyMapping, mappingContextFactoryBuilder, mapperConfig.mapperBuilderErrorHandler()));
                }
            }
        }
    });
    for (PropertyPerOwner e : getSubPropertyPerOwner()) {
        if (e.owner.isConstructorProperty()) {
            final List<PropertyMapping<T, ?, K, FieldMapperColumnDefinition<K>>> properties = e.propertyMappings;
            final MappingContextFactoryBuilder currentBuilder = getMapperContextFactoryBuilder(e.owner, properties);
            final Mapper<S, ?> mapper;
            if (properties.size() == 1 && properties.get(0).getPropertyMeta() instanceof ArrayElementPropertyMeta) {
                mapper = getterPropertyMapper(e.owner, properties.get(0));
            } else {
                mapper = subPropertyMapper(e.owner, properties, currentBuilder);
            }
            ConstructorPropertyMeta<T, ?> meta = (ConstructorPropertyMeta<T, ?>) e.owner;
            injections.put(meta.getParameter(), newMapperGetterAdapter(mapper, currentBuilder));
            fieldMappers.add(newMapperFieldMapper(properties, meta, mapper, currentBuilder));
        }
    }
    return new ConstructorInjections(injections, fieldMappers.toArray(new FieldMapper[0]));
}

Output:
             final Mapper<S, ?> mapper;
-            if (properties.size() == 1 && properties.get(0).getPropertyMeta() instanceof ArrayElementPropertyMeta) {
+            if (properties.size() == 1 && JoinUtils.isArrayElement(properties.get(0).getPropertyMeta())) {
                 mapper = getterPropertyMapper(e.owner, properties.get(0));


Input:
public void onEnable() {
    PluginDescriptionFile pdfFile = this.getDescription();
    if (getServer().getPluginManager().getPlugin("String_Node_Str") != null) {
        RegisteredServiceProvider<Economy> rspEcon = getServer().getServicesManager().getRegistration(Economy.class);
        if (rspEcon != null) {
            economy = rspEcon.getProvider();
            this.logger.info("String_Node_Str" + pdfFile.getName() + "String_Node_Str");
        } else {
            this.logger.info("String_Node_Str");
            this.setEnabled(false);
            this.getPluginLoader().disablePlugin(this);
            return;
        }
        RegisteredServiceProvider<Permission> rspPerm = plugin.getServer().getServicesManager().getRegistration(Permission.class);
        if (rspPerm != null) {
            permission = rspPerm.getProvider();
            this.logger.info("String_Node_Str" + pdfFile.getName() + "String_Node_Str");
        } else {
            this.logger.info("String_Node_Str" + pdfFile.getName() + "String_Node_Str");
        }
        this.logger.info("String_Node_Str" + pdfFile.getName() + "String_Node_Str" + pdfFile.getVersion() + "String_Node_Str");
        cf = new CharacterFactory(TraderNpc.class);
        cf.withName("String_Node_Str");
        if (CitizensAPI.getCharacterManager() != null)
            CitizensAPI.getCharacterManager().registerCharacter(cf);
        if (CitizensAPI.getTraitManager() != null)
            CitizensAPI.getTraitManager().registerTrait(new TraitFactory(InventoryTrait.class).withName("String_Node_Str").withPlugin(this));
        getServer().getPluginManager().registerEvents((Listener) CitizensAPI.getCharacterManager().getCharacter("String_Node_Str"), this);
        getCommand("String_Node_Str").setExecutor(new TraderCommandExecutor());
        ((TraderNpc) CitizensAPI.getCharacterManager().getCharacter("String_Node_Str")).setEcon(economy);
        plugin = this;
    } else {
        this.logger.info("String_Node_Str");
        this.setEnabled(false);
        this.getPluginLoader().disablePlugin(this);
        return;
    }
}

Output:
         }
-        RegisteredServiceProvider<Permission> rspPerm = plugin.getServer().getServicesManager().getRegistration(Permission.class);
+        RegisteredServiceProvider<Permission> rspPerm = getServer().getServicesManager().getRegistration(Permission.class);
         if (rspPerm != null) {


Input:
protected int doProcess(Buffer inBuffer, Buffer outBuffer) {
    Format inFormat = inBuffer.getFormat();
    if ((inFormat != null) && (inFormat != this.inputFormat) && !inFormat.equals(this.inputFormat) && (null == setInputFormat(inFormat))) {
        return BUFFER_PROCESSED_FAILED;
    }
    long seqNo = inBuffer.getSequenceNumber();
    boolean decodeFEC = false;
    if ((lastSeqNo != Buffer.SEQUENCE_UNKNOWN) && (seqNo != lastSeqNo + 1) && (seqNo > lastSeqNo) && (lastFrameSizeInSamplesPerChannel > 0)) {
        decodeFEC = true;
    }
    if ((inBuffer.getFlags() & Buffer.FLAG_SKIP_FEC) != 0) {
        decodeFEC = false;
        if (logger.isTraceEnabled()) {
            logger.trace("String_Node_Str" + seqNo + "String_Node_Str");
        }
    }
    byte[] in = (byte[]) inBuffer.getData();
    int inOffset = inBuffer.getOffset();
    int inLength = inBuffer.getLength();
    int outOffset = 0;
    int outLength = 0;
    int totalFrameSizeInSamplesPerChannel = 0;
    if (decodeFEC) {
        byte[] out = validateByteArraySize(outBuffer, outOffset + lastFrameSizeInSamplesPerChannel * outputFrameSize, outOffset != 0);
        int frameSizeInSamplesPerChannel = Opus.decode(decoder, in, inOffset, inLength, out, lastFrameSizeInSamplesPerChannel, 1);
        if (frameSizeInSamplesPerChannel > 0) {
            int frameSizeInBytes = frameSizeInSamplesPerChannel * outputFrameSize;
            outLength += frameSizeInBytes;
            outOffset += frameSizeInBytes;
            totalFrameSizeInSamplesPerChannel += frameSizeInSamplesPerChannel;
            outBuffer.setFlags(outBuffer.getFlags() | BUFFER_FLAG_FEC);
            nbDecodedFec++;
        }
        lastSeqNo++;
        if (lastSeqNo > 65535)
            lastSeqNo = 0;
    } else {
        int frameSizeInSamplesPerChannel = Opus.decoder_get_nb_samples(decoder, in, inOffset, inLength);
        byte[] out = validateByteArraySize(outBuffer, outOffset + frameSizeInSamplesPerChannel * outputFrameSize, outOffset != 0);
        frameSizeInSamplesPerChannel = Opus.decode(decoder, in, inOffset, inLength, out, frameSizeInSamplesPerChannel, 0);
        if (frameSizeInSamplesPerChannel > 0) {
            int frameSizeInBytes = frameSizeInSamplesPerChannel * outputFrameSize;
            outLength += frameSizeInBytes;
            outOffset += frameSizeInBytes;
            totalFrameSizeInSamplesPerChannel += frameSizeInSamplesPerChannel;
            outBuffer.setFlags(outBuffer.getFlags() & ~BUFFER_FLAG_FEC);
            lastFrameSizeInSamplesPerChannel = frameSizeInSamplesPerChannel;
        }
        lastSeqNo = seqNo;
    }
    if (outLength > 0) {
        outBuffer.setDuration(totalFrameSizeInSamplesPerChannel * channels * 1000L * 1000L / outputSampleRate);
        outBuffer.setFormat(getOutputFormat());
        outBuffer.setLength(outLength);
        outBuffer.setOffset(0);
    } else {
        outBuffer.setLength(0);
        discardOutputBuffer(outBuffer);
    }
    if (lastSeqNo == seqNo)
        return BUFFER_PROCESSED_OK;
    else
        return INPUT_BUFFER_NOT_CONSUMED;
}

Output:
     long seqNo = inBuffer.getSequenceNumber();
-    boolean decodeFEC = false;
-    if ((lastSeqNo != Buffer.SEQUENCE_UNKNOWN) && (seqNo != lastSeqNo + 1) && (seqNo > lastSeqNo) && (lastFrameSizeInSamplesPerChannel > 0)) {
-        decodeFEC = true;
-    }
+    int lostSeqNoCount = calculateLostSeqNoCount(lastSeqNo, seqNo);
+    boolean decodeFEC = ((lostSeqNoCount != 0) && (lastFrameSizeInSamplesPerChannel != 0));
     if ((inBuffer.getFlags() & Buffer.FLAG_SKIP_FEC) != 0) {


Input:
protected IStatus run(IProgressMonitor monitor) {
    try {
        final Set<Artifact> arts = new HashSet<Artifact>();
        for (Artifact art : artifacts) {
            if (art.isOfType(AtsArtifactTypes.Action)) {
                arts.add(art);
            } else if (art instanceof AbstractWorkflowArtifact) {
                Artifact parentArt = ((AbstractWorkflowArtifact) art).getParentActionArtifact();
                if (parentArt != null) {
                    arts.add(parentArt);
                }
            }
        }
        Displays.ensureInDisplayThread(new Runnable() {
            public void run() {
                worldComposite.load(worldEditor.getWorldXWidgetActionPage().getCurrentTitleLabel(), arts);
            }
        });
    } catch (OseeCoreException ex) {
        OseeLog.log(Activator.class, OseeLevel.SEVERE_POPUP, ex);
    }
    return Status.OK_STATUS;
}

Output:
         }
-        Displays.ensureInDisplayThread(new Runnable() {
-            public void run() {
-                worldComposite.load(worldEditor.getWorldXWidgetActionPage().getCurrentTitleLabel(), arts);
-            }
-        });
+        worldComposite.load(worldEditor.getWorldXWidgetActionPage().getCurrentTitleLabel(), arts);
     } catch (OseeCoreException ex) {


Input:
private int getRandomDamage(Random random, int maxDamage) {
    return 20 + random.nextInt(maxDamage - 20);
}

Output:
 private int getRandomDamage(Random random, int maxDamage) {
-    return 20 + random.nextInt(maxDamage - 20);
+    return random.nextInt(maxDamage);
 }


Input:
protected void populate() {
    super.populate();
    this.types = new LoadableDetachableModel<List<SearchClause.Type>>() {
        private static final long serialVersionUID = 5275935387613157437L;
        protected List<SearchClause.Type> load() {
            final List<SearchClause.Type> result = new ArrayList<>();
            result.add(SearchClause.Type.ATTRIBUTE);
            result.add(SearchClause.Type.RESOURCE);
            return result;
        }
    };
    this.groupNames = new LoadableDetachableModel<List<Pair<Long, String>>>() {

        private static final long serialVersionUID = 5275935387613157437L;
        protected List<Pair<Long, String>> load() {
            return Collections.<Pair<Long, String>>emptyList();
        }
    };
}

Output:
     };
-    this.groupNames = new LoadableDetachableModel<List<Pair<Long, String>>>() {
+    this.groupNames = new LoadableDetachableModel<Map<Long, String>>() {


Input:
public void onServiceClick(View view) {
    setOfficeNum(0);
    setServiceRedVisible(View.GONE);
    PublicActivity.startActivity((Activity) getContext(), "String_Node_Str");
}

Output:
     setServiceRedVisible(View.GONE);
-    PublicActivity.startActivity((Activity) getContext(), "String_Node_Str");
+    setServiceContent("String_Node_Str");
+    if (JMessageClient.getMyInfo() == null) {
+        PublicActivity.startActivity((Activity) getContext(), "String_Node_Str");
+    } else {
+        PublicActivity.startActivity((Activity) getContext(), "String_Node_Str");
+    }
 }


Input:
private UsageEventVO convertSnapshotEvent(EventVO event, Connection conn) throws IOException, SQLException {
    Properties snapEventParams = new Properties();
    long snapId = -1L;
    long snapSize = -1L;
    Long zoneId = null;
    UsageEventVO usageEvent = null;
    snapEventParams.load(new StringReader(event.getParameters()));
    snapId = Long.parseLong(snapEventParams.getProperty("String_Node_Str"));
    String snapshotName = snapEventParams.getProperty("String_Node_Str");
    String size = snapEventParams.getProperty("String_Node_Str");
    if (size != null) {
        snapSize = Long.parseLong(size);
    }
    String zoneString = snapEventParams.getProperty("String_Node_Str");
    if (zoneString != null) {
        zoneId = Long.parseLong(zoneString);
    }
    Long accountId = event.getAccountId();
    if (accountId.longValue() == 0L || zoneId == null) {
        PreparedStatement pstmt = conn.prepareStatement("String_Node_Str");
        pstmt.setLong(1, snapId);
        s_logger.debug("String_Node_Str" + pstmt);
        ResultSet rs = pstmt.executeQuery();
        if (rs.next()) {
            zoneId = rs.getLong(1);
            accountId = rs.getLong(2);
        }
        rs.close();
        pstmt.close();
    }
    if (EventTypes.EVENT_SNAPSHOT_CREATE.equals(event.getType())) {
        usageEvent = new UsageEventVO(EventTypes.EVENT_SNAPSHOT_CREATE, accountId, zoneId, snapId, snapshotName, null, null, snapSize);
    } else if (EventTypes.EVENT_SNAPSHOT_DELETE.equals(event.getType())) {
        usageEvent = new UsageEventVO(EventTypes.EVENT_SNAPSHOT_DELETE, accountId, zoneId, snapId, snapshotName, null, null, 0L);
    }
    return usageEvent;
}

Output:
     long snapSize = -1L;
-    Long zoneId = null;
+    Long zoneId = 0L;
     UsageEventVO usageEvent = null;


Input:
public void testGetTableNamesFromQuery() throws SQLException {
    assertTrue(ExtractMetaDataFromDataBase.tableCommentsMap instanceof HashMap<?, ?>);
    assertTrue(ExtractMetaDataFromDataBase.tableCommentsMap.isEmpty());
    ResultSet mockResultSet = mock(ResultSet.class);
    when(mockResultSet.getString(1)).thenReturn("String_Node_Str");
    String nameKey = mockResultSet.getString(1).trim();
    String tableComment = ExtractMetaDataFromDataBase.getTableComment(nameKey, mockResultSet, false, ExtractMetaDataUtils.conn);
    assertNotNull(tableComment);
    ExtractMetaDataFromDataBase.tableCommentsMap.put(nameKey, tableComment);
    assertNotNull(ExtractMetaDataFromDataBase.tableCommentsMap);
    assertNotNull(ExtractMetaDataFromDataBase.getTableNamesFromQuery(mockResultSet, ExtractMetaDataUtils.conn));
}

Output:
     String nameKey = mockResultSet.getString(1).trim();
-    String tableComment = ExtractMetaDataFromDataBase.getTableComment(nameKey, mockResultSet, false, ExtractMetaDataUtils.conn);
+    String tableComment = ExtractMetaDataFromDataBase.getTableComment(nameKey, mockResultSet, false, ExtractMetaDataUtils.getInstance().getConn());
     assertNotNull(tableComment);


Input:
protected PollingResult compareRemoteRevisionWith(AbstractProject<?, ?> project, Launcher launcher, FilePath workspace, final TaskListener listener, SCMRevisionState _baseline) throws IOException, InterruptedException {
    Logger.debug("String_Node_Str");
    IntegrityRevisionState baseline;
    IntegrityCMProject siProject = getIntegrityProject();
    if (_baseline instanceof IntegrityRevisionState) {
        baseline = (IntegrityRevisionState) _baseline;
        AbstractBuild<?, ?> lastBuild = project.getLastBuild();
        if (null == lastBuild) {
            Logger.debug("String_Node_Str");
            return PollingResult.BUILD_NOW;
        } else {
            baseline = (IntegrityRevisionState) calcRevisionsFromBuild(lastBuild, launcher, listener);
            if (null != baseline && null != baseline.getProjectDB()) {
                APISession api = APISession.create(this);
                if (null != api) {
                    try {
                        String resolvedConfigPath = IntegrityCheckpointAction.evalGroovyExpression(project.getCharacteristicEnvVars(), configPath);
                        listener.getLogger().println("String_Node_Str" + resolvedConfigPath);
                        initializeCMProject(api, new File(lastBuild.getRootDir(), "String_Node_Str"), resolvedConfigPath);
                        listener.getLogger().println("String_Node_Str" + resolvedConfigPath);
                        initializeCMProjectMembers(api);
                        File projectDB = baseline.getProjectDB();
                        int changeCount = siProject.compareBaseline(projectDB, api);
                        if (changeCount > 0) {
                            listener.getLogger().println("String_Node_Str" + changeCount + "String_Node_Str");
                            return PollingResult.SIGNIFICANT;
                        } else {
                            listener.getLogger().println("String_Node_Str");
                            return PollingResult.NO_CHANGES;
                        }
                    } catch (APIException aex) {
                        Logger.error("String_Node_Str");
                        listener.getLogger().println("String_Node_Str");
                        ExceptionHandler eh = new ExceptionHandler(aex);
                        Logger.error(eh.getMessage());
                        listener.getLogger().println(eh.getMessage());
                        Logger.debug(eh.getCommand() + "String_Node_Str" + eh.getExitCode());
                        listener.getLogger().println(eh.getCommand() + "String_Node_Str" + eh.getExitCode());
                        aex.printStackTrace();
                        return PollingResult.NO_CHANGES;
                    } catch (SQLException sqlex) {
                        Logger.error("String_Node_Str");
                        listener.getLogger().println("String_Node_Str");
                        listener.getLogger().println(sqlex.getMessage());
                        Logger.fatal(sqlex);
                        return PollingResult.NO_CHANGES;
                    } finally {
                        api.Terminate();
                        siProject.closeProjectDB();
                    }
                } else {
                    listener.getLogger().println("String_Node_Str");
                    return PollingResult.NO_CHANGES;
                }
            } else {
                Logger.debug("String_Node_Str");
                return PollingResult.BUILD_NOW;
            }
        }
    } else {
        Logger.error("String_Node_Str");
        return PollingResult.NO_CHANGES;
    }
}

Output:
     IntegrityRevisionState baseline;
-    IntegrityCMProject siProject = getIntegrityProject();
+    IntegrityCMProject siProject = null;
     if (_baseline instanceof IntegrityRevisionState) {


Input:
private static boolean validateDomainLength(String domainWithoutLastDot) {
    if (StringUtils.isBlank(domainWithoutLastDot)) {
        return false;
    }
    if (domainWithoutLastDot.length() < MIN_DOMAIN_LENGTH_WITHOUT_LAST_DOT || domainWithoutLastDot.length() > MAX_DOMAIN_LENGTH_WITHOUT_LAST_DOT) {
        return false;
    }
    return true;
}

Output:
     }
-    if (domainWithoutLastDot.length() < MIN_DOMAIN_LENGTH_WITHOUT_LAST_DOT || domainWithoutLastDot.length() > MAX_DOMAIN_LENGTH_WITHOUT_LAST_DOT) {
+    int domainLength = domainWithoutLastDot.length();
+    if (domainLength < MIN_DOMAIN_LENGTH_WITHOUT_LAST_DOT) {
+        return false;
+    }
+    if (domainLength > MAX_DOMAIN_LENGTH_WITHOUT_LAST_DOT) {
         return false;


Input:
public void start() {
    ioSelector.addTask(new Runnable() {

        public void run() {
            getSelectionKey();
        }
    });
    ioSelector.wakeup();
}

Output:
 public void start() {
-    ioSelector.addTask(new Runnable() {
+    ioSelector.addTaskAndWakeup(new Runnable() {


Input:
public void buildModel(String srcPathToBuild, String bytecodePathToBuild, String[] classpath) {
    JDTBasedSpoonCompiler jdtSpoonModelBuilder = null;
    logger.info("String_Node_Str" + srcPathToBuild + "String_Node_Str" + factory.getEnvironment().getComplianceLevel());
    factory.getEnvironment().setPreserveLineNumbers(ConfigurationProperties.getPropertyBool("String_Node_Str"));
    jdtSpoonModelBuilder = new JDTBasedSpoonCompiler(factory);
    String[] sources = srcPathToBuild.split(File.pathSeparator);
    for (String src : sources) {
        if (!src.trim().isEmpty())
            jdtSpoonModelBuilder.addInputSource(new File(src));
    }
    logger.info("String_Node_Str" + Arrays.toString(classpath));
    jdtSpoonModelBuilder.setSourceClasspath(classpath);
    jdtSpoonModelBuilder.build();
    if (ConfigurationProperties.getPropertyBool("String_Node_Str")) {
        jdtSpoonModelBuilder.setSourceOutputDirectory(new File(srcPathToBuild));
        jdtSpoonModelBuilder.generateProcessedSourceFiles(OutputType.COMPILATION_UNITS);
        jdtSpoonModelBuilder.setBinaryOutputDirectory(new File(bytecodePathToBuild));
        jdtSpoonModelBuilder.compile(InputType.CTTYPES);
    }
}

Output:
     if (ConfigurationProperties.getPropertyBool("String_Node_Str")) {
-        jdtSpoonModelBuilder.setSourceOutputDirectory(new File(srcPathToBuild));
+        factory.getEnvironment().setSourceOutputDirectory(new File(srcPathToBuild));
         jdtSpoonModelBuilder.generateProcessedSourceFiles(OutputType.COMPILATION_UNITS);


Input:
public static void renderCross(OpenGLContext context, float zoomWidth, float zoomHeight, List<Geometry> geometries, Geometry selectedGeometry, float renderWidth, Color color) {
    GL2 gl = context.getGL().getGL2();
    float[] c = color.brighter().getColorComponents(null);
    gl.glColor3f(c[0], c[1], c[2]);
    for (Geometry temp : geometries) {
        gl.glLineWidth(temp == selectedGeometry ? renderWidth * 2 : renderWidth);
        Coordinate point = new Coordinate(temp.getCoordinate());
        point.x = (point.x - context.getX()) / zoomWidth;
        point.y = 1 - (point.y - context.getY()) / zoomHeight;
        double rectwidth = 0.01;
        gl.glBegin(GL.GL_LINE_STRIP);
        gl.glVertex2d(point.x - rectwidth, point.y);
        gl.glVertex2d(point.x + rectwidth, point.y);
        gl.glEnd();
        gl.glBegin(GL.GL_LINE_STRIP);
        gl.glVertex2d(point.x, point.y - rectwidth);
        gl.glVertex2d(point.x, point.y + rectwidth);
        gl.glEnd();
        gl.glFlush();
    }
}

Output:
     gl.glColor3f(c[0], c[1], c[2]);
-    for (Geometry temp : geometries) {
-        gl.glLineWidth(temp == selectedGeometry ? renderWidth * 2 : renderWidth);
-        Coordinate point = new Coordinate(temp.getCoordinate());
-        point.x = (point.x - context.getX()) / zoomWidth;
-        point.y = 1 - (point.y - context.getY()) / zoomHeight;
-        double rectwidth = 0.01;
-        gl.glBegin(GL.GL_LINE_STRIP);
-        gl.glVertex2d(point.x - rectwidth, point.y);
-        gl.glVertex2d(point.x + rectwidth, point.y);
-        gl.glEnd();
-        gl.glBegin(GL.GL_LINE_STRIP);
-        gl.glVertex2d(point.x, point.y - rectwidth);
-        gl.glVertex2d(point.x, point.y + rectwidth);
-        gl.glEnd();
-        gl.glFlush();
+    if (geometries != null) {
+        for (Geometry temp : geometries) {
+            gl.glLineWidth(temp == selectedGeometry ? renderWidth * 2 : renderWidth);
+            Coordinate point = new Coordinate(temp.getCoordinate());
+            point.x = (point.x - context.getX()) / zoomWidth;
+            point.y = 1 - (point.y - context.getY()) / zoomHeight;
+            double rectwidth = 0.01;
+            gl.glBegin(GL.GL_LINE_STRIP);
+            gl.glVertex2d(point.x - rectwidth, point.y);
+            gl.glVertex2d(point.x + rectwidth, point.y);
+            gl.glEnd();
+            gl.glBegin(GL.GL_LINE_STRIP);
+            gl.glVertex2d(point.x, point.y - rectwidth);
+            gl.glVertex2d(point.x, point.y + rectwidth);
+            gl.glEnd();
+            gl.glFlush();
+        }
     }


Input:
public void onResponse(JSONObject response) {
    if (response == null) {
        this.errorListener.onErrorResponse(new VolleyError());
    } else {
        HSTicketUpdate update;
        String updateId = null;
        String userName = null;
        Date update_time = null;
        HSAttachment[] attachmentList = null;
        try {
            JSONObject requestObject = response.getJSONObject("String_Node_Str");
            if (!requestObject.isNull("String_Node_Str")) {
                userName = requestObject.getString("String_Node_Str");
            }
            if (!requestObject.isNull("String_Node_Str")) {
                update_time = parseTime(requestObject.getString("String_Node_Str"));
            }
            update = HSTicketUpdate.createUpdateByUser(updateId, userName, message, update_time, attachmentList);
        } catch (JSONException e) {
            e.printStackTrace();
            errorListener.onErrorResponse(new VolleyError("String_Node_Str"));
        }
    }
}

Output:
         Date update_time = null;
-        HSAttachment[] attachmentList = null;
+        HSAttachment[] attachmentList = attachmentObjectList;
         try {


Input:
public Object getItem(int i) {
    return files[i];
}

Output:
 public Object getItem(int i) {
-    return files[i];
+    return fileList.get(i);
 }


Input:
public void setTileEntity(int x, int y, int z, TileEntity tileentity) {
    if (tileentity == null || tileentity.isInvalid()) {
        return;
    }
    setChunkBlockTileEntity(x, y, z, tileentity);
}

Output:
 public void setTileEntity(int x, int y, int z, TileEntity tileentity) {
-    if (tileentity == null || tileentity.isInvalid()) {
+    if (tileentity == null) {
         return;


Input:
public void run(IIntroSite site, Properties params) {
    PlatformUI.getWorkbench().getIntroManager().closeIntro(PlatformUI.getWorkbench().getIntroManager().getIntro());
    run();
}

Output:
 public void run(IIntroSite site, Properties params) {
-    PlatformUI.getWorkbench().getIntroManager().closeIntro(PlatformUI.getWorkbench().getIntroManager().getIntro());
-    run();
+    IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
+    if (factory.isUserReadOnlyOnCurrentProject()) {
+        MessageDialog.openWarning(null, "String_Node_Str", "String_Node_Str");
+    } else {
+        PlatformUI.getWorkbench().getIntroManager().closeIntro(PlatformUI.getWorkbench().getIntroManager().getIntro());
+        IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+        if (null == workbenchWindow) {
+            return;
+        }
+        IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
+        if (null == workbenchPage) {
+            return;
+        }
+        IPerspectiveDescriptor currentPerspective = workbenchPage.getPerspective();
+        if (!IBrandingConfiguration.PERSPECTIVE_DQ_ID.equals(currentPerspective.getId())) {
+            try {
+                workbenchWindow.getWorkbench().showPerspective(IBrandingConfiguration.PERSPECTIVE_DQ_ID, workbenchWindow);
+                workbenchPage = workbenchWindow.getActivePage();
+            } catch (WorkbenchException e) {
+                ExceptionHandler.process(e);
+                return;
+            }
+        }
+        run();
+    }
 }


Input:
public static <T extends MVec> T[] copyAndConvertAlgebraOfArray(T[] orig, Algebra newS) {
    if (orig == null) {
        return null;
    }
    T[] clone = Arrays.copyOf(orig, orig.length);
    for (int v = 0; v < clone.length; v++) {
        if (orig[v] != null) {
            clone[v] = (T) orig[v].copyAndConvertAlgebra(newS);
        }
    }
    return clone;
}

Output:
         if (orig[v] != null) {
-            clone[v] = (T) orig[v].copyAndConvertAlgebra(newS);
+            MVec copy = orig[v].copyAndConvertAlgebra(newS);
+            if (!copy.getClass().equals(orig[v].getClass())) {
+                throw new RuntimeException(orig[v].getClass() + "String_Node_Str" + "String_Node_Str" + copy.getClass());
+            }
+            clone[v] = (T) copy;
         }


Input:
private boolean isSupportedDeploymentPair(QName artifactType, QName infrastructureNodeType) {
    boolean isSupportedInfrastructureNode = false;
    isSupportedInfrastructureNode |= PluginUtils.isSupportedUbuntuVMNodeType(infrastructureNodeType);
    isSupportedInfrastructureNode |= infrastructureNodeType.equals(Utils.externalResourceNodeType);
    if (!isSupportedInfrastructureNode) {
        return false;
    }
    boolean isSupportedArtifactType = false;
    if (this.archiveArtifactType.equals(artifactType)) {
        isSupportedArtifactType |= true;
    }
    if (this.scriptArtifactType.equals(artifactType)) {
        isSupportedArtifactType |= true;
    }
    if (this.warArtifactType.equals(artifactType)) {
        isSupportedArtifactType |= true;
    }
    if (this.bpelArchiveArtifactType.equals(artifactType)) {
        isSupportedArtifactType |= true;
    }
    if (this.sqlArtifactType.equals(artifactType)) {
        isSupportedArtifactType |= true;
    }
    return isSupportedArtifactType;
}

Output:
     }
-    if (this.warArtifactType.equals(artifactType)) {
+    if (this.bpelArchiveArtifactType.equals(artifactType)) {
         isSupportedArtifactType |= true;


Input:
public void widgetSelected(SelectionEvent e) {
    if (tableViewerCreator != null && tableViewerCreator.isReadOnly()) {
        return;
    }
    TableItem[] items = tableViewerCreator.getTable().getItems();
    String columnId = tableViewerCreatorColumn.getId();
    boolean modified = false;
    for (TableItem tableItem : items) {
        tableViewerCreator.getCellModifier().modify(tableItem, columnId, checked ? false : true);
        if (!modified) {
            modified = true;
        }
    }
    if (modified) {
        this.param.getValue();
        if (checked) {
            checked = false;
        } else {
            checked = true;
        }
        tableViewerCreatorColumn.getTableColumn().setImage(checked ? ImageProvider.getImage(EImage.CHECKED_ICON) : ImageProvider.getImage(EImage.UNCHECKED_ICON));
        this.param.setValue(new Boolean(checked));
    }
}

Output:
     String columnId = tableViewerCreatorColumn.getId();
-    boolean modified = false;
-    for (TableItem tableItem : items) {
-        tableViewerCreator.getCellModifier().modify(tableItem, columnId, checked ? false : true);
-        if (!modified) {
-            modified = true;
-        }
+    IBeanPropertyAccessors accessor = tableViewerCreator.getColumn(columnId).getBeanPropertyAccessors();
+    List inputList = tableViewerCreator.getInputList();
+    for (int i = 0; i < inputList.size(); i++) {
+        accessor.set(inputList.get(i), checked ? false : true);
     }


Input:
public static JsonNode getAsJson(String path, EtcdClient etcdClient) throws IOException, EtcdAuthenticationException, TimeoutException, EtcdException {
    EtcdKeyGetRequest etcdKeyGetRequest = etcdClient.get(path).recursive();
    EtcdKeysResponse dataTree = etcdKeyGetRequest.send().get();
    ObjectNode jNode = JsonNodeFactory.instance.objectNode();
    for (EtcdNode node : dataTree.getNode().getNodes()) {
        iterateOverNodes(jNode, node);
    }
    return dotNotationToStandardJson(jNode.at(path));
}

Output:
     ObjectNode jNode = JsonNodeFactory.instance.objectNode();
-    for (EtcdNode node : dataTree.getNode().getNodes()) {
-        iterateOverNodes(jNode, node);
+    if (dataTree.getNode().getNodes().isEmpty()) {
+        iterateOverNodes(jNode, dataTree.getNode());
+    } else {
+        for (EtcdNode node : dataTree.getNode().getNodes()) {
+            iterateOverNodes(jNode, node);
+        }
     }


Input:
public static boolean isSchedulable(JobCurator jobCurator, JobStatus status) {
    long running = jobCurator.findNumRunningByClassAndTarget(status.getTargetId(), status.getJobClass());
    return running == 0;
}

Output:
 public static boolean isSchedulable(JobCurator jobCurator, JobStatus status) {
-    long running = jobCurator.findNumRunningByClassAndTarget(status.getTargetId(), status.getJobClass());
+    Class<? extends KingpinJob> jobClass;
+    try {
+        jobClass = (Class<? extends KingpinJob>) Class.forName(status.getJobClass());
+    } catch (ClassNotFoundException cnfe) {
+        log.warn("String_Node_Str", status.getJobClass());
+        return false;
+    }
+    long running = jobCurator.findNumRunningByClassAndTarget(status.getTargetId(), jobClass);
     return running == 0;


Input:
public void handleInvalidUser(int status, CommandListener listener) {
    String s = Localization.get("String_Node_Str");
    if (status == UserValidator.USER_EXISTS) {
        s += "String_Node_Str" + Localization.get("String_Node_Str", new String[] { this.view.getUsername() });
    }
    if (status == UserValidator.USERORPASSWD_MISSING) {
        s += "String_Node_Str" + Localization.get("String_Node_Str");
    }
    if (status == UserValidator.MISMATCHED_PASSWORDS) {
        s += "String_Node_Str" + Localization.get("String_Node_Str");
    }
    J2MEDisplay.showError("String_Node_Str", s);
}

Output:
     }
-    J2MEDisplay.showError("String_Node_Str", s);
+    J2MEDisplay.showError(null, s);
 }


Input:
public void testFailureStop() throws InterruptedException {
    CountDownLatch failureLatch = new CountDownLatch(1);
    Service service = new RetryOnStartFailureService(createServiceSupplier(1000, new CountDownLatch(1), failureLatch), RetryStrategies.fixDelay(10, TimeUnit.MILLISECONDS));
    service.startAndWait();
    Assert.assertTrue(failureLatch.await(1, TimeUnit.SECONDS));
    service.stopAndWait();
}

Output:
     Assert.assertTrue(failureLatch.await(1, TimeUnit.SECONDS));
-    service.stopAndWait();
+    try {
+        service.stopAndWait();
+        Assert.fail();
+    } catch (UncheckedExecutionException e) {
+        Throwable rootCause = Throwables.getRootCause(e);
+        Assert.assertEquals(RuntimeException.class, rootCause.getClass());
+        Assert.assertEquals("String_Node_Str", rootCause.getMessage());
+    }
 }


Input:
public void decreasePriority(int overrideId, int pathId, String clientUUID) {
    logger.info("String_Node_Str");
    int origPriority = -1;
    int newPriority = -1;
    PreparedStatement queryStatement = null;
    ResultSet results = null;
    try (Connection sqlConnection = sqlService.getConnection()) {
        queryStatement = sqlConnection.prepareStatement("String_Node_Str" + Constants.DB_TABLE_ENABLED_OVERRIDE + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PATH_ID + "String_Node_Str" + "String_Node_Str" + Constants.GENERIC_CLIENT_UUID + "String_Node_Str" + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PRIORITY);
        queryStatement.setInt(1, pathId);
        queryStatement.setString(2, clientUUID);
        results = queryStatement.executeQuery();
        boolean gotOrig = false;
        while (results.next()) {
            if (results.getInt(Constants.ENABLED_OVERRIDES_OVERRIDE_ID) == overrideId) {
                origPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
                gotOrig = true;
            } else {
                newPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
                if (gotOrig) {
                    break;
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (results != null) {
                results.close();
            }
        } catch (Exception e) {
        }
        try {
            if (queryStatement != null) {
                queryStatement.close();
            }
        } catch (Exception e) {
        }
    }
    PreparedStatement statement = null;
    try (Connection sqlConnection = sqlService.getConnection()) {
        if (origPriority != -1 && newPriority != -1) {
            statement = sqlConnection.prepareStatement("String_Node_Str" + Constants.DB_TABLE_ENABLED_OVERRIDE + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PRIORITY + "String_Node_Str" + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PRIORITY + "String_Node_Str" + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PATH_ID + "String_Node_Str" + "String_Node_Str" + Constants.GENERIC_CLIENT_UUID + "String_Node_Str");
            statement.setInt(1, origPriority);
            statement.setInt(2, newPriority);
            statement.setInt(3, pathId);
            statement.setString(4, clientUUID);
            statement.executeUpdate();
            statement.close();
            statement = sqlConnection.prepareStatement("String_Node_Str" + Constants.DB_TABLE_ENABLED_OVERRIDE + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PRIORITY + "String_Node_Str" + "String_Node_Str" + Constants.ENABLED_OVERRIDES_OVERRIDE_ID + "String_Node_Str" + "String_Node_Str" + Constants.ENABLED_OVERRIDES_PATH_ID + "String_Node_Str" + "String_Node_Str" + Constants.GENERIC_CLIENT_UUID + "String_Node_Str");
            statement.setInt(1, newPriority);
            statement.setInt(2, overrideId);
            statement.setInt(3, pathId);
            statement.setString(4, clientUUID);
            statement.executeUpdate();
        }
    } catch (Exception e) {
    } finally {
        try {
            if (statement != null) {
                statement.close();
            }
        } catch (Exception e) {
        }
    }
}

Output:
             if (results.getInt(Constants.ENABLED_OVERRIDES_OVERRIDE_ID) == overrideId) {
-                origPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
-                gotOrig = true;
-            } else {
-                newPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
-                if (gotOrig) {
-                    break;
+                ordinalCount++;
+                if (ordinalCount == ordinal) {
+                    origPriority = results.getInt(Constants.ENABLED_OVERRIDES_PRIORITY);
+                    origId = results.getInt(Constants.GENERIC_ID);
+                    gotOrig = true;
+                    continue;
                 }


Input:
public void testSetStatus() {
    Assert.assertEquals(ClusterStatus.OUT_OF_SERVICE, this.c.getStatus());
    this.c.setStatus(ClusterStatus.TERMINATED);
    Assert.assertEquals(ClusterStatus.TERMINATED, this.c.getStatus());
}

Output:
 public void testSetStatus() {
-    Assert.assertEquals(ClusterStatus.OUT_OF_SERVICE, this.c.getStatus());
+    Assert.assertNull(this.c.getStatus());
     this.c.setStatus(ClusterStatus.TERMINATED);


Input:
public List<Vec3dCube> getOcclusionBoxes() {
    List<Vec3dCube> boxes = new ArrayList<Vec3dCube>();
    double h = getHeight() / 16D;
    double d = 0.25;
    boxes.add(new Vec3dCube(d, 0, d, 1 - d, h, 1 - d));
    VectorHelper.rotateBoxes(boxes, getFace(), 0);
    return boxes;
}

Output:
     double h = getHeight() / 16D;
-    double d = 0.25;
+    double d = 4 / 16D;
     boxes.add(new Vec3dCube(d, 0, d, 1 - d, h, 1 - d));


Input:
private void onMenuClearClick() {
    DataController.clear(mContext, RecordColumns.CONTENT_URI);
    Utils.notify(this, "String_Node_Str");
    finish();
}

Output:
 private void onMenuClearClick() {
-    DataController.clear(mContext, RecordColumns.CONTENT_URI);
+    DataController.clear(mContext, StatusUpdateInfoColumns.CONTENT_URI);
     Utils.notify(this, "String_Node_Str");


Input:
public void onGuildMemberJoin(GuildMemberJoinEvent event) {
    Guild guild = event.getGuild();
    TextChannel serverlog = db.getServerlogChannel(guild);
    TextChannel welcome = db.getWelcomeChannel(guild);
    TextChannel channel = FinderUtil.getDefaultChannel(event.getGuild());
    User newmember = event.getMember().getUser();
    Calendar calendar = GregorianCalendar.getInstance();
    calendar.setTime(new Date());
    String hour = String.format("String_Node_Str", calendar.get(Calendar.HOUR_OF_DAY));
    String min = String.format("String_Node_Str", calendar.get(Calendar.MINUTE));
    String sec = String.format("String_Node_Str", calendar.get(Calendar.SECOND));
    String msg = db.getWelcomeMessage(guild);
    parser.clear().put("String_Node_Str", newmember).put("String_Node_Str", guild).put("String_Node_Str", welcome);
    if (!(serverlog == null)) {
        if (!(serverlog.getGuild().getSelfMember().hasPermission(serverlog, Permission.MESSAGE_READ, Permission.MESSAGE_WRITE, Permission.MESSAGE_EMBED_LINKS, Permission.MESSAGE_HISTORY)))
            guild.getOwner().getUser().openPrivateChannel().queue(s -> s.sendMessage(Messages.SRVLOG_NOPERMISSIONS).queue(null, (e) -> channel.sendMessage(Messages.SRVLOG_NOPERMISSIONS).queue()));
        else
            serverlog.sendMessage("String_Node_Str" + hour + "String_Node_Str" + min + "String_Node_Str" + sec + "String_Node_Str" + newmember.getName() + "String_Node_Str" + newmember.getDiscriminator() + "String_Node_Str" + newmember.getId() + "String_Node_Str" + guild.getMembers().size() + "String_Node_Str").queue();
    }
    if (!(welcome == null) && !(msg.isEmpty())) {
        if (!(welcome.getGuild().getSelfMember().hasPermission(welcome, Permission.MESSAGE_READ, Permission.MESSAGE_WRITE, Permission.MESSAGE_HISTORY)))
            guild.getOwner().getUser().openPrivateChannel().queue(s -> s.sendMessage(Messages.WELCOME_NOPERMISSIONS).queue(null, (e) -> channel.sendMessage(Messages.WELCOME_NOPERMISSIONS).queue()));
        else
            welcome.sendMessage(parser.parse(msg).trim()).queueAfter(2, TimeUnit.SECONDS);
    }
}

Output:
     Guild guild = event.getGuild();
-    TextChannel serverlog = db.getServerlogChannel(guild);
-    TextChannel welcome = db.getWelcomeChannel(guild);
+    TextChannel serverlog = ldm.getServerlogChannel(guild);
+    TextChannel welcome = jldm.getWelcomeChannel(guild);
     TextChannel channel = FinderUtil.getDefaultChannel(event.getGuild());


Input:
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth, int desiredWindowHeight) {
    mLayoutRequested = false;
    mScrollMayChange = true;
    mInLayout = true;
    final View host = mView;
    if (DEBUG_ORIENTATION || DEBUG_LAYOUT) {
        Log.v(TAG, "String_Node_Str" + host + "String_Node_Str" + host.getMeasuredWidth() + "String_Node_Str" + host.getMeasuredHeight() + "String_Node_Str");
    }
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "String_Node_Str");
    try {
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
        mInLayout = false;
        int numViewsRequestingLayout = mLayoutRequesters.size();
        if (numViewsRequestingLayout > 0) {
            ArrayList<View> mValidLayoutRequesters = null;
            for (int i = 0; i < numViewsRequestingLayout; ++i) {
                View view = mLayoutRequesters.get(i);
                if ((view.mPrivateFlags & View.PFLAG_FORCE_LAYOUT) == View.PFLAG_FORCE_LAYOUT) {
                    while (view != null && view.mAttachInfo != null && view.mParent != null && (view.mPrivateFlags & View.PFLAG_FORCE_LAYOUT) != 0) {
                        if ((view.mViewFlags & View.VISIBILITY_MASK) != View.GONE) {
                            Log.w(TAG, "String_Node_Str" + "String_Node_Str" + view);
                            if (mValidLayoutRequesters == null) {
                                mValidLayoutRequesters = new ArrayList<View>();
                            }
                            mValidLayoutRequesters.add(view);
                            break;
                        }
                        if (view.mParent instanceof View) {
                            view = (View) view.mParent;
                        } else {
                            view = null;
                        }
                    }
                }
            }
            if (mValidLayoutRequesters != null) {
                for (int i = 0; i < numViewsRequestingLayout; ++i) {
                    View view = mLayoutRequesters.get(i);
                    while (view != null && (view.mPrivateFlags & View.PFLAG_FORCE_LAYOUT) != 0) {
                        view.mPrivateFlags &= ~View.PFLAG_FORCE_LAYOUT;
                        if (view.mParent instanceof View) {
                            view = (View) view.mParent;
                        } else {
                            view = null;
                        }
                    }
                }
                mHandlingLayoutInLayoutRequest = true;
                int numValidRequests = mValidLayoutRequesters.size();
                for (int i = 0; i < numValidRequests; ++i) {
                    mValidLayoutRequesters.get(i).requestLayout();
                }
                measureHierarchy(host, lp, mView.getContext().getResources(), desiredWindowWidth, desiredWindowHeight);
                mInLayout = true;
                host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
                mHandlingLayoutInLayoutRequest = false;
            }
            mLayoutRequesters.clear();
        }
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
    mInLayout = false;
}

Output:
         if (numViewsRequestingLayout > 0) {
-            ArrayList<View> mValidLayoutRequesters = null;
-            for (int i = 0; i < numViewsRequestingLayout; ++i) {
-                View view = mLayoutRequesters.get(i);
-                if ((view.mPrivateFlags & View.PFLAG_FORCE_LAYOUT) == View.PFLAG_FORCE_LAYOUT) {
-                    while (view != null && view.mAttachInfo != null && view.mParent != null && (view.mPrivateFlags & View.PFLAG_FORCE_LAYOUT) != 0) {
-                        if ((view.mViewFlags & View.VISIBILITY_MASK) != View.GONE) {
-                            Log.w(TAG, "String_Node_Str" + "String_Node_Str" + view);
-                            if (mValidLayoutRequesters == null) {
-                                mValidLayoutRequesters = new ArrayList<View>();
-                            }
-                            mValidLayoutRequesters.add(view);
-                            break;
-                        }
-                        if (view.mParent instanceof View) {
-                            view = (View) view.mParent;
-                        } else {
-                            view = null;
-                        }
-                    }
-                }
-            }
-            if (mValidLayoutRequesters != null) {
-                for (int i = 0; i < numViewsRequestingLayout; ++i) {
-                    View view = mLayoutRequesters.get(i);
-                    while (view != null && (view.mPrivateFlags & View.PFLAG_FORCE_LAYOUT) != 0) {
-                        view.mPrivateFlags &= ~View.PFLAG_FORCE_LAYOUT;
-                        if (view.mParent instanceof View) {
-                            view = (View) view.mParent;
-                        } else {
-                            view = null;
-                        }
-                    }
-                }
+            ArrayList<View> validLayoutRequesters = getValidLayoutRequesters(mLayoutRequesters, false);
+            if (validLayoutRequesters != null) {
                 mHandlingLayoutInLayoutRequest = true;


Input:
public void startContent(IContent content) throws BirtException {
    boolean isInline = PropertyUtil.isInlineElement(content);
    if (isInline) {
        if (current.isInlineStacking()) {
        } else {
            setContainer(af.createLineArea(current, context));
        }
    } else {
        if (current.isInlineStacking()) {
            while (current.isInlineStacking()) {
                closeContainer();
            }
        }
    }
    ILayout layout = af.createLayout(current, context, content);
    if (layout != null) {
        layout.layout();
    }
}

Output:
     if (isInline) {
-        if (current.isInlineStacking()) {
+        if (!unfinishedContents.isEmpty() && content.getParent() == unfinishedContents.peek()) {
+            IContent parent = unfinishedContents.poll();
+            _startContainer(parent);
         } else {


Input:
private void createWidget(final Composite parent) {
    final Color labelColor = parent.getBackground();
    final Font fFont = adjustFont(parent);
    final int initalWidth = 10;
    final GridLayout gridLayout = new GridLayout();
    gridLayout.numColumns = 3;
    gridLayout.marginHeight = 0;
    gridLayout.marginWidth = 0;
    gridLayout.marginTop = 0;
    gridLayout.horizontalSpacing = 0;
    gridLayout.verticalSpacing = 0;
    gridLayout.marginLeft = 0;
    gridLayout.marginRight = 0;
    final Composite composite = new Composite(parent, SWT.FILL);
    composite.setLayout(gridLayout);
    GridData gridData = new GridData();
    gridData.horizontalAlignment = SWT.FILL;
    gridData.verticalAlignment = SWT.FILL;
    gridData.grabExcessHorizontalSpace = true;
    composite.setLayoutData(gridData);
    gridData = new GridData();
    gridData.horizontalAlignment = SWT.RIGHT;
    gridData.verticalAlignment = SWT.TOP;
    fMaxNbEventsText = new Text(composite, SWT.READ_ONLY | SWT.RIGHT);
    fMaxNbEventsText.setFont(fFont);
    fMaxNbEventsText.setBackground(labelColor);
    fMaxNbEventsText.setEditable(false);
    fMaxNbEventsText.setText("String_Node_Str");
    fMaxNbEventsText.setLayoutData(gridData);
    gridData = new GridData();
    gridData.horizontalSpan = 2;
    gridData.verticalSpan = 2;
    gridData.horizontalAlignment = SWT.FILL;
    gridData.verticalAlignment = SWT.FILL;
    gridData.grabExcessHorizontalSpace = true;
    fCanvas = new Canvas(composite, SWT.BORDER | SWT.DOUBLE_BUFFERED);
    fCanvas.setLayoutData(gridData);
    gridData = new GridData();
    gridData.horizontalAlignment = SWT.RIGHT;
    gridData.verticalAlignment = SWT.BOTTOM;
    fMinNbEventsText = new Text(composite, SWT.READ_ONLY | SWT.RIGHT);
    fMinNbEventsText.setFont(fFont);
    fMinNbEventsText.setBackground(labelColor);
    fMinNbEventsText.setEditable(false);
    fMinNbEventsText.setText("String_Node_Str");
    fMinNbEventsText.setLayoutData(gridData);
    gridData = new GridData(initalWidth, SWT.DEFAULT);
    gridData.horizontalAlignment = SWT.RIGHT;
    gridData.verticalAlignment = SWT.BOTTOM;
    final Text dummyText = new Text(composite, SWT.READ_ONLY);
    dummyText.setFont(fFont);
    dummyText.setBackground(labelColor);
    dummyText.setEditable(false);
    dummyText.setText("String_Node_Str");
    dummyText.setLayoutData(gridData);
    gridData = new GridData();
    gridData.horizontalAlignment = SWT.LEFT;
    gridData.verticalAlignment = SWT.BOTTOM;
    fTimeRangeStartText = new Text(composite, SWT.READ_ONLY);
    fTimeRangeStartText.setFont(fFont);
    fTimeRangeStartText.setBackground(labelColor);
    fTimeRangeStartText.setText(HistogramUtils.nanosecondsToString(0));
    fTimeRangeStartText.setLayoutData(gridData);
    gridData = new GridData();
    gridData.horizontalAlignment = SWT.RIGHT;
    gridData.verticalAlignment = SWT.BOTTOM;
    fTimeRangeEndText = new Text(composite, SWT.READ_ONLY);
    fTimeRangeEndText.setFont(fFont);
    fTimeRangeEndText.setBackground(labelColor);
    fTimeRangeEndText.setText(HistogramUtils.nanosecondsToString(0));
    fTimeRangeEndText.setLayoutData(gridData);
}

Output:
     gridData.grabExcessHorizontalSpace = true;
-    fCanvas = new Canvas(composite, SWT.BORDER | SWT.DOUBLE_BUFFERED);
-    fCanvas.setLayoutData(gridData);
+    canvasComposite.setLayoutData(gridData);
+    canvasComposite.setLayout(new FillLayout());
+    fCanvas = new Canvas(canvasComposite, SWT.DOUBLE_BUFFERED);
     gridData = new GridData();


Input:
public boolean isInterruptableBy(PA_Task otherTask) {
    if (otherTask instanceof P_Task_Read || otherTask instanceof P_Task_Write) {
        if (otherTask.getPriority().ordinal() > PE_TaskPriority.FOR_NORMAL_READS_WRITES.ordinal()) {
            return true;
        } else if (otherTask.getPriority().ordinal() >= this.getPriority().ordinal()) {
            return this.getTotalTimeExecuting() >= getMinimumScanTime();
        }
    } else {
        return otherTask.getPriority().ordinal() > this.getPriority().ordinal();
    }
    return super.isInterruptableBy(otherTask);
}

Output:
 public boolean isInterruptableBy(PA_Task otherTask) {
-    if (otherTask instanceof P_Task_Read || otherTask instanceof P_Task_Write) {
+    if (otherTask instanceof P_Task_Read || otherTask instanceof P_Task_Write || otherTask instanceof P_Task_ReadRssi) {
         if (otherTask.getPriority().ordinal() > PE_TaskPriority.FOR_NORMAL_READS_WRITES.ordinal()) {


Input:
private static Set<ExpensesKey<?>> get() {
    if (instance == null) {
        instance = new HashSet<ExpensesKey<?>>();
        instance.add(ReportKey.get());
        instance.add(EmployeeKey.get());
    }
    return instance;
}

Output:
     if (instance == null) {
-        instance = new HashSet<ExpensesKey<?>>();
-        instance.add(ReportKey.get());
-        instance.add(EmployeeKey.get());
+        HashSet<ExpensesKey<?>> newInstance = new HashSet<ExpensesKey<?>>();
+        newInstance.add(ReportKey.get());
+        newInstance.add(EmployeeKey.get());
+        instance = newInstance;
     }


Input:
private ExtractorConfig<Cells> retrieveConfiguration(ClusterName clusterName) throws ExecutionException {
    DeepConnection deepConnection = null;
    try {
        deepConnection = (DeepConnection) deepConnectionHandler.getConnection(clusterName.getName());
    } catch (HandlerConnectionException ex) {
        throw new ExecutionException("String_Node_Str" + clusterName.toString() + "String_Node_Str", ex);
    }
    ExtractorConfig<Cells> extractorConfig = null;
    if (deepConnection != null) {
        extractorConfig = deepConnection.getExtractorConfig();
    } else {
        throw new ExecutionException("String_Node_Str" + clusterName.toString() + "String_Node_Str");
    }
    return extractorConfig;
}

Output:
     if (deepConnection != null) {
-        extractorConfig = deepConnection.getExtractorConfig();
+        extractorConfig = deepConnection.getExtractorConfig().clone();
     } else {


Input:
public void processCommand(ICommandSender commandSender, String[] args) {
    if (args.length < 3) {
        throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_USAGE);
    } else {
        float energyValue = 0;
        if (args.length >= 3) {
            energyValue = (float) parseDoubleWithMin(commandSender, args[2], 0);
        }
        ItemStack itemStack = ((EntityPlayer) commandSender).getCurrentEquippedItem();
        if (itemStack != null) {
            WrappedStack wrappedStack = WrappedStack.wrap(itemStack);
            EnergyValue newEnergyValue = new EnergyValue(energyValue);
            if (wrappedStack != null && newEnergyValue != null && Float.compare(newEnergyValue.getValue(), 0) > 0) {
                if (args[1].equalsIgnoreCase("String_Node_Str")) {
                    EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue, EnergyValueRegistryProxy.Phase.PRE_CALCULATION);
                } else if (args[1].equalsIgnoreCase("String_Node_Str")) {
                    EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue);
                } else {
                    throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_USAGE);
                }
                func_152373_a(commandSender, this, Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_SUCCESS, new Object[] { commandSender.getCommandSenderName(), args[1], itemStack.func_151000_E(), newEnergyValue.getChatComponent() });
            } else {
                throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_USAGE);
            }
            EnergyValueRegistry.INSTANCE.save();
        } else {
            throw new WrongUsageException(Messages.Commands.NO_ITEM);
        }
    }
}

Output:
             EnergyValue newEnergyValue = new EnergyValue(energyValue);
-            if (wrappedStack != null && newEnergyValue != null && Float.compare(newEnergyValue.getValue(), 0) > 0) {
-                if (args[1].equalsIgnoreCase("String_Node_Str")) {
-                    EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue, EnergyValueRegistryProxy.Phase.PRE_CALCULATION);
-                } else if (args[1].equalsIgnoreCase("String_Node_Str")) {
-                    EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue);
-                } else {
-                    throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_USAGE);
+            if (wrappedStack != null && newEnergyValue != null) {
+                if (Float.compare(newEnergyValue.getValue(), 0) > 0) {
+                    if (args[1].equalsIgnoreCase("String_Node_Str")) {
+                        EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue, EnergyValueRegistryProxy.Phase.PRE_CALCULATION);
+                    } else if (args[1].equalsIgnoreCase("String_Node_Str")) {
+                        EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue);
+                    } else {
+                        throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_USAGE);
+                    }
+                    func_152373_a(commandSender, this, Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_SUCCESS, new Object[] { commandSender.getCommandSenderName(), args[1], itemStack.func_151000_E(), newEnergyValue.getChatComponent() });
+                } else if (Float.compare(newEnergyValue.getValue(), 0) == 0) {
+                    BlacklistRegistryProxy.setAsNotLearnable(wrappedStack);
+                    BlacklistRegistryProxy.setAsNotExchangeable(wrappedStack);
+                    func_152373_a(commandSender, this, "String_Node_Str", new Object[] { commandSender.getCommandSenderName(), itemStack.func_151000_E() });
                 }


Input:
public String getSessionId() {
    return sessionId;
}

Output:
 public String getSessionId() {
-    return sessionId;
+    return client.getSession().getSessionId();
 }


Input:
private final void crossValues(final Iterator<PactRecord> values, final OutputCollector out) throws Exception {
    final PactRecord[] valBuffer = new PactRecord[VALUE_BUFFER_SIZE];
    int bufferValCnt;
    for (bufferValCnt = 0; bufferValCnt < VALUE_BUFFER_SIZE; bufferValCnt++) {
        if (values.hasNext()) {
            valBuffer[bufferValCnt] = values.next().createCopy();
        } else {
            break;
        }
    }
    for (int i = 0; i < bufferValCnt; i++) {
        if (!this.running)
            return;
        for (int j = 0; j < bufferValCnt; j++) {
            if (!this.running)
                return;
            stub.match(valBuffer[i].createCopy(), valBuffer[j].createCopy(), out);
        }
    }
    if (this.running && values.hasNext()) {
        MutableObjectIterator<PactRecord> valReader = new MutableObjectIterator<PactRecord>() {
            public boolean next(PactRecord target) throws IOException {
                if (!running || !values.hasNext()) {
                    return false;
                }
                values.next().copyTo(target);
                for (int i = 0; i < VALUE_BUFFER_SIZE; i++) {
                    try {
                        stub.match(valBuffer[i].createCopy(), target.createCopy(), out);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                return true;
            }
        };
        SpillingResettableMutableObjectIterator outerValResettableIterator = null;
        SpillingResettableMutableObjectIterator innerValResettableIterator = null;
        try {
            outerValResettableIterator = new SpillingResettableMutableObjectIterator(memoryManager, ioManager, valReader, (long) (availableMemory * (MEMORY_SHARE_RATIO / 2)), this);
            outerValResettableIterator.open();
            BufferIncludingIterator bii = new BufferIncludingIterator(valBuffer, outerValResettableIterator);
            PactRecord outerRecord = new PactRecord();
            PactRecord innerRecord = new PactRecord();
            if (this.running && outerValResettableIterator.next(outerRecord)) {
                innerValResettableIterator = new SpillingResettableMutableObjectIterator(memoryManager, ioManager, bii, (long) (availableMemory * (MEMORY_SHARE_RATIO / 2)), this);
                innerValResettableIterator.open();
                outerValResettableIterator.reset();
                while (this.running && outerValResettableIterator.next(outerRecord)) {
                    bufferValCnt = 0;
                    do {
                        outerRecord.copyTo(valBuffer[bufferValCnt++]);
                    } while (this.running && outerValResettableIterator.next(outerRecord) && bufferValCnt < VALUE_BUFFER_SIZE);
                    if (bufferValCnt == 0)
                        break;
                    while (this.running && innerValResettableIterator.next(innerRecord)) {
                        for (int i = 0; i < bufferValCnt; i++) {
                            stub.match(valBuffer[i].createCopy(), innerRecord, out);
                            if (i < bufferValCnt - 1)
                                innerValResettableIterator.repeatLast(innerRecord);
                        }
                    }
                    innerValResettableIterator.reset();
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (innerValResettableIterator != null) {
                innerValResettableIterator.close();
            }
            if (outerValResettableIterator != null) {
                outerValResettableIterator.close();
            }
        }
    }
}

Output:
             PactRecord innerRecord = new PactRecord();
-            if (this.running && outerValResettableIterator.next(outerRecord)) {
+            if (this.running) {
                 innerValResettableIterator = new SpillingResettableMutableObjectIterator(memoryManager, ioManager, bii, (long) (availableMemory * (MEMORY_SHARE_RATIO / 2)), this);


Input:
public RoaringBitmap inplace_newand() {
    bitmap1.newand(bitmap2);
}

Output:
 public RoaringBitmap inplace_newand() {
-    bitmap1.newand(bitmap2);
+    RoaringBitmap b1 = bitmap1.clone();
+    b1.newand(bitmap2);
+    return b1;
 }


Input:
public void createDocumentWaitForSync() {
    final DocumentCreate.Options options = new DocumentCreate.Options().waitForSync(true);
    final DocumentCreateResult<TestEntity> doc = db.collection(COLLECTION_NAME).createDocument(new TestEntity(), options).execute();
    assertThat(doc, is(notNullValue()));
    assertThat(doc.getId(), is(notNullValue()));
    assertThat(doc.getKey(), is(notNullValue()));
    assertThat(doc.getRev(), is(notNullValue()));
    assertThat(doc.getNew().isPresent(), is(false));
}

Output:
     final DocumentCreate.Options options = new DocumentCreate.Options().waitForSync(true);
-    final DocumentCreateResult<TestEntity> doc = db.collection(COLLECTION_NAME).createDocument(new TestEntity(), options).execute();
+    final DocumentCreateResult<BaseDocument> doc = db.collection(COLLECTION_NAME).createDocument(new BaseDocument(), options).execute();
     assertThat(doc, is(notNullValue()));