Input:
public void computeTileStack(Map<Band, Tile> targetTiles, Rectangle targetRectangle, ProgressMonitor pm) throws OperatorException {
    processingStarted = true;
    final int x0 = targetRectangle.x;
    final int y0 = targetRectangle.y;
    final int w = targetRectangle.width;
    final int h = targetRectangle.height;
    final int ymax = y0 + h;
    final int xmax = x0 + w;
    final GeoPos geoPos = new GeoPos();
    final PosVector earthPoint = new PosVector();
    final PosVector sensorPos = new PosVector();
    final int srcMaxRange = sourceImageWidth - 1;
    final int srcMaxAzimuth = sourceImageHeight - 1;
    ProductData demBuffer = null;
    ProductData latBuffer = null;
    ProductData lonBuffer = null;
    ProductData localIncidenceAngleBuffer = null;
    ProductData projectedLocalIncidenceAngleBuffer = null;
    ProductData layoverShadowingMasksBuffer = null;
    ProductData incidenceAngleFromEllipsoidBuffer = null;
    final Set<Band> keySet = targetTiles.keySet();
    if (!warpDataAvailable) {
        getWarpData(keySet, targetRectangle);
        outputResidualAndShiftFiles();
    }
    final List<RangeDopplerGeocodingOp.TileData> trgTileList = new ArrayList<>();
    for (Band targetBand : keySet) {
        if (targetBand.getName().equals("String_Node_Str")) {
            demBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        if (targetBand.getName().equals("String_Node_Str")) {
            latBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        if (targetBand.getName().equals("String_Node_Str")) {
            lonBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        if (targetBand.getName().equals("String_Node_Str")) {
            localIncidenceAngleBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        if (targetBand.getName().equals("String_Node_Str")) {
            projectedLocalIncidenceAngleBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        if (targetBand.getName().equals(SARSimulationOp.layoverShadowMaskBandName)) {
            layoverShadowingMasksBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        if (targetBand.getName().equals("String_Node_Str")) {
            incidenceAngleFromEllipsoidBuffer = targetTiles.get(targetBand).getDataBuffer();
            continue;
        }
        final String[] srcBandNames = targetBandNameToSourceBandName.get(targetBand.getName());
        final Band[] srcBands = new Band[] { sourceProduct.getBand(srcBandNames[0]), srcBandNames.length > 1 ? sourceProduct.getBand(srcBandNames[1]) : null };
        final RangeDopplerGeocodingOp.TileData td = new RangeDopplerGeocodingOp.TileData(targetTiles.get(targetBand), srcBands, isPolsar, targetBand.getName(), getBandUnit(targetBand.getName()), absRoot, calibrator, imgResampling);
        td.applyRadiometricNormalization = targetBandapplyRadiometricNormalizationFlag.get(targetBand.getName());
        td.applyRetroCalibration = targetBandApplyRetroCalibrationFlag.get(targetBand.getName());
        trgTileList.add(td);
    }
    final RangeDopplerGeocodingOp.TileData[] trgTiles = trgTileList.toArray(new RangeDopplerGeocodingOp.TileData[trgTileList.size()]);
    final TileGeoreferencing tileGeoRef = new TileGeoreferencing(targetProduct, x0 - 1, y0 - 1, w + 2, h + 2);
    int diffLat = Math.abs(latitude.getPixelInt(0, 0) - latitude.getPixelInt(0, targetImageHeight));
    try {
        final double[][] localDEM = new double[h + 2][w + 2];
        if (useAvgSceneHeight) {
            DEMFactory.fillDEM(localDEM, avgSceneHeight);
        } else {
            final boolean valid = DEMFactory.getLocalDEM(dem, demNoDataValue, demResamplingMethod, tileGeoRef, x0, y0, w, h, sourceProduct, true, localDEM);
            if (!valid)
                return;
        }
        for (int y = y0; y < ymax; y++) {
            final int yy = y - y0 + 1;
            for (int x = x0; x < xmax; x++) {
                final int index = trgTiles[0].targetTile.getDataBufferIndex(x, y);
                final double alt = localDEM[yy][x - x0 + 1];
                if (!useAvgSceneHeight && alt == demNoDataValue) {
                    if (saveDEM) {
                        demBuffer.setElemDoubleAt(index, demNoDataValue);
                    }
                    continue;
                }
                tileGeoRef.getGeoPos(x, y, geoPos);
                if (!geoPos.isValid()) {
                    continue;
                }
                final double lat = geoPos.lat;
                double lon = geoPos.lon;
                if (lon >= 180.0) {
                    lon -= 360.0;
                }
                GeoUtils.geo2xyzWGS84(lat, lon, alt, earthPoint);
                final double zeroDopplerTime = getEarthPointZeroDopplerTime(earthPoint);
                if (Double.compare(zeroDopplerTime, NonValidZeroDopplerTime) == 0) {
                    if (saveDEM) {
                        demBuffer.setElemDoubleAt(index, demNoDataValue);
                    }
                    continue;
                }
                double slantRange = SARGeocoding.computeSlantRange(zeroDopplerTime, orbit, earthPoint, sensorPos);
                double zeroDoppler = zeroDopplerTime;
                if (!skipBistaticCorrection) {
                    zeroDoppler = zeroDopplerTime + slantRange / Constants.lightSpeedInMetersPerDay;
                    slantRange = SARGeocoding.computeSlantRange(zeroDoppler, orbit, earthPoint, sensorPos);
                }
                final double azimuthIndex = (zeroDoppler - firstLineUTC) / lineTimeInterval;
                double rangeIndex = SARGeocoding.computeRangeIndex(srgrFlag, sourceImageWidth, firstLineUTC, lastLineUTC, rangeSpacing, zeroDoppler, slantRange, nearEdgeSlantRange, srgrConvParams);
                if (!nearRangeOnLeft) {
                    rangeIndex = srcMaxRange - rangeIndex;
                }
                if (!SARGeocoding.isValidCell(rangeIndex, azimuthIndex, lat, lon, diffLat, latitude, longitude, srcMaxRange, srcMaxAzimuth, sensorPos)) {
                    if (saveDEM) {
                        demBuffer.setElemDoubleAt(index, demNoDataValue);
                    }
                } else {
                    final double[] localIncidenceAngles = { SARGeocoding.NonValidIncidenceAngle, SARGeocoding.NonValidIncidenceAngle };
                    if (saveLocalIncidenceAngle || saveProjectedLocalIncidenceAngle || saveSigmaNought) {
                        final LocalGeometry localGeometry = new LocalGeometry(x, y, tileGeoRef, earthPoint, sensorPos);
                        SARGeocoding.computeLocalIncidenceAngle(localGeometry, demNoDataValue, saveLocalIncidenceAngle, saveProjectedLocalIncidenceAngle, saveSigmaNought, x0, y0, x, y, localDEM, localIncidenceAngles);
                        if (saveLocalIncidenceAngle && localIncidenceAngles[0] != SARGeocoding.NonValidIncidenceAngle) {
                            localIncidenceAngleBuffer.setElemDoubleAt(index, localIncidenceAngles[0]);
                        }
                        if (saveProjectedLocalIncidenceAngle && localIncidenceAngles[1] != SARGeocoding.NonValidIncidenceAngle) {
                            projectedLocalIncidenceAngleBuffer.setElemDoubleAt(index, localIncidenceAngles[1]);
                        }
                    }
                    if (saveDEM) {
                        demBuffer.setElemDoubleAt(index, alt);
                    }
                    if (saveLatLon) {
                        latBuffer.setElemDoubleAt(index, lat);
                        lonBuffer.setElemDoubleAt(index, lon);
                    }
                    if (saveLayoverShadowMask) {
                        final Rectangle srcRect = new Rectangle((int) (rangeIndex + 0.5), (int) (azimuthIndex + 0.5), 1, 1);
                        final Tile sourceTile = getSourceTile(maskBand, srcRect);
                        final int m = sourceTile.getDataBuffer().getElemIntAt(sourceTile.getDataBufferIndex((int) (rangeIndex + 0.5), (int) (azimuthIndex + 0.5)));
                        layoverShadowingMasksBuffer.setElemIntAt(index, m);
                    }
                    if (saveIncidenceAngleFromEllipsoid) {
                        incidenceAngleFromEllipsoidBuffer.setElemDoubleAt(index, incidenceAngle.getPixelDouble(rangeIndex, azimuthIndex));
                    }
                    for (RangeDopplerGeocodingOp.TileData tileData : trgTiles) {
                        final Unit.UnitType bandUnit = getBandUnit(tileData.bandName);
                        final String[] srcBandName = targetBandNameToSourceBandName.get(tileData.bandName);
                        final Band srcBand = sourceProduct.getBand(srcBandName[0]);
                        final PixelPos pixelPos = new PixelPos();
                        final WarpOp.WarpData warpData = warpDataMap.get(srcBand);
                        if (warpData.notEnoughGCPs) {
                            continue;
                        }
                        WarpOp.getWarpedCoords(warpData, warpPolynomialOrder, rangeIndex, azimuthIndex, pixelPos);
                        if (pixelPos.x < 0.0 || pixelPos.x >= srcMaxRange || pixelPos.y < 0.0 || pixelPos.y >= srcMaxAzimuth) {
                            tileData.tileDataBuffer.setElemDoubleAt(index, tileData.noDataValue);
                            continue;
                        }
                        final int[] subSwathIndex = { INVALID_SUB_SWATH_INDEX };
                        double v = getPixelValue(pixelPos.y, pixelPos.x, tileData, subSwathIndex);
                        if (v != tileData.noDataValue && tileData.applyRadiometricNormalization) {
                            if (localIncidenceAngles[1] != SARGeocoding.NonValidIncidenceAngle) {
                                final double satelliteHeight = Math.sqrt(sensorPos.x * sensorPos.x + sensorPos.y * sensorPos.y + sensorPos.z * sensorPos.z);
                                final double sceneToEarthCentre = Math.sqrt(earthPoint.x * earthPoint.x + earthPoint.y * earthPoint.y + earthPoint.z * earthPoint.z);
                                v = calibrator.applyCalibration(v, rangeIndex, azimuthIndex, slantRange, satelliteHeight, sceneToEarthCentre, localIncidenceAngles[1], tileData.bandPolar, bandUnit, subSwathIndex);
                            } else {
                                v = tileData.noDataValue;
                            }
                        }
                        tileData.tileDataBuffer.setElemDoubleAt(index, v);
                    }
                    orthoDataProduced = true;
                }
            }
        }
    } catch (Throwable e) {
        orthoDataProduced = true;
        OperatorUtils.catchOperatorException(getId(), e);
    }
}

Output:
                                 final double sceneToEarthCentre = Math.sqrt(earthPoint.x * earthPoint.x + earthPoint.y * earthPoint.y + earthPoint.z * earthPoint.z);
-                                v = calibrator.applyCalibration(v, rangeIndex, azimuthIndex, slantRange, satelliteHeight, sceneToEarthCentre, localIncidenceAngles[1], tileData.bandPolar, bandUnit, subSwathIndex);
+                                v = calibrator.applyCalibration(v, rangeIndex, azimuthIndex, slantRange, satelliteHeight, sceneToEarthCentre, localIncidenceAngles[1], tileData.bandName, tileData.bandPolar, bandUnit, subSwathIndex);
                             } else {


Input:
private SyncanoObject createSyncanoObject(Class<? extends SyncanoObject> clazz) {
    try {
        Constructor<? extends SyncanoObject> defaultConstructor = clazz.getConstructor();
        return defaultConstructor.newInstance();
    } catch (Exception e) {
        return new Gson().fromJson("String_Node_Str", clazz);
    }
}

Output:
     } catch (Exception e) {
-        return new Gson().fromJson("String_Node_Str", clazz);
+        Gson gson = new GsonBuilder().setFieldNamingStrategy(new SyncanoFieldNamingStrategy()).create();
+        return gson.fromJson("String_Node_Str", clazz);
     }


Input:
private void unmark() {
    try {
        int i = currentMode[index];
        switch(i) {
            case 0:
                singel.setStyle("String_Node_Str");
                break;
            case 1:
                serien.setStyle("String_Node_Str");
                break;
            case 2:
                ontime.setStyle("String_Node_Str");
                singel.setStyle("String_Node_Str");
                break;
        }
    } catch (NullPointerException n) {
        LOGGER.error("String_Node_Str", n);
    }
}

Output:
     try {
-        int i = currentMode[index];
+        int i = currentMode;
         switch(i) {


Input:
public final void run() {
    try {
        while (live) {
            threadWatcher.incrementRunCount();
            long currentMillis = System.currentTimeMillis();
            if ((currentMillis - lastPublish) > TEN_SECOND_MILLIS) {
                publishUtilization();
                lastPublish = currentMillis;
            }
            processSelectionQueue();
            if (!live)
                return;
            int selectedKeyCount;
            try {
                long startWait = System.nanoTime();
                selectedKeyCount = selector.select(waitTime);
                long now = System.nanoTime();
                threadWatcher.addWait((now - startWait), now);
                if (Thread.interrupted()) {
                    node.handleInterruptedException(Thread.currentThread(), new RuntimeException());
                    return;
                }
            } catch (Throwable exp) {
                continue;
            }
            if (selectedKeyCount == 0) {
                continue;
            }
            final Set<SelectionKey> setSelectedKeys = selector.selectedKeys();
            final Iterator<SelectionKey> it = setSelectedKeys.iterator();
            while (it.hasNext()) {
                final SelectionKey sk = it.next();
                it.remove();
                try {
                    if (sk.isValid()) {
                        sk.interestOps(sk.interestOps() & ~sk.readyOps());
                        SelectionHandler selectionHandler = (SelectionHandler) sk.attachment();
                        selectionHandler.handle();
                    }
                } catch (CancelledKeyException e) {
                } catch (Throwable e) {
                    handleSelectorException(e);
                }
            }
        }
    } catch (OutOfMemoryError e) {
        node.onOutOfMemory(e);
    } catch (Throwable e) {
        logger.log(Level.WARNING, "String_Node_Str" + Thread.currentThread().getName(), e);
    } finally {
        try {
            logger.log(Level.FINE, "String_Node_Str" + Thread.currentThread().getName());
            selector.close();
        } catch (final Exception ignored) {
        }
    }
}

Output:
                     if (sk.isValid()) {
-                        sk.interestOps(sk.interestOps() & ~sk.readyOps());
+                        if (!sk.isReadable())
+                            sk.interestOps(sk.interestOps() & ~sk.readyOps());
                         SelectionHandler selectionHandler = (SelectionHandler) sk.attachment();


Input:
public static List createSourceContent(String propertyName, String labelingScheme, ILaunchConfiguration config) throws CoreException {
    Vector result = new Vector();
    String value = config.getAttribute(propertyName, EMPTY_STRING);
    if (EMPTY_STRING.equals(value)) {
        return result;
    }
    String identifier = getValidIdentifier(labelingScheme);
    StringBuffer buffer = new StringBuffer();
    buffer.append(identifier).append(DEFINES_CR);
    buffer.append(value);
    result.add(new String[] { identifier, buffer.toString() });
    return result;
}

Output:
     String value = config.getAttribute(propertyName, EMPTY_STRING);
-    if (EMPTY_STRING.equals(value)) {
+    if (value.trim().length() == 0) {
         return result;


Input:
public static boolean isADye(ItemStack itemstack) {
    itemstack.stackSize = 0;
    return Arrays.asList(ALL_DYES).contains(itemstack);
}

Output:
 public static boolean isADye(ItemStack itemstack) {
-    itemstack.stackSize = 0;
-    return Arrays.asList(ALL_DYES).contains(itemstack);
+    Item toFind = itemstack.getItem();
+    for (int s = 0; s < ALL_DYES_DYE.length; s++) {
+        for (int z = 0; z < ALL_DYES_DYE[s].setDyes().length; z++) {
+            if (ALL_DYES_DYE[s].setDyes()[z].getItem().equals(toFind)) {
+                return true;
+            }
+        }
+    }
+    return false;
 }


Input:
protected Byte convertObjectToByte(Object sourceObject) throws ConversionException {
    if (sourceObject instanceof String && ((String) sourceObject).length() > 0 && ((String) sourceObject).charAt(0) == PLUS) {
        return super.convertObjectToByte(((String) sourceObject).substring(1));
    }
    return super.convertObjectToByte(sourceObject);
}

Output:
 protected Byte convertObjectToByte(Object sourceObject) throws ConversionException {
-    if (sourceObject instanceof String && ((String) sourceObject).length() > 0 && ((String) sourceObject).charAt(0) == PLUS) {
-        return super.convertObjectToByte(((String) sourceObject).substring(1));
+    if (sourceObject instanceof String) {
+        String sourceString = (String) sourceObject;
+        if (sourceString.length() == 0) {
+            return 0;
+        } else if (sourceString.charAt(0) == PLUS) {
+            return super.convertObjectToByte(sourceString.substring(1));
+        }
     }


Input:
public void noJobMapPrincipal() {
    List<Owner> owners = new ArrayList<Owner>();
    owners.add(new Owner("String_Node_Str"));
    Principal principal = new UserPrincipal("String_Node_Str", owners, null);
    when(this.principalProvider.get()).thenReturn(principal);
    JobDetail detail = new JobDetail();
    when(response.getEntity()).thenReturn(detail);
    this.interceptor.postProcess(response);
    Assert.assertEquals(principal, detail.getJobDataMap().get(PinsetterJobListener.PRINCIPAL_KEY));
}

Output:
 public void noJobMapPrincipal() {
-    List<Owner> owners = new ArrayList<Owner>();
-    owners.add(new Owner("String_Node_Str"));
-    Principal principal = new UserPrincipal("String_Node_Str", owners, null);
+    List<Permission> permissions = Arrays.asList(new Permission[] { new Permission(new Owner("String_Node_Str"), EnumSet.of(Role.OWNER_ADMIN)) });
+    Principal principal = new UserPrincipal("String_Node_Str", permissions);
     when(this.principalProvider.get()).thenReturn(principal);


Input:
public GetField readFields() throws IOException, ClassNotFoundException {
    if (!state.compareAndSet(State.UNREAD_FIELDS, State.ON)) {
        throw new NotActiveException("String_Node_Str");
    }
    final SerializableField[] streamFields = serializableClassDescriptor.getFields();
    final int cnt = streamFields.length;
    final ReadField[] readFields = new ReadField[cnt];
    for (int i = 0; i < cnt; i++) {
        SerializableField field = streamFields[i];
        try {
            switch(field.getKind()) {
                case BOOLEAN:
                    {
                        readFields[i] = new BooleanReadField(field, unmarshaller.readBoolean());
                        break;
                    }
                case BYTE:
                    {
                        readFields[i] = new ByteReadField(field, unmarshaller.readByte());
                        break;
                    }
                case CHAR:
                    {
                        readFields[i] = new CharReadField(field, unmarshaller.readChar());
                        break;
                    }
                case DOUBLE:
                    {
                        readFields[i] = new DoubleReadField(field, unmarshaller.readDouble());
                        break;
                    }
                case FLOAT:
                    {
                        readFields[i] = new FloatReadField(field, unmarshaller.readFloat());
                        break;
                    }
                case INT:
                    {
                        readFields[i] = new IntReadField(field, unmarshaller.readInt());
                        break;
                    }
                case LONG:
                    {
                        readFields[i] = new LongReadField(field, unmarshaller.readLong());
                        break;
                    }
                case OBJECT:
                    {
                        readFields[i] = new ObjectReadField(field, unmarshaller.readObject());
                        break;
                    }
                case SHORT:
                    {
                        readFields[i] = new ShortReadField(field, unmarshaller.readShort());
                        break;
                    }
                default:
                    throw new IllegalStateException("String_Node_Str");
            }
        } catch (IOException e) {
            TraceInformation.addFieldInformation(e, field.getName());
            throw e;
        } catch (ClassNotFoundException e) {
            TraceInformation.addFieldInformation(e, field.getName());
            throw e;
        } catch (RuntimeException e) {
            TraceInformation.addFieldInformation(e, field.getName());
            throw e;
        }
    }
    return new GetField() {
        public ObjectStreamClass getObjectStreamClass() {
            throw new UnsupportedOperationException("String_Node_Str");
        }
        private ReadField find(final String name) {
            if (name == null) {
                throw new NullPointerException("String_Node_Str");
            }
            for (ReadField field : readFields) {
                if (name.equals(field.getName())) {
                    return field;
                }
            }
            throw new IllegalArgumentException("String_Node_Str" + name + "String_Node_Str");
        }
        public boolean defaulted(final String name) throws IOException {
            return find(name).isDefaulted();
        }
        public boolean get(final String name, final boolean val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getBoolean();
        }
        public byte get(final String name, final byte val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getByte();
        }
        public char get(final String name, final char val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getChar();
        }
        public short get(final String name, final short val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getShort();
        }
        public int get(final String name, final int val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getInt();
        }
        public long get(final String name, final long val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getLong();
        }
        public float get(final String name, final float val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getFloat();
        }
        public double get(final String name, final double val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getDouble();
        }
        public Object get(final String name, final Object val) throws IOException {
            final ReadField field = find(name);
            return field.isDefaulted() ? val : field.getObject();
        }
    };
}

Output:
 public GetField readFields() throws IOException, ClassNotFoundException {
-    if (!state.compareAndSet(State.UNREAD_FIELDS, State.ON)) {
-        throw new NotActiveException("String_Node_Str");
+    State old = state.getAndSet(State.ON);
+    switch(old) {
+        case UNREAD_FIELDS:
+        case UNREAD_FIELDS_EOB:
+            break;
+        default:
+            throw new NotActiveException("String_Node_Str");
     }


Input:
public IStatus doAction() {
    try {
        if (page.isDirty()) {
            boolean save = MessageDialog.openConfirm(page.getSite().getShell(), "String_Node_Str", "String_Node_Str" + page.getXObject().getDisplayName() + "String_Node_Str");
            if (save)
                page.SaveWithForce(new NullProgressMonitor());
            else
                return Status.CANCEL_STATUS;
        }
        IStructuredSelection selection = (TreeSelection) page.getTreeViewer().getSelection();
        XSDComponent xSDCom = null;
        String conceptName = null;
        if (selection.getFirstElement() instanceof Element) {
            TreePath tPath = ((TreeSelection) selection).getPaths()[0];
            for (int i = 0; i < tPath.getSegmentCount(); i++) {
                if (tPath.getSegment(i) instanceof XSDAnnotation)
                    xSDCom = (XSDAnnotation) (tPath.getSegment(i));
            }
        } else
            xSDCom = (XSDComponent) selection.getFirstElement();
        if (xSDCom instanceof XSDElementDeclaration) {
            conceptName = xSDCom.getElement().getAttributes().getNamedItem("String_Node_Str").getNodeValue();
        }
        if (xSDCom instanceof XSDParticle) {
        }
        XSDAnnotationsStructure struc = null;
        if (xSDCom != null)
            struc = new XSDAnnotationsStructure(xSDCom);
        if (struc == null || struc.getAnnotation() == null) {
            throw new RuntimeException("String_Node_Str" + xSDCom.getClass().getName());
        }
        fkd = getNewFKFilterDialog(page.getSite().getShell(), struc.getFKFilter(), page, conceptName);
        fkd.setBlockOnOpen(true);
        int ret = fkd.open();
        if (ret == Window.CANCEL) {
            return Status.CANCEL_STATUS;
        }
        String fkfilter = fkd.getFilter();
        struc.setFKFilter(fkfilter);
        if (struc.hasChanged()) {
            page.refresh();
            page.getTreeViewer().expandToLevel(xSDCom, 2);
            page.markDirty();
        }
    } catch (Exception e) {
        log.error(e.getMessage(), e);
        MessageDialog.openError(page.getSite().getShell(), "String_Node_Str", "String_Node_Str" + e.getLocalizedMessage());
        return Status.CANCEL_STATUS;
    }
    return Status.OK_STATUS;
}

Output:
         if (page.isDirty()) {
-            boolean save = MessageDialog.openConfirm(page.getSite().getShell(), "String_Node_Str", "String_Node_Str" + page.getXObject().getDisplayName() + "String_Node_Str");
-            if (save)
-                page.SaveWithForce(new NullProgressMonitor());
-            else
+            boolean save = MessageDialog.openConfirm(page.getSite().getShell(), Messages.getString("String_Node_Str"), "String_Node_Str" + page.getXObject().getDisplayName() + "String_Node_Str" + Messages.getString("String_Node_Str"));
+            if (save) {
+                IEditorPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
+                PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().saveEditor(part, false);
+            } else
                 return Status.CANCEL_STATUS;


Input:
private CacheResult fetch(RuleKey ruleKey, LazyPath output) {
    CacheResult artifactFetchResult = maybeFetchArtifact(ruleKey, output);
    if (artifactFetchResult.getType() == CacheResultType.HIT || artifactFetchResult.getType() == CacheResultType.ERROR) {
        return artifactFetchResult;
    } else {
        return fetchMetadata(ruleKey, output);
    }
}

Output:
 private CacheResult fetch(RuleKey ruleKey, LazyPath output) {
-    CacheResult artifactFetchResult = maybeFetchArtifact(ruleKey, output);
-    if (artifactFetchResult.getType() == CacheResultType.HIT || artifactFetchResult.getType() == CacheResultType.ERROR) {
-        return artifactFetchResult;
+    CacheResult artifactResult = fetchContent(ruleKey, output);
+    CacheResult metadataResult = fetchMetadata(ruleKey, output);
+    if (artifactResult.getType().isSuccess() && metadataResult.getType().isSuccess()) {
+        return CacheResult.hit(name, CACHE_MODE, metadataResult.getMetadata(), artifactResult.getArtifactSizeBytes());
+    } else if (artifactResult.getType() == CacheResultType.HIT || artifactResult.getType() == CacheResultType.ERROR) {
+        return artifactResult;
     } else {


Input:
public void insert(int elementId) {
    final DoubleLinkedIntListItem handle = buckets[getRankIdx(elementId)].pushFront(elementId);
    handles[elementId] = handle;
    size++;
}

Output:
 public void insert(int elementId) {
-    final DoubleLinkedIntListItem handle = buckets[getRankIdx(elementId)].pushFront(elementId);
-    handles[elementId] = handle;
+    buckets[getRankIdx(elementId)].pushFront(handles[elementId]);
     size++;


Input:
protected void addPages() {
    switch(analysisType) {
        case COLUMN_CORRELATION:
            masterPage = new ColumnCorrelationNominalAndIntervalMasterPage(this, MASTER_PAGE, ANALYSIS_SETTINGS);
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            resultPage = new ColumnCorrelationNominalIntervalResultPage(this, SECOND_PAGE, ANALYSIS_RESULTS);
            try {
                addPage(masterPage);
                addPage(resultPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        case MULTIPLE_COLUMN:
            masterPage = new ColumnMasterDetailsPage(this, MASTER_PAGE, ANALYSIS_SETTINGS);
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            resultPage = new ColumnAnalysisResultPage(this, SECOND_PAGE, ANALYSIS_RESULTS);
            try {
                addPage(masterPage);
                addPage(resultPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        case CONNECTION:
            masterPage = new ConnectionMasterDetailsPage(this, MASTER_PAGE, ANALYSIS_SETTINGS);
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            try {
                addPage(masterPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        case CATALOG:
            masterPage = new CatalogMasterDetailsPage(this, MASTER_PAGE, ANALYSIS_SETTINGS);
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            try {
                addPage(masterPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        case SCHEMA:
            masterPage = new SchemaAnalysisMasterDetailsPage(this, MASTER_PAGE, ANALYSIS_SETTINGS);
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            try {
                addPage(masterPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        case COLUMNS_COMPARISON:
            masterPage = new ColumnsComparisonMasterDetailsPage(this, MASTER_PAGE, DefaultMessagesImpl.getString("String_Node_Str"));
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            resultPage = new ColumnsComparisonAnalysisResultPage(this, SECOND_PAGE, ANALYSIS_RESULTS);
            try {
                addPage(masterPage);
                addPage(resultPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        case TABLE:
            masterPage = new TableMasterDetailsPage(this, MASTER_PAGE, ANALYSIS_SETTINGS);
            setPartName(DefaultMessagesImpl.getString("String_Node_Str"));
            resultPage = new TableAnalysisResultPage(this, SECOND_PAGE, ANALYSIS_RESULTS);
            try {
                addPage(masterPage);
                addPage(resultPage);
            } catch (PartInitException e) {
                ExceptionHandler.process(e, Level.ERROR);
            }
            break;
        default:
    }
    TdEditorToolBar toolbar = getToolBar();
    if (toolbar != null && masterPage != null) {
        runAction = new RunAnalysisAction(masterPage);
        refreshAction = new RefreshChartAction();
        toolbar.addActions(runAction, refreshAction);
    }
}

Output:
     if (toolbar != null && masterPage != null) {
-        runAction = new RunAnalysisAction(masterPage);
+        runAction = new RunAnalysisAction();
         refreshAction = new RefreshChartAction();


Input:
public AbstractTreeElement resolveReference(TreeReference qualifiedRef) {
    DataInstance instance = this.getMainInstance();
    if (qualifiedRef.getInstanceName() != null && (instance == null || instance.getInstanceId() == null || !instance.getInstanceId().equals(qualifiedRef.getInstanceName()))) {
        instance = this.getInstance(qualifiedRef.getInstanceName());
    }
    return instance.resolveReference(qualifiedRef);
}

Output:
     }
-    return instance.resolveReference(qualifiedRef);
+    return instance.resolveReference(qualifiedRef, this);
 }


Input:
public void schedulJob(final ExecutionGraph executionGraph) throws SchedulingException {
    final Map<InstanceType, InstanceTypeDescription> availableInstances = getInstanceManager().getMapOfAvailableInstanceTypes();
    for (int i = 0; i < executionGraph.getNumberOfStages(); i++) {
        final Map<InstanceType, Integer> requiredInstanceTypes = new HashMap<InstanceType, Integer>();
        final ExecutionStage stage = executionGraph.getStage(i);
        stage.collectRequiredInstanceTypes(requiredInstanceTypes, ExecutionState.CREATED);
        final Iterator<Map.Entry<InstanceType, Integer>> it = requiredInstanceTypes.entrySet().iterator();
        while (it.hasNext()) {
            final Map.Entry<InstanceType, Integer> entry = it.next();
            final InstanceTypeDescription descr = availableInstances.get(entry.getKey());
            if (descr == null) {
                throw new SchedulingException("String_Node_Str" + entry.getKey() + "String_Node_Str");
            }
            if (descr.getMaximumNumberOfAvailableInstances() != -1 && descr.getMaximumNumberOfAvailableInstances() < entry.getValue().intValue()) {
                throw new SchedulingException("String_Node_Str" + entry.getValue().intValue() + "String_Node_Str" + entry.getKey() + "String_Node_Str" + descr.getMaximumNumberOfAvailableInstances() + "String_Node_Str");
            }
        }
    }
    executionGraph.registerJobStatusListener(this);
    final ExecutionGraphIterator it2 = new ExecutionGraphIterator(executionGraph, true);
    while (it2.hasNext()) {
        final ExecutionVertex vertex = it2.next();
        if (vertex.getExecutionState() != ExecutionState.CREATED) {
            LOG.error("String_Node_Str" + vertex + "String_Node_Str" + vertex.getExecutionState() + "String_Node_Str" + ExecutionState.CREATED);
        }
        vertex.getEnvironment().registerExecutionListener(new QueueExecutionListener(this, vertex));
        vertex.setExecutionState(ExecutionState.SCHEDULED);
    }
    executionGraph.registerExecutionStageListener(this);
    synchronized (this.jobQueue) {
        this.jobQueue.add(executionGraph);
    }
    final ExecutionStage executionStage = executionGraph.getCurrentExecutionStage();
    try {
        requestInstances(executionStage);
    } catch (InstanceException e) {
        LOG.error(StringUtils.stringifyException(e));
    }
}

Output:
         this.jobQueue.add(executionGraph);
-    }
-    final ExecutionStage executionStage = executionGraph.getCurrentExecutionStage();
-    try {
-        requestInstances(executionStage);
-    } catch (InstanceException e) {
-        LOG.error(StringUtils.stringifyException(e));
+        final ExecutionStage executionStage = executionGraph.getCurrentExecutionStage();
+        try {
+            requestInstances(executionStage);
+        } catch (InstanceException e) {
+            LOG.error(StringUtils.stringifyException(e));
+        }
     }


Input:
public void init(FMLInitializationEvent event) {
    PAItems.init();
    PABlocks.init();
    NetworkRegistry.INSTANCE.registerGuiHandler(instance, guiHandler);
    FMLCommonHandler.instance().bus().register(instance);
    MinecraftForge.EVENT_BUS.register(new EventRenderWorld());
}

Output:
     FMLCommonHandler.instance().bus().register(instance);
-    MinecraftForge.EVENT_BUS.register(new EventRenderWorld());
+    proxy.init();
 }


Input:
public Object visitImportOnDemandNode(ImportOnDemandNode node, LinkedList args) {
    NameNode name = node.getName();
    StaticResolution.resolveAName(name, StaticResolution.SYSTEM_PACKAGE.getEnviron(), null, null, JavaDecl.CG_PACKAGE);
    PackageDecl decl = (PackageDecl) name.getDefinedProperty(DECL_KEY);
    _importOnDemand(decl);
    return null;
}

Output:
     NameNode name = node.getName();
-    StaticResolution.resolveAName(name, StaticResolution.SYSTEM_PACKAGE.getEnviron(), null, null, JavaDecl.CG_PACKAGE);
+    StaticResolution.resolveAName(name, StaticResolution.SYSTEM_PACKAGE.getEnviron(), null, null, CG_PACKAGE);
     PackageDecl decl = (PackageDecl) name.getDefinedProperty(DECL_KEY);


Input:
private void sendWiki(ID roomID, String target, String articleName) {
    articleName = articleName.replace(' ', '_');
    if (target == null) {
        sendMessage(roomID, NLS.bind(CustomMessages.getString(CustomMessages.Wiki), articleName));
    } else {
        sendMessage(roomID, NLS.bind(CustomMessages.getString(CustomMessages.Wiki_Reply), target, articleName));
    }
}

Output:
     articleName = articleName.replace(' ', '_');
-    if (target == null) {
-        sendMessage(roomID, NLS.bind(CustomMessages.getString(CustomMessages.Wiki), articleName));
-    } else {
-        sendMessage(roomID, NLS.bind(CustomMessages.getString(CustomMessages.Wiki_Reply), target, articleName));
-    }
+    sendMessage(roomID, (target != null ? target + "String_Node_Str" : "String_Node_Str") + NLS.bind(CustomMessages.getString(CustomMessages.Wiki), articleName));
 }


Input:
public LinkedList<Biometric> getBIOsFromTo(String from, String to) {
    LinkedList<Biometric> resultList = new LinkedList<Biometric>();
    int start, i = 0;
    int end = 0;
    for (i = 0; i < wods.size(); i++) {
        if (biometrics.get(i).getYear() == Integer.parseInt(from.substring(4, 8))) {
            if (biometrics.get(i).getMonth() > Integer.parseInt(from.substring(2, 4))) {
                break;
            } else if (biometrics.get(i).getMonth() == Integer.parseInt(from.substring(2, 4))) {
                if (biometrics.get(i).getDay() >= Integer.parseInt(from.substring(0, 2))) {
                    break;
                }
            }
        }
        if (biometrics.get(i).getYear() > Integer.parseInt(from.substring(4, 8))) {
            break;
        }
    }
    start = i;
    for (i = 0; i < biometrics.size(); i++) {
        if (biometrics.get(i).getYear() == Integer.parseInt(to.substring(4, 8))) {
            if (biometrics.get(i).getMonth() > Integer.parseInt(to.substring(2, 4))) {
                break;
            } else if (biometrics.get(i).getMonth() == Integer.parseInt(to.substring(2, 4))) {
                if (biometrics.get(i).getDay() >= Integer.parseInt(to.substring(0, 2))) {
                    break;
                }
            }
        }
        if (biometrics.get(i).getYear() > Integer.parseInt(to.substring(4, 8))) {
            break;
        }
    }
    end = i;
    for (i = 0; start <= end; start++) {
        resultList.add(biometrics.get(start));
    }
    Biometric checkFirst = resultList.get(0);
    if (checkFirst.getYear() < Integer.parseInt(from.substring(4, 8))) {
        resultList.clear();
    } else if (checkFirst.getYear() == Integer.parseInt(from.substring(4, 8))) {
        if (checkFirst.getMonth() < Integer.parseInt(from.substring(0, 2))) {
            resultList.clear();
        } else if (checkFirst.getMonth() == Integer.parseInt(from.substring(0, 2))) {
            if (checkFirst.getDay() < Integer.parseInt(from.substring(2, 4))) {
                resultList.clear();
            }
        }
    }
    return resultList;
}

Output:
         if (biometrics.get(i).getYear() == Integer.parseInt(from.substring(4, 8))) {
-            if (biometrics.get(i).getMonth() > Integer.parseInt(from.substring(2, 4))) {
+            if (biometrics.get(i).getMonth() > Integer.parseInt(from.substring(0, 2))) {
                 break;


Input:
static StratosAdminResponse unDeployApplication(String configCompositeApplicationAlias, ConfigurationContext ctxt, String userName, String tenantDomain) throws RestAPIException {
    log.info("String_Node_Str" + configCompositeApplicationAlias);
    CloudControllerServiceClient cloudControllerServiceClient = getCloudControllerServiceClient();
    if (cloudControllerServiceClient != null) {
        try {
            if (log.isDebugEnabled()) {
                log.debug("String_Node_Str" + configCompositeApplicationAlias);
            }
            cloudControllerServiceClient.unDeployCompositeApplicationDefinition(configCompositeApplicationAlias);
        } catch (RemoteException e) {
            e.printStackTrace();
            String message = "String_Node_Str";
            log.error(message, e);
            throw new RestAPIException(message, e);
        } catch (CloudControllerServiceInvalidCompositeApplicationDefinitionExceptionException e) {
            e.printStackTrace();
            String message = "String_Node_Str";
            log.error(message, e);
            throw new RestAPIException(message, e);
        } catch (CloudControllerServiceInvalidIaasProviderExceptionException e) {
            e.printStackTrace();
            String message = "String_Node_Str";
            log.error(message, e);
            throw new RestAPIException(message, e);
        }
    } else {
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str");
        }
    }
    log.info("String_Node_Str" + configCompositeApplicationAlias);
    StratosAdminResponse stratosAdminResponse = new StratosAdminResponse();
    stratosAdminResponse.setMessage("String_Node_Str" + configCompositeApplicationAlias);
    return stratosAdminResponse;
}

Output:
     }
-    log.info("String_Node_Str" + configCompositeApplicationAlias);
+    log.info(String.format("String_Node_Str", configCompositeApplicationAlias));
     StratosAdminResponse stratosAdminResponse = new StratosAdminResponse();


Input:
private List<Integer> getPositionList(PositionList pl, LocalObservations local) {
    int pidx = local.getPidx();
    int cidx = local.getCidx();
    FeaturizedToken tok;
    FeaturizedTokenPair pair;
    switch(pl) {
        case CHILDREN_P:
            tok = getFeatTok(pidx);
            return tok.getChildren();
        case NO_FAR_CHILDREN_P:
            tok = getFeatTok(pidx);
            return tok.getNoFarChildren();
        case CHILDREN_C:
            tok = getFeatTok(cidx);
            return tok.getChildren();
        case NO_FAR_CHILDREN_C:
            tok = getFeatTok(cidx);
            return tok.getNoFarChildren();
        case LINE_P_C:
            pair = getFeatTokPair(pidx, cidx);
            return pair.getLinePath();
        case LINE_RI_RK:
            pair = getFeatTokPair(local.getRStartIdx(), local.getREndIdx());
            return pair.getLinePath();
        case BTWN_P_C:
            pair = getFeatTokPair(pidx, cidx);
            List<Integer> posList = pair.getLinePath();
            if (posList.size() > 2) {
                posList = posList.subList(1, posList.size() - 1);
            } else {
                posList = Collections.emptyList();
            }
            return posList;
        default:
            throw new IllegalStateException();
    }
}

Output:
         case CHILDREN_P:
-            tok = getFeatTok(pidx);
+            tok = getFeatTok(local.getPidx());
             return tok.getChildren();


Input:
private void runStart() {
    Intent intent = makeIntent();
    if (intent != null) {
        System.out.println("String_Node_Str" + intent);
        try {
            intent.addFlags(intent.FLAG_ACTIVITY_NEW_TASK);
            int res = mAm.startActivity(null, intent, intent.getType(), null, 0, null, null, 0, false, mDebugOption);
            switch(res) {
                case IActivityManager.START_SUCCESS:
                    break;
                case IActivityManager.START_CLASS_NOT_FOUND:
                    System.err.println("String_Node_Str");
                    System.err.println("String_Node_Str" + intent.getComponent().toShortString() + "String_Node_Str");
                    break;
                case IActivityManager.START_DELIVERED_TO_TOP:
                    System.err.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
                    break;
                case IActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:
                    System.err.println("String_Node_Str" + "String_Node_Str");
                    break;
                case IActivityManager.START_INTENT_NOT_RESOLVED:
                    System.err.println("String_Node_Str" + "String_Node_Str" + intent.toString());
                    break;
                case IActivityManager.START_RETURN_INTENT_TO_CALLER:
                    System.err.println("String_Node_Str" + "String_Node_Str");
                    break;
                case IActivityManager.START_TASK_TO_FRONT:
                    System.err.println("String_Node_Str" + "String_Node_Str");
                    break;
                default:
                    System.err.println("String_Node_Str" + "String_Node_Str" + res);
                    break;
            }
        } catch (RemoteException e) {
            System.err.println("String_Node_Str");
            System.err.println("String_Node_Str" + "String_Node_Str");
        }
    }
}

Output:
         try {
-            intent.addFlags(intent.FLAG_ACTIVITY_NEW_TASK);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
             int res = mAm.startActivity(null, intent, intent.getType(), null, 0, null, null, 0, false, mDebugOption);


Input:
public void testBadCodeCategory_STS3822() {
    String[] sources = { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" };
    runNegativeTest(sources, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
}

Output:
     String[] sources = { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" };
-    runNegativeTest(sources, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+    runNegativeTest(sources, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + (!GroovyUtils.isAtLeastGroovy(20) ? "String_Node_Str" : "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str"));
 }


Input:
public void test() throws Exception {
    MailboxFactory mailboxFactory = JAMailboxFactory.newMailboxFactory(10);
    Mailbox factoryMailbox = mailboxFactory.createMailbox();
    JAFactory factory = new JAFactory();
    factory.initialize(factoryMailbox);
    (new JFileFactories()).initialize(factoryMailbox, factory);
    IncrementCounterFactory ntf = new IncrementCounterFactory("String_Node_Str");
    factory.registerActorFactory(ntf);
    JAFuture future = new JAFuture();
    AggregateTransaction aggregateTransaction = new AggregateTransaction(ntf);
    Path directoryPath = FileSystems.getDefault().getPath("String_Node_Str");
    CounterDB db = new CounterDB(mailboxFactory, factory, directoryPath);
    db.initialCapacity = 10000;
    db.clearDirectory();
    (new OpenDbFile(10000)).send(future, db);
    TransactionAggregator transactionAggregator = db.getTransactionAggregator();
    TransactionAggregatorDriver transactionAggregatorDriver = new TransactionAggregatorDriver();
    transactionAggregatorDriver.initialize(mailboxFactory.createAsyncMailbox(), transactionAggregator);
    transactionAggregatorDriver.setInitialBufferCapacity(10000);
    transactionAggregatorDriver.win = 3;
    transactionAggregatorDriver.aggregateTransaction = aggregateTransaction;
    transactionAggregatorDriver.batch = 10;
    transactionAggregatorDriver.count = 10;
    Go.req.send(future, transactionAggregatorDriver);
    Finish.req.send(future, transactionAggregator);
    long t0 = System.currentTimeMillis();
    Go.req.send(future, transactionAggregatorDriver);
    Finish.req.send(future, transactionAggregator);
    long t1 = System.currentTimeMillis();
    int transactions = transactionAggregatorDriver.batch * transactionAggregatorDriver.count;
    assertEquals(2 * transactions, db.getCounter());
    System.out.println("String_Node_Str" + (t1 - t0));
    System.out.println("String_Node_Str" + transactions);
    System.out.println("String_Node_Str" + (1000L * transactions / (t1 - t0)));
    db.closeDbFile();
    mailboxFactory.close();
}

Output:
     transactionAggregatorDriver.aggregateTransaction = aggregateTransaction;
-    transactionAggregatorDriver.batch = 10;
-    transactionAggregatorDriver.count = 10;
+    transactionAggregatorDriver.batch = 5;
+    transactionAggregatorDriver.count = 5;
+    System.out.println("String_Node_Str");
     Go.req.send(future, transactionAggregatorDriver);


Input:
public String removeQuote(String string) {
    if (string != null && string.length() >= 2 && string.startsWith("String_Node_Str") && string.endsWith("String_Node_Str")) {
        return string.substring(1, string.length() - 1);
    }
    return string;
}

Output:
 public String removeQuote(String string) {
-    if (string != null && string.length() >= 2 && string.startsWith("String_Node_Str") && string.endsWith("String_Node_Str")) {
-        return string.substring(1, string.length() - 1);
+    if (string != null && string.trim().length() >= 2 && string.trim().startsWith("String_Node_Str") && string.trim().endsWith("String_Node_Str")) {
+        return string.trim().substring(1, string.trim().length() - 1);
     }


Input:
protected boolean canSave() {
    if (columnListA.size() != columnListB.size()) {
        MessageDialog.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"));
        return false;
    }
    if (columnListA.size() > 0) {
        ColumnSet columnSetOwnerA = null;
        ColumnSet columnSetOwnerB = null;
        ColumnSet ownerA = null;
        ColumnSet ownerB = null;
        for (int i = 0; i < columnListA.size(); i++) {
            if (!((TdColumn) columnListA.get(i)).getSqlDataType().getName().equals(((TdColumn) columnListB.get(i)).getSqlDataType().getName())) {
                MessageDialog.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"));
                return false;
            }
            ownerA = ColumnHelper.getColumnSetOwner(columnListA.get(i));
            ownerB = ColumnHelper.getColumnSetOwner(columnListB.get(i));
            if (i == 0) {
                columnSetOwnerA = ownerA;
                columnSetOwnerB = ownerB;
            } else {
                if ((columnSetOwnerA != ownerA) || (columnSetOwnerB != ownerB)) {
                    MessageDialog.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"));
                    return false;
                }
            }
        }
        Package parentCatalogOrSchemaA = ColumnSetHelper.getParentCatalogOrSchema(columnSetOwnerA);
        Package parentCatalogOrSchemaB = ColumnSetHelper.getParentCatalogOrSchema(columnSetOwnerB);
        if (!parentCatalogOrSchemaA.getName().equals(parentCatalogOrSchemaB.getName())) {
            MessageDialog.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"));
            return false;
        }
    }
    return true;
}

Output:
     if (columnListA.size() != columnListB.size()) {
-        MessageDialog.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"));
-        return false;
+        return new ReturnCode(DefaultMessagesImpl.getString("String_Node_Str"), false);
     }


Input:
public static void animateTransform(ImageView imageView, Matrix matrix) {
    Drawable drawable = imageView.getDrawable();
    if (matrix == null) {
        drawable.setBounds(0, 0, imageView.getWidth(), imageView.getHeight());
    } else {
        drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
        Matrix drawMatrix = imageView.getImageMatrix();
        drawMatrix.set(matrix);
        ReflectionUtils.setFieldValue(imageView, FIELD_DRAW_MATRIX, drawMatrix);
    }
    imageView.invalidate();
}

Output:
     Drawable drawable = imageView.getDrawable();
-    if (matrix == null) {
+    if (matrix == null || drawable.getIntrinsicWidth() == -1 || drawable.getIntrinsicHeight() == -1) {
         drawable.setBounds(0, 0, imageView.getWidth(), imageView.getHeight());


Input:
private void unregisterWithRouterService() {
    Log.i(TAG, "String_Node_Str");
    if (isBound && routerServiceMessenger != null) {
        Message msg = Message.obtain();
        msg.what = TransportConstants.ROUTER_UNREGISTER_CLIENT;
        msg.replyTo = this.clientMessenger;
        Bundle bundle = new Bundle();
        bundle.putLong(TransportConstants.APP_ID_EXTRA, appId);
        msg.setData(bundle);
        sendMessageToRouterService(msg);
    } else {
        Log.w(TAG, "String_Node_Str");
    }
    routerServiceMessenger = null;
}

Output:
         Bundle bundle = new Bundle();
-        bundle.putLong(TransportConstants.APP_ID_EXTRA, appId);
+        if (routerServiceVersion < TransportConstants.RouterServiceVersions.APPID_STRING) {
+            bundle.putLong(TransportConstants.APP_ID_EXTRA, convertAppId(appId));
+        }
+        bundle.putString(TransportConstants.APP_ID_EXTRA_STRING, appId);
         msg.setData(bundle);


Input:
public Set<Attribute> getCreateAttributes(final CreateRequest request, final CryptoService cryptoService) throws ResourceException {
    JsonValue content = request.getContent().required().expect(Map.class);
    String nameValue = request.getNewResourceId();
    if (null == nameValue) {
        JsonValue o = content.get(nameAttribute);
        if (o.isNull()) {
            o = content.get(Resource.FIELD_CONTENT_ID);
        }
        if (o.isString()) {
            nameValue = o.asString();
        }
    }
    if (StringUtils.isBlank(nameValue)) {
        throw new BadRequestException("String_Node_Str" + nameAttribute + "String_Node_Str");
    }
    Set<String> keySet = content.keys();
    Map<String, Attribute> result = new HashMap<String, Attribute>(keySet.size());
    result.put(Name.NAME, new Name(nameValue));
    for (AttributeInfoHelper attributeInfo : attributes) {
        if (Name.NAME.equals(attributeInfo.getAttributeInfo().getName()) || Uid.NAME.equals(attributeInfo.getAttributeInfo().getName()) || !keySet.contains(attributeInfo.getName())) {
            continue;
        }
        if (attributeInfo.getAttributeInfo().isCreateable()) {
            JsonValue v = content.get(attributeInfo.getName());
            if (v.isNull() && attributeInfo.getAttributeInfo().isRequired()) {
                throw new BadRequestException("String_Node_Str" + attributeInfo.getName() + "String_Node_Str");
            }
            Attribute a = attributeInfo.build(v.getObject(), cryptoService);
            if (null != a) {
                result.put(attributeInfo.getAttributeInfo().getName(), a);
            }
        }
    }
    if (logger.isTraceEnabled()) {
        ConnectorObjectBuilder builder = new ConnectorObjectBuilder().addAttributes(result.values());
        builder.setName(nameValue);
        builder.setUid(nameValue);
        logger.trace("String_Node_Str", SerializerUtil.serializeXmlObject(builder.build(), false));
    }
    return new HashSet<Attribute>(result.values());
}

Output:
     for (AttributeInfoHelper attributeInfo : attributes) {
-        if (Name.NAME.equals(attributeInfo.getAttributeInfo().getName()) || Uid.NAME.equals(attributeInfo.getAttributeInfo().getName()) || !keySet.contains(attributeInfo.getName())) {
+        if (Name.NAME.equals(attributeInfo.getAttributeInfo().getName()) || Uid.NAME.equals(attributeInfo.getAttributeInfo().getName()) || (!keySet.contains(attributeInfo.getName()) && !attributeInfo.getAttributeInfo().isRequired())) {
             continue;


Input:
private void writeTextInParagraph(int type, String txt, IStyle style, String fontFamily, HyperlinkInfo info, int paragraphWidth) {
    writer.openTag("String_Node_Str");
    writer.openTag("String_Node_Str");
    CSSValue lineHeight = style.getProperty(StyleConstants.STYLE_LINE_HEIGHT);
    if (!"String_Node_Str".equalsIgnoreCase(lineHeight.getCssText())) {
        writeSpacing(lineHeight);
    }
    writeAlign(style.getTextAlign(), style.getDirection());
    writeBackgroundColor(style.getBackgroundColor());
    writeParagraphBorders(style);
    int indent = PropertyUtil.getDimensionValue(style.getProperty(StyleConstants.STYLE_TEXT_INDENT), paragraphWidth * 1000) / 1000 * 20;
    if (indent != 0) {
        writeIndent(indent);
    }
    writer.closeTag("String_Node_Str");
    writeTextInRun(type, txt, style, fontFamily, info, false, paragraphWidth);
}

Output:
     writer.closeTag("String_Node_Str");
-    writeTextInRun(type, txt, style, fontFamily, info, false, paragraphWidth);
+    writeTextInRun(type, txt, style, fontFamily, info, false, paragraphWidth, runIsRtl);
 }


Input:
public String view() {
    try {
        String frontEndCaseDataIn = extractWidgetConfig("String_Node_Str");
        this.setFrontEndCaseData(frontEndCaseDataIn);
        if ((!StringUtils.isBlank(this.getKnowledgeSourceId()) || !StringUtils.isBlank(this.getContainerid()) || !StringUtils.isBlank(this.getCasePath()) || !StringUtils.isBlank(this.getChannelPath())) && (this.getChannelPath().equalsIgnoreCase(this.getFrontEndCaseData()))) {
            this.getCaseManager().setKieServerConfiguration(this.getKnowledgeSourceId());
            this.setCaseInstanceDetails(this.getCaseManager().getCaseInstancesDetails(this.getContainerid(), this.getCasePath()).toString());
        } else {
            this.setKnowledgeSourceId(this.getCaseManager().loadFirstConfigurations().getId());
            this.setContainerid(this.getCaseManager().getContainersList().get(0).getContainerId());
            this.setCasePath(this.getCaseManager().getCaseInstancesList(this.getContainerid()).get(0));
            this.setCaseInstanceDetails(this.getCaseManager().getCaseInstancesDetails(this.getContainerid(), this.getCasePath()).toString());
        }
    } catch (ApsSystemException t) {
        logger.error("String_Node_Str", t);
        return FAILURE;
    }
    return SUCCESS;
}

Output:
         this.setFrontEndCaseData(frontEndCaseDataIn);
-        if ((!StringUtils.isBlank(this.getKnowledgeSourceId()) || !StringUtils.isBlank(this.getContainerid()) || !StringUtils.isBlank(this.getCasePath()) || !StringUtils.isBlank(this.getChannelPath())) && (this.getChannelPath().equalsIgnoreCase(this.getFrontEndCaseData()))) {
+        String channelIn = extractWidgetConfig("String_Node_Str");
+        this.setChannel(channelIn);
+        if ((!StringUtils.isBlank(this.getKnowledgeSourceId()) || !StringUtils.isBlank(this.getContainerid()) || !StringUtils.isBlank(this.getCasePath()) || !StringUtils.isBlank(this.getChannelPath())) && (this.getChannelPath().equalsIgnoreCase(this.getChannel()))) {
             this.getCaseManager().setKieServerConfiguration(this.getKnowledgeSourceId());


Input:
private static JavaElementLocation getTypeDeclarationLocation(final IJavaElement javaElement) {
    if (!(javaElement instanceof IType)) {
        return JavaElementLocation.TYPE_DECLARATION;
    } else {
        try {
            if (!((IType) javaElement).isInterface()) {
                return JavaElementLocation.EXTENDS_DECLARATION;
            }
        } catch (final JavaModelException e) {
            throw new IllegalStateException(e);
        }
    }
    return JavaElementLocation.IMPLEMENTS_DECLARATION;
}

Output:
         return JavaElementLocation.TYPE_DECLARATION;
-    } else {
-        try {
-            if (!((IType) javaElement).isInterface()) {
-                return JavaElementLocation.EXTENDS_DECLARATION;
-            }
-        } catch (final JavaModelException e) {
-            throw new IllegalStateException(e);
+    }
+    try {
+        if (((IType) javaElement).isInterface()) {
+            return JavaElementLocation.IMPLEMENTS_DECLARATION;
         }


Input:
private void finishProcedure(polyglot.ast.ProcedureDecl procedure, soot.SootMethod sootMethod) {
    addProcedureToClass(sootMethod);
    if (procedure.position() != null) {
        if (procedure.body() != null) {
            if (procedure.body().position() != null) {
                Util.addLnPosTags(sootMethod, procedure.position().line(), procedure.body().position().endLine(), procedure.position().column(), procedure.body().position().endColumn());
            }
        }
    }
    MethodFinalsChecker mfc = new MethodFinalsChecker();
    mfc.setCurrentSootClass(sootClass.getName());
    if (procedure.body() != null) {
        procedure.body().visit(mfc);
    }
    if (newToOuterMap == null) {
        newToOuterMap = new HashMap();
    }
    if (mfc.getNewToOuter().keySet() != null) {
        Iterator newIt = mfc.getNewToOuter().keySet().iterator();
        while (newIt.hasNext()) {
            Object next = newIt.next();
            newToOuterMap.put(next, mfc.getNewToOuter().get(next));
        }
    }
    if ((mfc.getLocals() != null) && (mfc.getClassNames() != null)) {
        if (finalsMap == null) {
            finalsMap = new HashMap();
        }
        Iterator it = mfc.getClassNames().iterator();
        while (it.hasNext()) {
            ArrayList finalLocals = new ArrayList();
            polyglot.ast.New key = (polyglot.ast.New) it.next();
            LocalUsesChecker luc = new LocalUsesChecker();
            key.body().visit(luc);
            Iterator localsIt = luc.getLocals().iterator();
            while (localsIt.hasNext()) {
                polyglot.types.LocalInstance testLocal = (polyglot.types.LocalInstance) ((polyglot.util.IdentityKey) localsIt.next()).object();
                if (!luc.getLocalDecls().contains(new polyglot.util.IdentityKey(testLocal))) {
                    finalLocals.add(new polyglot.util.IdentityKey(testLocal));
                }
            }
            finalsMap.put(key, finalLocals);
        }
    }
    PolyglotMethodSource mSrc = new PolyglotMethodSource(procedure.body(), procedure.formals());
    mSrc.setFinalsMap(finalsMap);
    mSrc.setNewToOuterMap(newToOuterMap);
    mSrc.setPrivateAccessMap(privateAccessMap);
    if (localClassMap != null) {
        mSrc.setLocalClassMap(localClassMap);
    }
    if (anonClassMap != null) {
        mSrc.setAnonClassMap(anonClassMap);
    }
    sootMethod.setSource(mSrc);
}

Output:
             }
-            finalsMap.put(key, finalLocals);
+            alci.finalFields(finalLocals);
+            finalsMap.put(key, alci);
         }


Input:
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
    CoreResources cr = new CoreResources();
    Locale locale = new Locale("String_Node_Str");
    ResourceBundleProvider.updateLocale(locale);
    ResourceBundle pageMessages = ResourceBundleProvider.getPageMessagesBundle();
    List<File> markForDelete = new LinkedList<File>();
    Boolean zipped = true;
    Boolean deleteOld = true;
    Boolean exceptions = false;
    JobDataMap dataMap = context.getMergedJobDataMap();
    String localeStr = dataMap.getString(LOCALE);
    String[] doNotDeleteUntilExtract = new String[4];
    int cnt = dataMap.getInt("String_Node_Str");
    DatasetBean datasetBean = null;
    if (localeStr != null) {
        locale = new Locale(localeStr);
        ResourceBundleProvider.updateLocale(locale);
        pageMessages = ResourceBundleProvider.getPageMessagesBundle();
    }
    String alertEmail = dataMap.getString(EMAIL);
    java.io.InputStream in = null;
    FileOutputStream endFileStream = null;
    try {
        ApplicationContext appContext = (ApplicationContext) context.getScheduler().getContext().get("String_Node_Str");
        mailSender = (OpenClinicaMailSender) appContext.getBean("String_Node_Str");
        dataSource = (DataSource) appContext.getBean("String_Node_Str");
        coreResources = (CoreResources) appContext.getBean("String_Node_Str");
        ruleSetRuleDao = (RuleSetRuleDao) appContext.getBean("String_Node_Str");
        DatasetDAO dsdao = new DatasetDAO(dataSource);
        int userAccountId = dataMap.getInt(USER_ID);
        int studyId = dataMap.getInt(STUDY_ID);
        String outputPath = dataMap.getString(POST_FILE_PATH);
        logger.debug("String_Node_Str" + outputPath);
        String generalFileDir = dataMap.getString(XML_FILE_PATH);
        int epBeanId = dataMap.getInt(EXTRACT_PROPERTY);
        int dsId = dataMap.getInt(DATASET_ID);
        ExtractPropertyBean epBean = (ExtractPropertyBean) dataMap.get(EP_BEAN);
        File doNotDelDir = new File(generalFileDir);
        if (doNotDelDir.isDirectory()) {
            doNotDeleteUntilExtract = doNotDelDir.list();
        }
        zipped = epBean.getZipFormat();
        deleteOld = epBean.getDeleteOld();
        long sysTimeBegin = System.currentTimeMillis();
        userAccountDao = new UserAccountDAO(dataSource);
        UserAccountBean userBean = (UserAccountBean) userAccountDao.findByPK(userAccountId);
        generateFileService = new GenerateExtractFileService(dataSource, userBean, coreResources, ruleSetRuleDao);
        studyDao = new StudyDAO(dataSource);
        StudyBean currentStudy = (StudyBean) studyDao.findByPK(studyId);
        StudyBean parentStudy = (StudyBean) studyDao.findByPK(currentStudy.getParentStudyId());
        String successMsg = epBean.getSuccessMessage();
        String failureMsg = epBean.getFailureMessage();
        final long start = System.currentTimeMillis();
        datasetBean = (DatasetBean) dsdao.findByPK(dsId);
        ExtractBean eb = generateFileService.generateExtractBean(datasetBean, currentStudy, parentStudy);
        datasetBean.setName(datasetBean.getName().replaceAll("String_Node_Str", "String_Node_Str"));
        logger.debug("String_Node_Str");
        HashMap answerMap = generateFileService.createODMFile(epBean.getFormat(), sysTimeBegin, generalFileDir, datasetBean, currentStudy, "String_Node_Str", eb, currentStudy.getId(), currentStudy.getParentStudyId(), "String_Node_Str", (Boolean) dataMap.get(ZIPPED), false, (Boolean) dataMap.get(DELETE_OLD), epBean.getOdmType());
        String ODMXMLFileName = "String_Node_Str";
        int fId = 0;
        for (Iterator it = answerMap.entrySet().iterator(); it.hasNext(); ) {
            java.util.Map.Entry entry = (java.util.Map.Entry) it.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            ODMXMLFileName = (String) key;
            Integer fileID = (Integer) value;
            fId = fileID.intValue();
            logger.debug("String_Node_Str" + fId + "String_Node_Str" + ODMXMLFileName);
        }
        File output = new File(outputPath);
        if (!output.isDirectory()) {
            output.mkdirs();
        }
        TransformerFactory tFactory = TransformerFactory.newInstance();
        int numXLS = epBean.getFileName().length;
        int fileCntr = 0;
        String xmlFilePath = generalFileDir + ODMXMLFileName;
        String endFile = null;
        File oldFilesPath = new File(generalFileDir);
        while (fileCntr < numXLS) {
            String xsltPath = dataMap.getString(XSLT_PATH) + File.separator + epBean.getFileName()[fileCntr];
            in = new java.io.FileInputStream(xsltPath);
            Transformer transformer = tFactory.newTransformer(new StreamSource(in));
            endFile = outputPath + File.separator + epBean.getExportFileName()[fileCntr];
            endFileStream = new FileOutputStream(endFile);
            transformer.transform(new StreamSource(xmlFilePath), new StreamResult(endFileStream));
            in.close();
            endFileStream.close();
            fileCntr++;
        }
        if (oldFilesPath.isDirectory()) {
            markForDelete = Arrays.asList(oldFilesPath.listFiles());
        }
        final double done = setFormat((new Double(System.currentTimeMillis() - start)) / 1000);
        logger.info("String_Node_Str" + done + "String_Node_Str");
        ProcessingFunction function = epBean.getPostProcessing();
        String subject = "String_Node_Str";
        String jobName = dataMap.getString(XsltTriggerService.JOB_NAME);
        StringBuffer emailBuffer = new StringBuffer("String_Node_Str");
        emailBuffer.append("String_Node_Str" + pageMessages.getString("String_Node_Str") + "String_Node_Str" + EmailEngine.getAdminEmail() + "String_Node_Str" + pageMessages.getString("String_Node_Str") + "String_Node_Str" + pageMessages.getString("String_Node_Str") + "String_Node_Str");
        emailBuffer.append("String_Node_Str" + datasetBean.getName() + "String_Node_Str");
        emailBuffer.append("String_Node_Str" + currentStudy.getName() + "String_Node_Str");
        if (function != null && function.getClass().equals(org.akaza.openclinica.bean.service.SqlProcessingFunction.class)) {
            String dbUrl = ((org.akaza.openclinica.bean.service.SqlProcessingFunction) function).getDatabaseUrl();
            int lastIndex = dbUrl.lastIndexOf("String_Node_Str");
            String schemaName = dbUrl.substring(lastIndex);
            int HostIndex = dbUrl.substring(0, lastIndex).indexOf("String_Node_Str");
            String Host = dbUrl.substring(HostIndex, lastIndex);
            emailBuffer.append("String_Node_Str" + ((org.akaza.openclinica.bean.service.SqlProcessingFunction) function).getDatabaseType() + "String_Node_Str");
            emailBuffer.append("String_Node_Str" + schemaName.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str");
            emailBuffer.append("String_Node_Str" + Host.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str");
        }
        emailBuffer.append("String_Node_Str" + pageMessages.getString("String_Node_Str") + datasetBean.getName() + pageMessages.getString("String_Node_Str") + "String_Node_Str");
        if (function != null) {
            function.setTransformFileName(outputPath + File.separator + dataMap.getString(POST_FILE_NAME));
            function.setODMXMLFileName(endFile);
            function.setXslFileName(dataMap.getString(XSL_FILE_PATH));
            function.setDeleteOld((Boolean) dataMap.get(POST_PROC_DELETE_OLD));
            function.setZip((Boolean) dataMap.get(POST_PROC_ZIP));
            function.setLocation(dataMap.getString(POST_PROC_LOCATION));
            function.setExportFileName(dataMap.getString(POST_PROC_EXPORT_NAME));
            File[] oldFiles = getOldFiles(outputPath, dataMap.getString(POST_PROC_LOCATION));
            function.setOldFiles(oldFiles);
            File[] intermediateFiles = getInterFiles(dataMap.getString(POST_FILE_PATH));
            ProcessingResultType message = function.run();
            if (message.getCode().intValue() != 2)
                deleteOldFiles(intermediateFiles);
            final long done2 = System.currentTimeMillis() - start;
            logger.info("String_Node_Str" + done2 + "String_Node_Str" + message.getCode());
            logger.info("String_Node_Str" + done2 + "String_Node_Str" + message.getCode());
            if (!function.getClass().equals(org.akaza.openclinica.bean.service.SqlProcessingFunction.class)) {
                String archivedFile = dataMap.getString(POST_FILE_NAME) + "String_Node_Str" + function.getFileType();
                if (function.isZip())
                    archivedFile = archivedFile + "String_Node_Str";
                if (function.getClass().equals(org.akaza.openclinica.bean.service.PdfProcessingFunction.class))
                    archivedFile = function.getArchivedFileName();
                ArchivedDatasetFileBean fbFinal = generateFileRecord(archivedFile, outputPath, datasetBean, done, new File(outputPath + File.separator + archivedFile).length(), ExportFormatBean.PDFFILE, userAccountId);
                if (successMsg == null || successMsg.isEmpty()) {
                }
                if (successMsg.contains("String_Node_Str")) {
                    successMsg = successMsg.replace("String_Node_Str", "String_Node_Str" + CoreResources.getField("String_Node_Str") + "String_Node_Str" + fbFinal.getId() + "String_Node_Str" + CoreResources.getField("String_Node_Str") + "String_Node_Str" + fbFinal.getId() + "String_Node_Str");
                }
                emailBuffer.append("String_Node_Str" + successMsg + "String_Node_Str");
                logMe("String_Node_Str" + sysTimeBegin);
                logMe("String_Node_Str" + System.currentTimeMillis());
                double sysTimeEnd = setFormat((System.currentTimeMillis() - sysTimeBegin) / 1000);
                logMe("String_Node_Str" + sysTimeEnd);
                if (fbFinal != null) {
                    fbFinal.setFileSize((int) bytesToKilo(new File(archivedFile).length()));
                    fbFinal.setRunTime(sysTimeEnd);
                }
            }
            if (message.getCode().intValue() == 1) {
                if (jobName != null) {
                    subject = "String_Node_Str" + jobName;
                } else {
                    subject = "String_Node_Str" + datasetBean.getName();
                }
            } else if (message.getCode().intValue() == 2) {
                if (jobName != null) {
                    subject = "String_Node_Str" + jobName;
                } else {
                    subject = "String_Node_Str" + datasetBean.getName();
                }
                if (failureMsg != null && !failureMsg.isEmpty()) {
                    emailBuffer.append(failureMsg);
                }
                emailBuffer.append("String_Node_Str" + message.getDescription());
                postErrorMessage(message.getDescription(), context);
            } else if (message.getCode().intValue() == 3) {
                if (jobName != null) {
                    subject = "String_Node_Str" + jobName;
                } else {
                    subject = "String_Node_Str" + datasetBean.getName();
                }
            }
        } else {
            String archivedFilename = dataMap.getString(POST_FILE_NAME);
            if (zipped)
                archivedFilename = dataMap.getString(POST_FILE_NAME) + "String_Node_Str";
            List<File> intermediateFiles = generateFileService.getOldFiles();
            String[] dontDelFiles = epBean.getDoNotDelFiles();
            if (dontDelFiles.length > 1 && zipped) {
                logMe("String_Node_Str" + cnt + "String_Node_Str" + dontDelFiles.length);
                logMe("String_Node_Str" + cnt + "String_Node_Str" + dontDelFiles);
                File temp = new File(endFile);
                String path = outputPath + File.separator;
                logMe("String_Node_Str" + path);
                logMe("String_Node_Str" + epBean.getZipName());
                String zipName = (epBean.getZipName() == null || epBean.getZipName().isEmpty()) ? endFile + "String_Node_Str" : path + epBean.getZipName() + "String_Node_Str";
                archivedFilename = new File(zipName).getName();
                zipAll(path, epBean.getDoNotDelFiles(), zipName);
                String[] tempArray = { archivedFilename };
                dontDelFiles = tempArray;
                endFile = archivedFilename;
            } else if (zipped) {
                markForDelete = zipxmls(markForDelete, endFile);
                endFile = endFile + "String_Node_Str";
                String[] temp = new String[dontDelFiles.length];
                int i = 0;
                while (i < dontDelFiles.length) {
                    temp[i] = dontDelFiles[i] + "String_Node_Str";
                    i++;
                }
                dontDelFiles = temp;
                FilenameFilter xmlFilter = new XMLFileFilter();
                File tempFile = new File(generalFileDir);
                deleteOldFiles(tempFile.listFiles(xmlFilter));
            }
            final double sysTimeEnd = setFormat((System.currentTimeMillis() - start) / 60000);
            ArchivedDatasetFileBean fbFinal = generateFileRecord(archivedFilename, outputPath, datasetBean, done, new File(outputPath + File.separator + archivedFilename).length(), ExportFormatBean.TXTFILE, userAccountId);
            if (jobName != null) {
                subject = "String_Node_Str" + jobName;
            } else {
                subject = "String_Node_Str" + datasetBean.getName();
            }
            if (successMsg == null || successMsg.isEmpty()) {
                logger.info("String_Node_Str" + emailBuffer);
            } else {
                if (successMsg.contains("String_Node_Str")) {
                    successMsg = successMsg.replace("String_Node_Str", "String_Node_Str" + CoreResources.getField("String_Node_Str") + "String_Node_Str" + fbFinal.getId() + "String_Node_Str" + CoreResources.getField("String_Node_Str") + "String_Node_Str" + fbFinal.getId() + "String_Node_Str");
                }
                emailBuffer.append("String_Node_Str" + successMsg + "String_Node_Str");
            }
            if (deleteOld) {
                deleteIntermFiles(intermediateFiles, endFile, dontDelFiles);
                deleteIntermFiles(markForDelete, endFile, dontDelFiles);
            }
        }
        emailBuffer.append("String_Node_Str" + pageMessages.getString("String_Node_Str") + "String_Node_Str");
        try {
            mailSender.sendEmail(alertEmail, EmailEngine.getAdminEmail(), subject, emailBuffer.toString(), true);
        } catch (OpenClinicaSystemException ose) {
            logger.info("String_Node_Str" + ose.getMessage());
            logger.error("String_Node_Str" + ose.getMessage());
        }
        logger.info("String_Node_Str" + alertEmail + "String_Node_Str" + EmailEngine.getAdminEmail());
        if (successMsg == null)
            successMsg = "String_Node_Str";
        postSuccessMessage(successMsg, context);
        logMe(emailBuffer.toString());
    } catch (TransformerConfigurationException e) {
        sendErrorEmail(e.getMessage(), context, alertEmail);
        postErrorMessage(e.getMessage(), context);
        e.printStackTrace();
        logger.error(e.getStackTrace().toString());
        exceptions = true;
    } catch (FileNotFoundException e) {
        sendErrorEmail(e.getMessage(), context, alertEmail);
        postErrorMessage(e.getMessage(), context);
        e.printStackTrace();
        logger.error(e.getStackTrace().toString());
        exceptions = true;
    } catch (TransformerFactoryConfigurationError e) {
        sendErrorEmail(e.getMessage(), context, alertEmail);
        postErrorMessage(e.getMessage(), context);
        e.printStackTrace();
        logger.error(e.getStackTrace().toString());
        exceptions = true;
    } catch (TransformerException e) {
        sendErrorEmail(e.getMessage(), context, alertEmail);
        postErrorMessage(e.getMessage(), context);
        e.printStackTrace();
        logger.error(e.getStackTrace().toString());
        exceptions = true;
    } catch (Exception ee) {
        sendErrorEmail(ee.getMessage(), context, alertEmail);
        postErrorMessage(ee.getMessage(), context);
        ee.printStackTrace();
        logger.error(ee.getStackTrace().toString());
        exceptions = true;
    } finally {
        if (in != null)
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        if (endFileStream != null)
            try {
                endFileStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        if (exceptions) {
            logger.debug("String_Node_Str");
            String generalFileDir = dataMap.getString(XML_FILE_PATH);
            File oldFilesPath = new File(generalFileDir);
            String endFile = "String_Node_Str";
            ExtractPropertyBean epBean = (ExtractPropertyBean) dataMap.get(EP_BEAN);
            endFile = dataMap.getString(POST_FILE_PATH) + File.separator + dataMap.getString(POST_FILE_NAME);
            if (oldFilesPath.isDirectory()) {
                markForDelete = Arrays.asList(oldFilesPath.listFiles());
            }
            logger.debug("String_Node_Str");
            if (deleteOld) {
                deleteIntermFiles(markForDelete, endFile, doNotDeleteUntilExtract);
            }
        }
        if (datasetBean != null)
            resetArchiveDataset(datasetBean.getId());
    }
}

Output:
         userAccountDao = new UserAccountDAO(dataSource);
-        UserAccountBean userBean = (UserAccountBean) userAccountDao.findByPK(userAccountId);
+        userBean = (UserAccountBean) userAccountDao.findByPK(userAccountId);
         generateFileService = new GenerateExtractFileService(dataSource, userBean, coreResources, ruleSetRuleDao);


Input:
public void testJava_cup() throws ClassHierarchyException {
    AnalysisScope scope = CallGraphTestUtil.makeJ2SEAnalysisScope(TestConstants.JAVA_CUP);
    ClassHierarchy cha = ClassHierarchy.make(scope);
    Iterable<Entrypoint> entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha, TestConstants.JAVA_CUP_MAIN);
    AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints);
    doCallGraphs(options, new AnalysisCache(), cha, scope, null, useShortProfile(), false);
}

Output:
     AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints);
-    doCallGraphs(options, new AnalysisCache(), cha, scope, null, useShortProfile(), false);
+    doCallGraphs(options, new AnalysisCache(), cha, scope, null, useShortProfile(), false, true);
 }


Input:
private static byte[] macAddress() {
    try {
        Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        byte[] mac = null;
        while (interfaces.hasMoreElements() && mac != null && mac.length != 6) {
            NetworkInterface netInterface = interfaces.nextElement();
            if (netInterface.isLoopback() || netInterface.isVirtual())
                continue;
            mac = netInterface.getHardwareAddress();
        }
        if (mac == null)
            mac = new byte[] { 0, 0, 0, 0, 0, 0 };
        return mac;
    } catch (Exception e) {
        throw new RuntimeException("String_Node_Str");
    }
}

Output:
         byte[] mac = null;
-        while (interfaces.hasMoreElements() && mac != null && mac.length != 6) {
+        while (interfaces.hasMoreElements() && (mac == null || mac.length != 6)) {
             NetworkInterface netInterface = interfaces.nextElement();


Input:
protected void setUpLinkedMode(IDocument document, char closingCharacter) {
    if (getTextViewer() != null) {
        try {
            int baseOffset = getReplacementOffset();
            LinkedModeModel model = new LinkedModeModel();
            for (int i = 0; i < fPositions.size(); i += 1) {
                Position position = fPositions.get(i);
                position.setOffset(baseOffset + position.getOffset());
                LinkedPositionGroup group = new LinkedPositionGroup();
                if (fProposals.size() <= i || fProposals.get(i).length < 2) {
                    group.addPosition(new LinkedPosition(document, position.getOffset(), position.getLength(), LinkedPositionGroup.NO_STOP));
                } else {
                    ensurePositionCategoryInstalled(document, model);
                    document.addPosition(fPositionCategory, position);
                    group.addPosition(new ProposalPosition(document, position.getOffset(), position.getLength(), LinkedPositionGroup.NO_STOP, fProposals.get(i)));
                }
                model.addGroup(group);
            }
            JavaEditor editor = getJavaEditor();
            if (editor != null) {
                model.addLinkingListener(new EditorHighlightingSynchronizer(editor));
            }
            model.forceInstall();
            LinkedModeUI ui = new EditorLinkedModeUI(model, getTextViewer());
            ui.setCyclingMode(LinkedModeUI.CYCLE_NEVER);
            ui.setDoContextInfo(true);
            ui.setExitPolicy(new ExitPolicy(closingCharacter, document));
            ui.setExitPosition(getTextViewer(), baseOffset + getCursorPosition(), 0, Integer.MAX_VALUE);
            ui.enter();
        } catch (BadLocationException | BadPositionCategoryException e) {
            GroovyContentAssist.logError(e);
        }
    }
}

Output:
             LinkedModeModel model = new LinkedModeModel();
-            for (int i = 0; i < fPositions.size(); i += 1) {
-                Position position = fPositions.get(i);
-                position.setOffset(baseOffset + position.getOffset());
+            if (fPositions == null) {
                 LinkedPositionGroup group = new LinkedPositionGroup();


Input:
public static <T> void refresh(final T newObject) throws ConstraintViolationException {
    try {
        getTransaction(newObject).getTxState().getEntityManager().refresh(newObject);
    } catch (final RuntimeException ex) {
        PersistenceExceptions.throwFiltered(ex);
        throw ex;
    }
}

Output:
     try {
-        getTransaction(newObject).getTxState().getEntityManager().refresh(newObject);
+        getTransaction(newObject).getTxState().getEntityManager().refresh(newObject, lockMode);
     } catch (final RuntimeException ex) {


Input:
public void testFindPaginatedResourcesReturnsBadRequestForAnInvalidPageNumber() {
    this.request("String_Node_Str").xmlPost(new Sample("String_Node_Str"));
    this.request("String_Node_Str").xmlPost(new Sample("String_Node_Str"));
    this.request("String_Node_Str").setQueryParameter("String_Node_Str", "String_Node_Str").getJson();
}

Output:
     this.request("String_Node_Str").xmlPost(new Sample("String_Node_Str"));
-    this.request("String_Node_Str").setQueryParameter("String_Node_Str", "String_Node_Str").getJson();
+    this.request("String_Node_Str").setQueryParameter("String_Node_Str", "String_Node_Str").jsonGet();
 }


Input:
private XMPPError parseError(XmlPullParser parser) throws Exception {
    String errorCode = null;
    for (int i = 0; i < parser.getAttributeCount(); i++) {
        if (parser.getAttributeName(i).equals("String_Node_Str")) {
            errorCode = parser.getAttributeValue("String_Node_Str", "String_Node_Str");
        }
    }
    String message = parser.nextText();
    while (true) {
        if (parser.getEventType() == XmlPullParser.END_TAG && parser.getName().equals("String_Node_Str")) {
            break;
        }
    }
    return new XMPPError(Integer.parseInt(errorCode), message);
}

Output:
     }
-    String message = parser.nextText();
+    try {
+        message = parser.nextText();
+    } catch (XmlPullParserException ex) {
+    }
     while (true) {


Input:
private void calculateMinMaxForNormalization(Graph graph) {
    minX = Double.POSITIVE_INFINITY;
    maxX = Double.NEGATIVE_INFINITY;
    minY = Double.POSITIVE_INFINITY;
    maxY = Double.NEGATIVE_INFINITY;
    minSize = Double.POSITIVE_INFINITY;
    maxSize = Double.NEGATIVE_INFINITY;
    for (NodeIterator nodeIterator = graph.getNodes().iterator(); nodeIterator.hasNext(); ) {
        Node node = nodeIterator.next();
        minX = Math.min(minX, node.getNodeData().x());
        maxX = Math.max(maxX, node.getNodeData().x());
        minY = Math.min(minY, node.getNodeData().y());
        maxY = Math.max(maxY, node.getNodeData().y());
        minSize = Math.min(minSize, node.getNodeData().r());
        maxSize = Math.max(maxSize, node.getNodeData().r());
    }
}

Output:
     maxSize = Double.NEGATIVE_INFINITY;
-    for (NodeIterator nodeIterator = graph.getNodes().iterator(); nodeIterator.hasNext(); ) {
-        Node node = nodeIterator.next();
+    for (Node node : graph.getNodes()) {
         minX = Math.min(minX, node.getNodeData().x());


Input:
private void addRepositoryTreeViewer(Composite leftComposite) {
    GridData gridData = new GridData(GridData.FILL_BOTH);
    gridData.widthHint = 210;
    leftComposite.setLayoutData(gridData);
    RepositoryCheckBoxView view = new RepositoryCheckBoxView();
    try {
        view.init(RepositoryView.show().getViewSite());
    } catch (PartInitException e) {
        ExceptionHandler.process(e);
    }
    view.createPartControl(leftComposite);
    processItems(versionObjects, view.getRoot());
    treeViewer = (CheckboxRepositoryTreeViewer) view.getViewer();
    treeViewer.addFilter(new ViewerFilter() {
        public boolean select(Viewer viewer, Object parentElement, Object element) {
            RepositoryNode node = (RepositoryNode) element;
            return filterRepositoryNode(node);
        }
    });
    treeViewer.addCheckStateListener(new ICheckStateListener() {
        public void checkStateChanged(CheckStateChangedEvent event) {
            RepositoryNode node = (RepositoryNode) event.getElement();
            List<ItemVersionObject> objects = new ArrayList<ItemVersionObject>();
            processItems(objects, node);
            if (!objects.isEmpty()) {
                if (event.getChecked()) {
                    checkedObjects.addAll(objects);
                } else {
                    checkedObjects.removeAll(objects);
                    removeItemElements(objects);
                }
                researchMaxVersion();
                refreshTableItems();
            }
        }
    });
    treeViewer.addTreeListener(new ITreeViewerListener() {
        public void treeCollapsed(TreeExpansionEvent event) {
        }
        public void treeExpanded(TreeExpansionEvent event) {
            refreshCheckedTreeView();
        }
    });
    expandSomeNodes(view);
}

Output:
     leftComposite.setLayoutData(gridData);
-    RepositoryCheckBoxView view = new RepositoryCheckBoxView();
-    try {
-        view.init(RepositoryView.show().getViewSite());
-    } catch (PartInitException e) {
-        ExceptionHandler.process(e);
-    }
-    view.createPartControl(leftComposite);
-    processItems(versionObjects, view.getRoot());
-    treeViewer = (CheckboxRepositoryTreeViewer) view.getViewer();
+    RepositoryViewerProvider provider = new RepositoryViewerProvider() {
+        protected RepositoryNode getInputRoot(RepositoryContentProvider contentProvider) {
+            return contentProvider.getRoot();
+        }
+        public RepositoryContentProvider getContextProvider() {
+            return new RepositoryContentProvider(getRepView());
+        }
+    };
+    treeViewer = (CheckboxRepositoryTreeViewer) provider.createViewer(leftComposite);
+    processItems(versionObjects, ((RepositoryContentProvider) treeViewer.getContentProvider()).getRoot());
     treeViewer.addFilter(new ViewerFilter() {


Input:
public Image getImage(Object element) {
    Image image = null;
    if (element instanceof File) {
        File file = (File) element;
        String fileName = file.getName();
        if (file.isDirectory()) {
            image = ImageLib.getImage(ImageLib.FOLDERNODE_IMAGE);
            EResourceConstant constant = resolveResourceConstant(fileName);
            if (constant != null) {
                switch(constant) {
                    case DATA_PROFILING:
                        image = ImageLib.getImage(ImageLib.DATA_PROFILING);
                        break;
                    case METADATA:
                        image = ImageLib.getImage(ImageLib.METADATA);
                        break;
                    case LIBRARIES:
                        image = ImageLib.getImage(ImageLib.LIBRARIES);
                        break;
                    case ANALYSIS:
                        break;
                    case REPORTS:
                        break;
                    case EXCHANGE:
                        image = ImageLib.getImage(ImageLib.EXCHANGE);
                        break;
                    case DB_CONNECTIONS:
                    case MDM_CONNECTIONS:
                        image = ImageLib.getImage(ImageLib.CONNECTION);
                        break;
                    default:
                        break;
                }
            }
        } else {
            if (fileName.endsWith(FactoriesUtil.ANA)) {
                image = ImageLib.getImage(ImageLib.ANALYSIS_OBJECT);
            } else if (fileName.endsWith(FactoriesUtil.REP)) {
                image = ImageLib.getImage(ImageLib.REPORT_OBJECT);
            } else if (fileName.endsWith(FactoriesUtil.PATTERN)) {
                image = ImageLib.getImage(ImageLib.PATTERN_REG);
            } else if (fileName.endsWith(FactoriesUtil.DQRULE)) {
                image = ImageLib.getImage(ImageLib.DQ_RULE);
            } else if (fileName.endsWith(FactoriesUtil.PROV)) {
                image = ImageLib.getImage(ImageLib.TD_DATAPROVIDER);
            } else if (fileName.endsWith(FactoriesUtil.UDI)) {
                image = ImageLib.getImage(ImageLib.IND_DEFINITION);
            }
        }
    }
    return image != null ? image : super.getImage(element);
}

Output:
     Image image = null;
-    if (element instanceof File) {
-        File file = (File) element;
+    if (element instanceof ItemRecord) {
+        ItemRecord record = (ItemRecord) element;
+        File file = record.getFile();
         String fileName = file.getName();


Input:
public void addTo(final DBObject obj) {
    if (joinMethod == CriteriaJoin.AND) {
        Map<String, Integer> fields = new HashMap<String, Integer>();
        for (final Criteria child : children) {
            String field = child.getFieldName();
            if (null != field) {
                if (fields.containsKey(field))
                    fields.put(field, fields.get(field) + 1);
                else
                    fields.put(field, 1);
            }
        }
        List<Criteria> ands = new ArrayList<Criteria>();
        for (Criteria child : this.children) {
            String field = child.getFieldName();
            if (null != field || fields.get(field) <= 1) {
                child.addTo(obj);
            } else {
                ands.add(child);
            }
        }
        if (ands.size() > 0) {
            final BasicDBList and = new BasicDBList();
            for (final Criteria child : ands) {
                final BasicDBObject container = new BasicDBObject();
                child.addTo(container);
                and.add(container);
            }
            obj.put("String_Node_Str", and);
        }
    } else if (joinMethod == CriteriaJoin.OR) {
        final BasicDBList or = new BasicDBList();
        for (final Criteria child : children) {
            final BasicDBObject container = new BasicDBObject();
            child.addTo(container);
            or.add(container);
        }
        obj.put("String_Node_Str", or);
    }
}

Output:
     if (joinMethod == CriteriaJoin.AND) {
-        Map<String, Integer> fields = new HashMap<String, Integer>();
+        final Set<String> fields = new HashSet<String>();
+        int nonNullFieldNames = 0;
         for (final Criteria child : children) {