Input:
private void updateProperty() {
    Object updateObject = result.getUpdateObject();
    if (updateObject == null) {
        return;
    }
    if (updateObject instanceof Node) {
        Node node = (Node) updateObject;
        boolean update = false;
        boolean isXsdPath = false;
        Object parameter = result.getParameter();
        if (parameter instanceof XmlFileConnectionImpl) {
            String filePath = ((XmlFileConnectionImpl) parameter).getXmlFilePath();
            if (filePath != null) {
                if (XmlUtil.isXSDFile(filePath)) {
                    isXsdPath = true;
                }
            }
        }
        if (result.getResultType() == EUpdateResult.UPDATE) {
            if (result.isChecked()) {
                for (IElementParameter param : node.getElementParameters()) {
                    String repositoryValue = param.getRepositoryValue();
                    if ((repositoryValue != null) && (param.isShow(node.getElementParameters()) || (node instanceof INode && ((INode) node).getComponent().getName().equals("String_Node_Str")) || (node instanceof INode && ((INode) node).getComponent().getName().equals("String_Node_Str")))) {
                        if (param.getName().equals(EParameterName.PROPERTY_TYPE.getName()) || param.getFieldType() == EParameterFieldType.MEMO_SQL) {
                            continue;
                        }
                        if (param.getFieldType().equals(EParameterFieldType.FILE) && isXsdPath) {
                            continue;
                        }
                        IMetadataTable table = null;
                        if (!node.getMetadataList().isEmpty()) {
                            table = node.getMetadataList().get(0);
                        }
                        Object objectValue = RepositoryToComponentProperty.getValue((org.talend.core.model.metadata.builder.connection.Connection) result.getParameter(), repositoryValue, table);
                        if (objectValue == null || "String_Node_Str".equals(objectValue)) {
                            if (GlobalServiceRegister.getDefault().isServiceRegistered(IESBService.class)) {
                                IESBService service = (IESBService) GlobalServiceRegister.getDefault().getService(IESBService.class);
                                if (service != null) {
                                    String propertyValue = (String) node.getPropertyValue(EParameterName.REPOSITORY_PROPERTY_TYPE.getName());
                                    if (node.getComponent().getName().startsWith("String_Node_Str")) {
                                        if (propertyValue.contains("String_Node_Str")) {
                                            propertyValue = propertyValue.split("String_Node_Str")[0];
                                        }
                                    }
                                    IRepositoryViewObject lastVersion = UpdateRepositoryUtils.getRepositoryObjectById(propertyValue);
                                    if (lastVersion != null) {
                                        Item item = lastVersion.getProperty().getItem();
                                        if (item != null) {
                                            objectValue = service.getValue(item, repositoryValue, node);
                                        }
                                    }
                                }
                            }
                        }
                        if (param.getName().equals(EParameterName.CDC_TYPE_MODE.getName())) {
                            String propertyValue = (String) node.getPropertyValue(EParameterName.REPOSITORY_PROPERTY_TYPE.getName());
                            Item item = null;
                            IRepositoryViewObject lastVersion = UpdateRepositoryUtils.getRepositoryObjectById(propertyValue);
                            if (lastVersion != null) {
                                item = lastVersion.getProperty().getItem();
                            }
                            if (item != null && PluginChecker.isCDCPluginLoaded()) {
                                ICDCProviderService service = (ICDCProviderService) GlobalServiceRegister.getDefault().getService(ICDCProviderService.class);
                                if (service != null) {
                                    try {
                                        List<IRepositoryViewObject> all;
                                        all = CorePlugin.getDefault().getProxyRepositoryFactory().getAll(ERepositoryObjectType.METADATA_CONNECTIONS);
                                        for (IRepositoryViewObject obj : all) {
                                            Item tempItem = obj.getProperty().getItem();
                                            if (tempItem instanceof DatabaseConnectionItem) {
                                                String cdcLinkId = service.getCDCConnectionLinkId((DatabaseConnectionItem) tempItem);
                                                if (cdcLinkId != null && item.getProperty().getId().equals(cdcLinkId)) {
                                                    objectValue = RepositoryToComponentProperty.getValue(((DatabaseConnectionItem) tempItem).getConnection(), repositoryValue, node.getMetadataList().get(0));
                                                }
                                            }
                                        }
                                    } catch (PersistenceException e) {
                                        ExceptionHandler.process(e);
                                    }
                                }
                            }
                        }
                        if (GlobalServiceRegister.getDefault().isServiceRegistered(IJsonFileService.class)) {
                            IJsonFileService jsonService = (IJsonFileService) GlobalServiceRegister.getDefault().getService(IJsonFileService.class);
                            boolean paramChanged = jsonService.changeFilePathFromRepository(result.getParameter(), param, node, objectValue);
                            if (paramChanged) {
                                continue;
                            }
                        }
                        if (objectValue != null) {
                            if (param.getFieldType().equals(EParameterFieldType.CLOSED_LIST) && repositoryValue.equals(UpdatesConstants.TYPE)) {
                                boolean found = false;
                                String[] items = param.getListRepositoryItems();
                                for (int i = 0; (i < items.length) && (!found); i++) {
                                    if (objectValue.equals(items[i])) {
                                        found = true;
                                        node.setPropertyValue(param.getName(), param.getListItemsValue()[i]);
                                    }
                                }
                            } else {
                                if (param.getFieldType().equals(EParameterFieldType.TABLE)) {
                                    String name = param.getName();
                                    if (name.equals("String_Node_Str") || name.equals("String_Node_Str") || name.equals("String_Node_Str") && objectValue instanceof List) {
                                        param.setValue(objectValue);
                                    } else if (param.getName().equals("String_Node_Str") && objectValue instanceof List) {
                                        List<Map<String, Object>> paramMaps = (List<Map<String, Object>>) param.getValue();
                                        if (paramMaps == null) {
                                            paramMaps = new ArrayList<Map<String, Object>>();
                                            node.setPropertyValue(param.getName(), paramMaps);
                                        } else {
                                            List<Map<String, Object>> objectValueList = (List<Map<String, Object>>) objectValue;
                                            if (paramMaps.size() < objectValueList.size()) {
                                                paramMaps.clear();
                                                for (int i = 0; i < objectValueList.size(); i++) {
                                                    Map<String, Object> map = objectValueList.get(i);
                                                    paramMaps.add(map);
                                                }
                                            } else {
                                                String value = null;
                                                List<String> repNames = new ArrayList<String>();
                                                for (int i = 0; i < objectValueList.size(); i++) {
                                                    repNames.add(objectValueList.get(i).get("String_Node_Str").toString());
                                                }
                                                for (int j = 0; j < paramMaps.size(); j++) {
                                                    Map<String, Object> map = paramMaps.get(j);
                                                    value = map.get("String_Node_Str").toString();
                                                    if (!repNames.contains(value)) {
                                                        paramMaps.remove(j);
                                                    }
                                                }
                                            }
                                        }
                                    } else if ((name.equals("String_Node_Str") || name.equals("String_Node_Str") && objectValue instanceof List)) {
                                        List<HashMap<String, Object>> oldValue = (List<HashMap<String, Object>>) param.getValue();
                                        for (HashMap<String, Object> map : oldValue) {
                                            if (map.get("String_Node_Str") != null && !map.get("String_Node_Str").equals("String_Node_Str")) {
                                                ((List<HashMap<String, Object>>) objectValue).add(map);
                                            }
                                        }
                                        param.setValue(objectValue);
                                    } else if (param.getName().equals("String_Node_Str") && objectValue instanceof List) {
                                        param.setValue(objectValue);
                                    }
                                } else {
                                    node.setPropertyValue(param.getName(), objectValue);
                                }
                            }
                        } else if (param.getFieldType().equals(EParameterFieldType.TABLE) && UpdatesConstants.XML_MAPPING.equals(repositoryValue)) {
                            RepositoryToComponentProperty.getTableXMLMappingValue((org.talend.core.model.metadata.builder.connection.Connection) result.getParameter(), (List<Map<String, Object>>) param.getValue(), node);
                        } else if (param.getFieldType().equals(EParameterFieldType.TABLE) && param.getName().equals("String_Node_Str")) {
                            objectValue = RepositoryToComponentProperty.getValue((org.talend.core.model.metadata.builder.connection.Connection) result.getParameter(), "String_Node_Str", node.getMetadataList().get(0));
                            List<Map<String, Object>> paramMaps = (List<Map<String, Object>>) param.getValue();
                            if (paramMaps == null) {
                                paramMaps = new ArrayList<Map<String, Object>>();
                            } else {
                                paramMaps.clear();
                            }
                            if (objectValue != null) {
                                List<String> objectValueList = (List<String>) objectValue;
                                for (int i = 0; i < objectValueList.size(); i++) {
                                    Map<String, Object> map = new HashedMap();
                                    map.put("String_Node_Str", TalendTextUtils.addQuotes(objectValueList.get(i)));
                                    paramMaps.add(map);
                                }
                            }
                        }
                        if (!("String_Node_Str".equals(node.getComponent().getName()) && "String_Node_Str".equals(param.getRepositoryValue()))) {
                            param.setRepositoryValueUsed(true);
                            param.setReadOnly(true);
                            update = true;
                        }
                    }
                }
            }
        }
        if (!update) {
            String propertyName = EParameterName.PROPERTY_TYPE.getName();
            String parentParamName = "String_Node_Str";
            if (this.result.getParameter() instanceof IElementParameter) {
                IElementParameter parentParam = ((IElementParameter) this.result.getParameter()).getParentParameter();
                if (parentParam != null) {
                    parentParamName = parentParam.getName();
                    propertyName = parentParam.getName() + "String_Node_Str" + parentParam.getChildParameters().get(EParameterName.PROPERTY_TYPE.getName()).getName();
                }
            }
            node.setPropertyValue(propertyName, EmfComponent.BUILTIN);
            for (IElementParameter param : node.getElementParameters()) {
                if (param.getRepositoryValue() == null || param.getRepositoryProperty() != null && !param.getRepositoryProperty().equals(parentParamName)) {
                    continue;
                }
                if (param.isShow(node.getElementParameters())) {
                    if (param.getName().equals(EParameterName.PROPERTY_TYPE.getName()) || param.getFieldType() == EParameterFieldType.MEMO_SQL) {
                        continue;
                    }
                    param.setRepositoryValueUsed(false);
                    param.setReadOnly(false);
                }
            }
        }
    }
}

Output:
         Object parameter = result.getParameter();
-        if (parameter instanceof XmlFileConnectionImpl) {
-            String filePath = ((XmlFileConnectionImpl) parameter).getXmlFilePath();
-            if (filePath != null) {
-                if (XmlUtil.isXSDFile(filePath)) {
-                    isXsdPath = true;
+        IElementParameter curPropertyParam = null;
+        String parentParamName = "String_Node_Str";
+        ConnectionItem connectionItem = null;
+        if (parameter instanceof ConnectionItem) {
+            if (parameter instanceof XmlFileConnectionItem) {
+                String filePath = ((XmlFileConnection) ((XmlFileConnectionItem) parameter).getConnection()).getXmlFilePath();
+                if (filePath != null) {
+                    if (XmlUtil.isXSDFile(filePath)) {
+                        isXsdPath = true;
+                    }
+                }
+            }
+            connectionItem = (ConnectionItem) result.getParameter();
+            for (IElementParameter param : node.getElementParameters()) {
+                if (param.getFieldType() == EParameterFieldType.PROPERTY_TYPE && param.getChildParameters().get(EParameterName.REPOSITORY_PROPERTY_TYPE.getName()).getValue().equals(connectionItem.getProperty().getId())) {
+                    curPropertyParam = param;
+                    parentParamName = curPropertyParam.getName();
+                    break;
                 }


Input:
public void onTodoListLoaded(List<AbstractFlexibleItem> items) {
    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
    boolean permanentDelete = !sharedPreferences.getBoolean(KEY_PREF_HEADER_OR_ITEM, true);
    mAdapter = new FlexibleAdapter<>(items);
    mRecyclerView.setupRecyclerView(mEmptyView, mAdapter, mFabMenu);
    mRecyclerView.setupFlexibleAdapter(this, mAdapter, permanentDelete);
    initializeActionModeHelper();
}

Output:
     mAdapter = new FlexibleAdapter<>(items);
-    mRecyclerView.setupRecyclerView(mEmptyView, mAdapter, mFabMenu);
-    mRecyclerView.setupFlexibleAdapter(this, mAdapter, permanentDelete);
+    mRecyclerView.configure(mEmptyView, mAdapter, mFabMenu);
+    setupFlexibleAdapter(this, mAdapter, permanentDelete);
     initializeActionModeHelper();


Input:
public void bindLocationListener() {
    locManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    locListener = new LocationListener(this.getApplicationContext());
    Log.e(TAG, "String_Node_Str");
    locManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locListener);
}

Output:
     locManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
-    locListener = new LocationListener(this.getApplicationContext());
+    loc = new Location(this.getApplicationContext());
     Log.e(TAG, "String_Node_Str");


Input:
public void init(IConfiguration configuration) throws InitializationException {
    this.connectionHandler = new DeepConnectionHandler(new ConnectionConfiguration());
    this.deepContext = ConnectionConfiguration.getDeepContext();
}

Output:
 public void init(IConfiguration configuration) throws InitializationException {
-    this.connectionHandler = new DeepConnectionHandler(new ConnectionConfiguration());
+    this.connectionHandler = new DeepConnectionHandler(null);
     this.deepContext = ConnectionConfiguration.getDeepContext();


Input:
public void testExpression() {
    DynamicTextItemDesign multi = new DynamicTextItemDesign();
    Expression<String> exp = Expression.newConstant("String_Node_Str");
    Expression<String> type = Expression.newConstant("String_Node_Str");
    multi.setContent(exp);
    multi.setContentType(type);
    assertEquals(multi.getContent(), exp);
    assertEquals(multi.getContentType(), type);
}

Output:
     DynamicTextItemDesign multi = new DynamicTextItemDesign();
-    Expression<String> exp = Expression.newConstant("String_Node_Str");
+    Expression<Object> exp = new Expression<Object>("String_Node_Str", Object.class);
     Expression<String> type = Expression.newConstant("String_Node_Str");


Input:
public boolean isValidExpansion(ItemStack input, ItemStack expansion) {
    if (StackHelper.isMatchingItem(ItemRedstoneChipset.Chipset.RED.getStack(), expansion, true, true)) {
        return true;
    }
    for (ItemStack s : recipes.values()) {
        if (StackHelper.isMatchingItem(s, expansion, true, true)) {
            return true;
        }
    }
    return false;
}

Output:
 public boolean isValidExpansion(ItemStack input, ItemStack expansion) {
-    if (StackHelper.isMatchingItem(ItemRedstoneChipset.Chipset.RED.getStack(), expansion, true, true)) {
+    if (StackHelper.isMatchingItem(EnumRedstoneChipset.RED.getStack(), expansion, true, true)) {
         return true;


Input:
public void selectionChanged(SelectionChangedEvent arg0) {
    int index = table.getSelectionIndex();
    String selectedTable = wizardImport.getData().getJdbcTables().get(index);
    wizardImport.getData().setSelectedJdbcTable(selectedTable);
    readColumns();
    readPreview();
    setPageComplete(true);
}

Output:
     readColumns();
-    readPreview();
-    setPageComplete(true);
+    setPageComplete(readPreview());
 }


Input:
private void intLoop(Raster source, WritableRaster dest, Rectangle destRect) {
    float src_rect_x1 = source.getMinX();
    float src_rect_y1 = source.getMinY();
    float src_rect_x2 = src_rect_x1 + source.getWidth();
    float src_rect_y2 = src_rect_y1 + source.getHeight();
    MultiPixelPackedSampleModel sourceSM = (MultiPixelPackedSampleModel) source.getSampleModel();
    DataBufferInt sourceDB = (DataBufferInt) source.getDataBuffer();
    int sourceTransX = source.getSampleModelTranslateX();
    int sourceTransY = source.getSampleModelTranslateY();
    int sourceDataBitOffset = sourceSM.getDataBitOffset();
    int sourceScanlineStride = sourceSM.getScanlineStride();
    MultiPixelPackedSampleModel destSM = (MultiPixelPackedSampleModel) dest.getSampleModel();
    DataBufferInt destDB = (DataBufferInt) dest.getDataBuffer();
    int destMinX = dest.getMinX();
    int destMinY = dest.getMinY();
    int destTransX = dest.getSampleModelTranslateX();
    int destTransY = dest.getSampleModelTranslateY();
    int destDataBitOffset = destSM.getDataBitOffset();
    int destScanlineStride = destSM.getScanlineStride();
    int[] sourceData = sourceDB.getData();
    int sourceDBOffset = sourceDB.getOffset();
    int[] destData = destDB.getData();
    int destDBOffset = destDB.getOffset();
    Point2D dst_pt = new Point2D.Float();
    Point2D src_pt = new Point2D.Float();
    int dst_min_x = destRect.x;
    int dst_min_y = destRect.y;
    int dst_max_x = destRect.x + destRect.width;
    int dst_max_y = destRect.y + destRect.height;
    int incyStride = incy * sourceScanlineStride;
    int incy1Stride = incy1 * sourceScanlineStride;
    black = ((int) backgroundValues[0]) & 1;
    for (int y = dst_min_y; y < dst_max_y; y++) {
        dst_pt.setLocation((double) dst_min_x + 0.5, (double) y + 0.5);
        mapDestPoint(dst_pt, src_pt);
        float s_x = (float) src_pt.getX();
        float s_y = (float) src_pt.getY();
        int s_ix = (int) Math.floor(s_x);
        int s_iy = (int) Math.floor(s_y);
        double fracx = s_x - (double) s_ix;
        double fracy = s_y - (double) s_iy;
        int ifracx = (int) Math.floor(fracx * geom_frac_max);
        int ifracy = (int) Math.floor(fracy * geom_frac_max);
        int start_s_ix = s_ix;
        int start_s_iy = s_iy;
        int start_ifracx = ifracx;
        int start_ifracy = ifracy;
        Range clipRange = performScanlineClipping(src_rect_x1, src_rect_y1, src_rect_x2, src_rect_y2, s_ix, s_iy, ifracx, ifracy, dst_min_x, dst_max_x, 0, 0, 0, 0);
        int clipMinX = ((Integer) clipRange.getMinValue()).intValue();
        int clipMaxX = ((Integer) clipRange.getMaxValue()).intValue();
        if (clipMinX > clipMaxX)
            continue;
        int destYOffset = (y - destTransY) * destScanlineStride + destDBOffset;
        int destXOffset = destDataBitOffset + (dst_min_x - destTransX);
        int sourceYOffset = (s_iy - sourceTransY) * sourceScanlineStride + sourceDBOffset;
        int sourceXOffset = s_ix - sourceTransX + sourceDataBitOffset;
        for (int x = dst_min_x; x < clipMinX; x++) {
            if (setBackground) {
                int dindex = destYOffset + (destXOffset >> 5);
                int dshift = 31 - (destXOffset & 31);
                int delement = destData[dindex];
                delement |= black << dshift;
                destData[dindex] = (int) delement;
            }
            if (ifracx < ifracdx1) {
                s_ix += incx;
                ifracx += ifracdx;
                sourceXOffset += incx;
            } else {
                s_ix += incx1;
                ifracx -= ifracdx1;
                sourceXOffset += incx1;
            }
            if (ifracy < ifracdy1) {
                s_iy += incy;
                ifracy += ifracdy;
                sourceYOffset += incyStride;
            } else {
                s_iy += incy1;
                ifracy -= ifracdy1;
                sourceYOffset += incy1Stride;
            }
            ++destXOffset;
        }
        for (int x = clipMinX; x < clipMaxX; x++) {
            int sindex = sourceYOffset + (sourceXOffset >> 5);
            int selement = sourceData[sindex];
            int val = (selement >> (31 - (sourceXOffset & 31))) & 1;
            int dindex = destYOffset + (destXOffset >> 5);
            int dshift = 31 - (destXOffset & 31);
            int delement = destData[dindex];
            delement |= val << dshift;
            destData[dindex] = (int) delement;
            if (ifracx < ifracdx1) {
                s_ix += incx;
                ifracx += ifracdx;
                sourceXOffset += incx;
            } else {
                s_ix += incx1;
                ifracx -= ifracdx1;
                sourceXOffset += incx1;
            }
            if (ifracy < ifracdy1) {
                s_iy += incy;
                ifracy += ifracdy;
                sourceYOffset += incyStride;
            } else {
                s_iy += incy1;
                ifracy -= ifracdy1;
                sourceYOffset += incy1Stride;
            }
            ++destXOffset;
        }
        for (int x = clipMaxX; x < dst_max_x; x++) {
            if (setBackground) {
                int dindex = destYOffset + (destXOffset >> 5);
                int dshift = 31 - (destXOffset & 31);
                int delement = destData[dindex];
                delement |= black << dshift;
                destData[dindex] = (int) delement;
            }
            if (ifracx < ifracdx1) {
                s_ix += incx;
                ifracx += ifracdx;
                sourceXOffset += incx;
            } else {
                s_ix += incx1;
                ifracx -= ifracdx1;
                sourceXOffset += incx1;
            }
            if (ifracy < ifracdy1) {
                s_iy += incy;
                ifracy += ifracdy;
                sourceYOffset += incyStride;
            } else {
                s_iy += incy1;
                ifracy -= ifracdy1;
                sourceYOffset += incy1Stride;
            }
            ++destXOffset;
        }
    }
}

Output:
         int start_ifracy = ifracy;
-        Range clipRange = performScanlineClipping(src_rect_x1, src_rect_y1, src_rect_x2, src_rect_y2, s_ix, s_iy, ifracx, ifracy, dst_min_x, dst_max_x, 0, 0, 0, 0);
+        Range clipRange = performScanlineClipping(src_rect_x1, src_rect_y1, src_rect_x2 - 1, src_rect_y2 - 1, s_ix, s_iy, ifracx, ifracy, dst_min_x, dst_max_x, 0, 0, 0, 0);
         int clipMinX = ((Integer) clipRange.getMinValue()).intValue();


Input:
public void addToModel(RelativePosition position, AbstractEnvironmentValue value) {
    List<ParameterValue<?>> realDataPoint = this.getRealPosition(position);
    realDataPoint.add(value.getValue());
    for (ParameterValue<?> parameterValue : realDataPoint) {
        AbstractDataSetColumn<?> column = null;
        column = modifier.getColumn(parameterValue.getParameter());
        if (column == null) {
            column = modifier.addColumn(parameterValue.getParameter());
        }
        column.getParameterValues().add(parameterValue);
    }
    this.resultIsInvalid = true;
}

Output:
     for (ParameterValue<?> parameterValue : realDataPoint) {
-        AbstractDataSetColumn<?> column = null;
-        column = modifier.getColumn(parameterValue.getParameter());
-        if (column == null) {
-            column = modifier.addColumn(parameterValue.getParameter());
+        if (parameterValue.getParameter().getRole().equals(ParameterRole.INPUT)) {
+            dataSetBuilder.addInputParameterValue(parameterValue.getParameter(), parameterValue.getValue());
+        } else {
+            dataSetBuilder.addObservationParameterValue(parameterValue.getParameter(), parameterValue.getValue());
         }


Input:
public synchronized boolean startRecording() {
    if (audioLine.isOpen()) {
        setRecording(true);
        notifyAll();
        while (!isStarted()) {
            try {
                wait();
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
        }
        return true;
    } else {
        return false;
    }
}

Output:
 public synchronized boolean startRecording() {
-    if (audioLine.isOpen()) {
+    if (open()) {
         setRecording(true);


Input:
private void indexPath(Path file, BasicFileAttributes attrs) {
    Date modifiedDate = new Date(attrs.lastModifiedTime().toMillis());
    if (from == null || from.before(modifiedDate)) {
        transferredResourceAdded(FolderMonitorNIO.createTransferredResource(file, basePath), false);
        counter++;
        if (counter >= 1000) {
            try {
                LOGGER.error("String_Node_Str");
                index.commit(RodaConstants.INDEX_SIP);
                counter = 0;
            } catch (IOException | SolrServerException e) {
                LOGGER.error(e.getMessage(), e);
            }
        }
    }
}

Output:
             try {
-                LOGGER.error("String_Node_Str");
+                LOGGER.debug("String_Node_Str");
                 index.commit(RodaConstants.INDEX_SIP);


Input:
public void run() {
    for (final IIngredient ingredient : recipe.getInput()) {
        int quantityToConsume = ingredient.getQuantityConsumed();
        for (final ItemStack itemStack : ingredient.getItemStacks()) {
            quantityToConsume -= playerInventory.clearMatchingItems(itemStack.getItem(), itemStack.getMetadata(), quantityToConsume, itemStack.getTagCompound());
            playerInventory.markDirty();
            if (quantityToConsume <= 0) {
                break;
            }
        }
    }
    for (final ItemStack itemStack : recipe.getOutput()) {
        final ItemStack copy = itemStack.copy();
        if (!playerInventory.addItemStackToInventory(copy)) {
            ctx.getServerHandler().playerEntity.dropItem(copy, true);
        } else {
            playerInventory.markDirty();
        }
    }
}

Output:
     }
-    for (final ItemStack itemStack : recipe.getOutput()) {
-        final ItemStack copy = itemStack.copy();
-        if (!playerInventory.addItemStackToInventory(copy)) {
-            ctx.getServerHandler().playerEntity.dropItem(copy, true);
-        } else {
-            playerInventory.markDirty();
         }

         }
+        for (final ItemStack itemStack : recipe.getOutput()) {
+            final ItemStack copy = itemStack.copy();
+            if (!playerInventory.addItemStackToInventory(copy)) {
+                ctx.getServerHandler().playerEntity.dropItem(copy, true);
+            } else {
+                playerInventory.markDirty();
     }


Input:
public static Boolean toBoolean(Object source) throws BirtException {
    if (source == null)
        return null;
    if (source instanceof Boolean) {
        return (Boolean) source;
    } else if (source instanceof Number) {
        if (((Number) source).doubleValue() == 0)
            return new Boolean(false);
        return new Boolean(true);
    } else if (source instanceof String) {
        if (((String) source).equalsIgnoreCase("String_Node_Str"))
            return Boolean.TRUE;
        else if (((String) source).equalsIgnoreCase("String_Node_Str"))
            return Boolean.FALSE;
        else {
            try {
                if (Integer.parseInt((String) source) == 0)
                    return Boolean.FALSE;
                else
                    return Boolean.TRUE;
            } catch (NumberFormatException e) {
                throw new CoreException(ResourceConstants.CONVERT_FAILS, new Object[] { source.toString(), "String_Node_Str" });
            }
        }
    } else {
        throw new CoreException(ResourceConstants.CONVERT_FAILS, new Object[] { source.toString(), "String_Node_Str" });
    }
}

Output:
     if (source == null)
-        return null;
+        return Boolean.FALSE;
     if (source instanceof Boolean) {


Input:
public Object executeTransform(final Object input) {
    if (input instanceof OIdentifiable) {
        final ORecord rec = ((OIdentifiable) input).getRecord();
        if (rec instanceof ODocument) {
            final ODocument doc = (ODocument) rec;
            if (setOperation) {
                final Object newValue;
                if (expression != null) {
                    if (sqlFilter == null)
                        sqlFilter = new OSQLFilter(expression, context, null);
                    newValue = sqlFilter.evaluate(doc, null, context);
                } else
                    newValue = value;
                doc.field(fieldName, newValue);
                log(OETLProcessor.LOG_LEVELS.DEBUG, "String_Node_Str", fieldName, newValue, doc);
            } else {
                final Object prev = doc.removeField(fieldName);
                log(OETLProcessor.LOG_LEVELS.DEBUG, "String_Node_Str", fieldName, prev, doc);
            }
            if (save) {
                final ODatabaseDocumentTx db = super.pipeline.getDocumentDatabase();
                if (db == null)
                    throw new OETLProcessHaltedException("String_Node_Str");
                db.save(doc);
            }
        }
    }
    return input;
}

Output:
                 if (db == null)
-                    throw new OETLProcessHaltedException("String_Node_Str");
+                    throw new OTransformException("String_Node_Str");
                 db.save(doc);


Input:
public static void main(String[] args) {
    String points = args[0];
    String canopies = args[1];
    String output = args[2];
    String measureClassName = args[3];
    float t1 = new Float(args[4]);
    float t2 = new Float(args[5]);
    String jarLocation = "String_Node_Str";
    if (args.length > 6) {
        jarLocation = args[6];
    }
    runJob(points, canopies, output, measureClassName, t1, t2, jarLocation);
}

Output:
     float t2 = new Float(args[5]);
-    String jarLocation = "String_Node_Str";
-    if (args.length > 6) {
-        jarLocation = args[6];
-    }
-    runJob(points, canopies, output, measureClassName, t1, t2, jarLocation);
+    runJob(points, canopies, output, measureClassName, t1, t2);
 }


Input:
public void computeTileStack(Map<Band, Tile> targetTiles, Rectangle targetRectangle, ProgressMonitor pm) throws OperatorException {
    try {
        processingStarted = true;
        try {
            if (!isElevationModelAvailable) {
                getElevationModel();
            }
        } catch (Exception e) {
            throw new OperatorException(e);
        }
        final int x0 = targetRectangle.x;
        final int y0 = targetRectangle.y;
        final int w = targetRectangle.width;
        final int h = targetRectangle.height;
        final TileGeoreferencing tileGeoRef = new TileGeoreferencing(targetProduct, x0 - 1, y0 - 1, w + 2, h + 2);
        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, nodataValueAtSea, localDEM);
            if (!valid && nodataValueAtSea)
                return;
        }
        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 incidenceAngleFromEllipsoidBuffer = null;
        final List<TileData> trgTileList = new ArrayList<>();
        final Set<Band> keySet = targetTiles.keySet();
        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("String_Node_Str")) {
                incidenceAngleFromEllipsoidBuffer = targetTiles.get(targetBand).getDataBuffer();
                continue;
            }
            final Band[] srcBands = targetBandNameToSourceBand.get(targetBand.getName());
            final TileData td = new 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 int maxY = y0 + h;
        final int maxX = x0 + w;
        final TileData[] trgTiles = trgTileList.toArray(new TileData[trgTileList.size()]);
        final EarthGravitationalModel96 egm = EarthGravitationalModel96.instance();
        int diffLat = Math.abs(latitude.getPixelInt(0, 0) - latitude.getPixelInt(0, targetImageHeight));
        for (int y = y0; y < maxY; y++) {
            final int yy = y - y0 + 1;
            for (int x = x0; x < maxX; x++) {
                final int index = trgTiles[0].targetTile.getDataBufferIndex(x, y);
                double alt = localDEM[yy][x - x0 + 1];
                if (alt == demNoDataValue && !useAvgSceneHeight) {
                    if (nodataValueAtSea) {
                        continue;
                    }
                }
                tileGeoRef.getGeoPos(x, y, geoPos);
                final double lat = geoPos.lat;
                double lon = geoPos.lon;
                if (lon >= 180.0) {
                    lon -= 360.0;
                }
                if (alt == demNoDataValue && !nodataValueAtSea) {
                    alt = egm.getEGM(lat, lon);
                }
                GeoUtils.geo2xyzWGS84(lat, lon, alt, earthPoint);
                double zeroDopplerTime = SARGeocoding.getEarthPointZeroDopplerTime(firstLineUTC, lineTimeInterval, wavelength, earthPoint, orbit.sensorPosition, orbit.sensorVelocity);
                if (Double.compare(zeroDopplerTime, SARGeocoding.NonValidZeroDopplerTime) == 0) {
                    if (saveDEM) {
                        demBuffer.setElemDoubleAt(index, demNoDataValue);
                    }
                    continue;
                }
                double slantRange = SARGeocoding.computeSlantRange(zeroDopplerTime, orbit, earthPoint, sensorPos);
                if (!skipBistaticCorrection) {
                    zeroDopplerTime += slantRange / Constants.lightSpeedInMetersPerDay;
                    slantRange = SARGeocoding.computeSlantRange(zeroDopplerTime, orbit, earthPoint, sensorPos);
                }
                double rangeIndex = SARGeocoding.computeRangeIndex(srgrFlag, sourceImageWidth, firstLineUTC, lastLineUTC, rangeSpacing, zeroDopplerTime, slantRange, nearEdgeSlantRange, srgrConvParams);
                if (rangeIndex == -1.0) {
                    if (saveDEM) {
                        demBuffer.setElemDoubleAt(index, demNoDataValue);
                    }
                    continue;
                }
                if (!nearRangeOnLeft) {
                    rangeIndex = srcMaxRange - rangeIndex;
                }
                final double azimuthIndex = (zeroDopplerTime - firstLineUTC) / lineTimeInterval;
                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 (saveIncidenceAngleFromEllipsoid && incidenceAngle != null) {
                        incidenceAngleFromEllipsoidBuffer.setElemDoubleAt(index, incidenceAngle.getPixelDouble(rangeIndex, azimuthIndex));
                    }
                    double satelliteHeight = 0;
                    double sceneToEarthCentre = 0;
                    if (saveSigmaNought) {
                        satelliteHeight = Math.sqrt(sensorPos.x * sensorPos.x + sensorPos.y * sensorPos.y + sensorPos.z * sensorPos.z);
                        sceneToEarthCentre = Math.sqrt(earthPoint.x * earthPoint.x + earthPoint.y * earthPoint.y + earthPoint.z * earthPoint.z);
                    }
                    for (TileData tileData : trgTiles) {
                        int[] subSwathIndex = { INVALID_SUB_SWATH_INDEX };
                        double v = getPixelValue(azimuthIndex, rangeIndex, tileData, subSwathIndex);
                        if (v != tileData.noDataValue && tileData.applyRadiometricNormalization) {
                            if (localIncidenceAngles[1] != SARGeocoding.NonValidIncidenceAngle) {
                                v = calibrator.applyCalibration(v, rangeIndex, azimuthIndex, slantRange, satelliteHeight, sceneToEarthCentre, localIncidenceAngles[1], tileData.bandPolar, tileData.bandUnit, subSwathIndex);
                            } else {
                                v = tileData.noDataValue;
                            }
                        }
                        tileData.tileDataBuffer.setElemDoubleAt(index, v);
                    }
                    orthoDataProduced = true;
                }
            }
        }
        localDEM = null;
    } catch (Throwable e) {
        orthoDataProduced = true;
        OperatorUtils.catchOperatorException(getId(), e);
    }
}

Output:
                             if (localIncidenceAngles[1] != SARGeocoding.NonValidIncidenceAngle) {
-                                v = calibrator.applyCalibration(v, rangeIndex, azimuthIndex, slantRange, satelliteHeight, sceneToEarthCentre, localIncidenceAngles[1], tileData.bandPolar, tileData.bandUnit, subSwathIndex);
+                                v = calibrator.applyCalibration(v, rangeIndex, azimuthIndex, slantRange, satelliteHeight, sceneToEarthCentre, localIncidenceAngles[1], tileData.bandName, tileData.bandPolar, tileData.bandUnit, subSwathIndex);
                             } else {


Input:
public void run() {
    LOG.log(Level.INFO, "String_Node_Str");
    for (int i = 0; i < 100000; i++) {
        IntData data = generateData();
        while (!reduce.send(0, data)) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        sendCount++;
        Thread.yield();
    }
    status = Status.MAP_FINISHED;
}

Output:
         IntData data = generateData();
-        while (!reduce.send(0, data)) {
-            try {
-                Thread.sleep(1);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
+        for (int j = 0; j < NO_OF_TASKS - 1; j++) {
+            while (!reduce.send(j, data)) {
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
             }


Input:
public synchronized QueryResultSet findLast(int count) throws RuntimeException {
    Vector filelist = filterFilesByDate(this.historyImpl.getFileList(), null, null);
    TreeSet result = new TreeSet(new HistoryRecordComparator());
    int leftCount = count;
    int currentFile = filelist.size() - 1;
    while (leftCount > 0 && currentFile >= 0) {
        Document doc = this.historyImpl.getDocumentForFile((String) filelist.get(currentFile));
        if (doc == null) {
            currentFile--;
            continue;
        }
        List nodes = new ArrayList();
        NodeList nodesList = doc.getElementsByTagName("String_Node_Str");
        for (int i = 0; i < nodesList.getLength(); i++) {
            nodes.add(nodesList.item(i));
        }
        List lNodes = null;
        if (nodes.size() > leftCount) {
            lNodes = nodes.subList(nodes.size() - leftCount, nodes.size());
            leftCount = 0;
        } else {
            lNodes = nodes;
            leftCount -= nodes.size();
        }
        Iterator i = lNodes.iterator();
        while (i.hasNext()) {
            Node node = (Node) i.next();
            NodeList propertyNodes = node.getChildNodes();
            String ts = node.getAttributes().getNamedItem("String_Node_Str").getNodeValue();
            Date timestamp = new Date(Long.parseLong(ts));
            ArrayList nameVals = new ArrayList();
            boolean isRecordOK = true;
            int len = propertyNodes.getLength();
            for (int j = 0; j < len; j++) {
                Node propertyNode = propertyNodes.item(j);
                if (propertyNode.getNodeType() == Node.ELEMENT_NODE) {
                    Node nodeValue = propertyNode.getFirstChild();
                    if (nodeValue != null) {
                        nameVals.add(propertyNode.getNodeName());
                        nameVals.add(nodeValue.getNodeValue());
                    } else
                        isRecordOK = false;
                }
            }
            if (!isRecordOK)
                continue;
            String[] propertyNames = new String[nameVals.size() / 2];
            String[] propertyValues = new String[propertyNames.length];
            for (int j = 0; j < propertyNames.length; j++) {
                propertyNames[j] = (String) nameVals.get(j * 2);
                propertyValues[j] = (String) nameVals.get(j * 2 + 1);
            }
            HistoryRecord record = new HistoryRecord(propertyNames, propertyValues, timestamp);
            result.add(record);
        }
        currentFile--;
    }
    return new OrderedQueryResultSet(result);
}

Output:
 public synchronized QueryResultSet findLast(int count) throws RuntimeException {
-    Vector filelist = filterFilesByDate(this.historyImpl.getFileList(), null, null);
-    TreeSet result = new TreeSet(new HistoryRecordComparator());
+    Vector<String> filelist = filterFilesByDate(this.historyImpl.getFileList(), null, null);
+    TreeSet<HistoryRecord> result = new TreeSet<HistoryRecord>(new HistoryRecordComparator());
     int leftCount = count;


Input:
public int addItem(ItemStack stack, boolean doAdd, ForgeDirection from) {
    if (this.containesContainer(stack)) {
        ItemStack cu = inv[0].copy();
        if (cu.isItemEqual(stack)) {
            int left = 64 - (stack.stackSize + cu.stackSize);
            if (left < 0) {
                if (doAdd) {
                    cu.stackSize = 64;
                    inv[0] = cu;
                }
                return stack.stackSize - left;
            } else {
                if (doAdd) {
                    cu.stackSize += stack.stackSize;
                    inv[0] = cu;
                }
                return stack.stackSize;
            }
        }
    }
    return 0;
}

Output:
     if (this.containesContainer(stack)) {
-        ItemStack cu = inv[0].copy();
-        if (cu.isItemEqual(stack)) {
-            int left = 64 - (stack.stackSize + cu.stackSize);
-            if (left < 0) {
-                if (doAdd) {
-                    cu.stackSize = 64;
-                    inv[0] = cu;
+        ItemStack cu = inv[0];
+        if (cu != null) {
+            if (cu.isItemEqual(stack)) {
+                int left = stack.getMaxStackSize() - (stack.stackSize + cu.stackSize);
+                if (left < 0) {
+                    if (doAdd) {
+                        cu.stackSize = 64;
+                        inv[0] = cu;
+                    }
+                    return stack.stackSize - left;
+                } else {
+                    if (doAdd) {
+                        cu.stackSize += stack.stackSize;
+                        inv[0] = cu;
+                    }
+                    return stack.stackSize;
                 }


Input:
public void drawBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
    time.value = timeOpen + partialTicks;
    varData.refresh();
    super.drawBackgroundLayer(partialTicks, mouseX, mouseY);
}

Output:
     varData.refresh();
-    super.drawBackgroundLayer(partialTicks, mouseX, mouseY);
+    super.drawBackgroundLayer(partialTicks, mouseX, mouseY, backgroundRenderer);
 }


Input:
public void onBindViewHolder(GridViewHolder holder, int position) {
    if (!isValidPosition(position)) {
        return;
    }
    MediaModel media = mMediaList.get(position);
    String strState = media.getUploadState();
    MediaUploadState state = MediaUploadState.fromString(strState);
    boolean isLocalFile = MediaUtils.isLocalFile(strState) && !TextUtils.isEmpty(media.getFilePath());
    boolean isSelected = isItemSelected(media.getId());
    boolean canSelect = canSelectPosition(position);
    boolean isImage = media.getMimeType() != null && media.getMimeType().startsWith("String_Node_Str");
    if (!mLoadThumbnails) {
        holder.mFileContainer.setVisibility(View.GONE);
        mImageManager.load(holder.mImageView, ImageType.PHOTO, "String_Node_Str", ScaleType.CENTER_CROP);
    } else if (isImage) {
        holder.mFileContainer.setVisibility(View.GONE);
        if (isLocalFile) {
            mImageManager.load(holder.mImageView, ImageType.PHOTO, media.getFilePath(), ScaleType.CENTER_CROP);
        } else {
            mImageManager.load(holder.mImageView, ImageType.PHOTO, getBestImageUrl(media), ScaleType.CENTER_CROP);
        }
    } else if (media.isVideo()) {
        holder.mFileContainer.setVisibility(View.GONE);
        loadVideoThumbnail(media, holder.mImageView);
    } else {
        holder.mImageView.setImageDrawable(null);
        String fileName = media.getFileName();
        String title = media.getTitle();
        String fileExtension = MediaUtils.getExtensionForMimeType(media.getMimeType());
        holder.mFileContainer.setVisibility(View.VISIBLE);
        holder.mTitleView.setText(TextUtils.isEmpty(title) ? fileName : title);
        holder.mFileTypeView.setText(fileExtension.toUpperCase(Locale.ROOT));
        int placeholderResId = WPMediaUtils.getPlaceholder(fileName);
        holder.mFileTypeImageView.setImageResource(placeholderResId);
    }
    holder.mImageView.setContentDescription(mContext.getString(R.string.media_grid_item_image_desc, StringUtils.notNullStr(media.getFileName())));
    if (mBrowserType.canMultiselect() && canSelect) {
        holder.mSelectionCountContainer.setVisibility(View.VISIBLE);
        holder.mSelectionCountTextView.setVisibility(View.VISIBLE);
        holder.mSelectionCountTextView.setSelected(isSelected);
        if (isSelected) {
            int count = mSelectedItems.indexOf(media.getId()) + 1;
            holder.mSelectionCountTextView.setText(String.format(Locale.getDefault(), "String_Node_Str", count));
        } else {
            holder.mSelectionCountTextView.setText(null);
        }
    } else {
        holder.mSelectionCountContainer.setVisibility(View.GONE);
        holder.mSelectionCountTextView.setVisibility(View.GONE);
    }
    float scale = isSelected ? SCALE_SELECTED : SCALE_NORMAL;
    if (holder.mImageView.getScaleX() != scale) {
        holder.mImageView.setScaleX(scale);
        holder.mImageView.setScaleY(scale);
    }
    if (state != MediaUploadState.UPLOADED) {
        holder.mStateContainer.setVisibility(View.VISIBLE);
        boolean showProgress = state == MediaUploadState.UPLOADING || state == MediaUploadState.DELETING;
        holder.mProgressUpload.setVisibility(showProgress ? View.VISIBLE : View.GONE);
        if (state == MediaUploadState.FAILED || state == MediaUploadState.QUEUED) {
            holder.mRetryDeleteContainer.setVisibility(View.VISIBLE);
            holder.mImgRetry.setVisibility(state == MediaUploadState.FAILED ? View.VISIBLE : View.GONE);
        } else {
            holder.mRetryDeleteContainer.setVisibility(View.GONE);
        }
        holder.mStateTextView.setText(getLabelForMediaUploadState(state));
        holder.mVideoOverlayContainer.setVisibility(View.GONE);
    } else {
        holder.mStateContainer.setVisibility(View.GONE);
        holder.mStateContainer.setOnClickListener(null);
        holder.mVideoOverlayContainer.setVisibility(media.isVideo() ? View.VISIBLE : View.GONE);
    }
    if (position == getItemCount() - 1 && !mHasRetrievedAll && mCallback != null) {
        mCallback.onAdapterFetchMoreData();
    }
}

Output:
     } else {
-        holder.mImageView.setImageDrawable(null);
+        mImageManager.cancelRequestAndClearImageView(holder.mImageView);
         String fileName = media.getFileName();


Input:
private static void initPool() {
    JedisPoolConfig config = new JedisPoolConfig();
    config.setMaxTotal(maxTotal);
    config.setMaxIdle(maxIdle);
    config.setMinIdle(minIdle);
    config.setBlockWhenExhausted(true);
    config.setTestOnBorrow(testOnborrow);
    config.setTestOnReturn(testOnReturn);
    pool = new JedisPool(config, host, ip, 1000 * 2);
}

Output:
     config.setTestOnReturn(testOnReturn);
-    pool = new JedisPool(config, host, ip, 1000 * 2);
+    pool = new JedisPool(config, host, port, 1000 * 2);
 }


Input:
public String getMoveLineList(MoveLineReport moveLineReport) throws AxelorException {
    this.buildQuery(moveLineReport);
    int i = 1;
    String domainQuery = this.query;
    for (Object param : params.toArray()) {
        String paramStr = "String_Node_Str";
        if (param instanceof Model) {
            paramStr = ((Model) param).getId().toString();
        } else if (param instanceof Set) {
            Set<Object> paramSet = (Set<Object>) param;
            for (Object object : paramSet) {
                if (!paramStr.isEmpty()) {
                    paramStr += "String_Node_Str";
                }
                paramStr = ((Model) object).getId().toString();
            }
        } else if (param instanceof LocalDate) {
            paramStr = "String_Node_Str" + param.toString() + "String_Node_Str";
        } else {
            paramStr = param.toString();
        }
        domainQuery = domainQuery.replace("String_Node_Str" + i, paramStr);
        i++;
    }
    log.debug("String_Node_Str", domainQuery);
    return domainQuery;
}

Output:
                 }
-                paramStr = ((Model) object).getId().toString();
+                paramStr += ((Model) object).getId().toString();
             }


Input:
public UnmarshalRecord buildSelfRecord(UnmarshalRecord unmarshalRecord, Attributes atts) {
    try {
        Descriptor xmlDescriptor = (Descriptor) xmlCompositeObjectMapping.getReferenceDescriptor();
        if (null == xmlDescriptor) {
            xmlDescriptor = findReferenceDescriptor(null, unmarshalRecord, atts, xmlCompositeObjectMapping, xmlCompositeObjectMapping.getKeepAsElementPolicy());
        }
        if (xmlDescriptor != null) {
            if (xmlDescriptor.hasInheritance()) {
                unmarshalRecord.setAttributes(atts);
                Class clazz = ((ObjectBuilder) xmlDescriptor.getObjectBuilder()).classFromRow(unmarshalRecord, unmarshalRecord.getSession());
                if (clazz == null) {
                    XPathQName leafElementType = unmarshalRecord.getLeafElementType();
                    if (leafElementType != null) {
                        Object indicator = xmlDescriptor.getInheritancePolicy().getClassIndicatorMapping().get(leafElementType);
                        if (indicator != null) {
                            clazz = (Class) indicator;
                        }
                    }
                }
                if (clazz != null) {
                    xmlDescriptor = (Descriptor) unmarshalRecord.getSession().getDescriptor(clazz);
                } else {
                    if (Modifier.isAbstract(xmlDescriptor.getJavaClass().getModifiers())) {
                        throw DescriptorException.missingClassIndicatorField(unmarshalRecord, (org.eclipse.persistence.oxm.XMLDescriptor) xmlDescriptor.getInheritancePolicy().getDescriptor());
                    }
                }
            }
            ObjectBuilder stob2 = (ObjectBuilder) xmlDescriptor.getObjectBuilder();
            org.eclipse.persistence.oxm.record.UnmarshalRecord wrapper = (org.eclipse.persistence.oxm.record.UnmarshalRecord) stob2.createRecord(unmarshalRecord.getSession());
            UnmarshalRecord childRecord = wrapper.getUnmarshalRecord();
            childRecord.setUnmarshaller(unmarshalRecord.getUnmarshaller());
            childRecord.setSelfRecord(true);
            unmarshalRecord.setChildRecord(childRecord);
            childRecord.setXMLReader(unmarshalRecord.getXMLReader());
            childRecord.startDocument();
            childRecord.initializeRecord(this.xmlCompositeObjectMapping);
            return childRecord;
        } else {
            return null;
        }
    } catch (SAXException e) {
        throw XMLMarshalException.unmarshalException(e);
    }
}

Output:
             }
-            ObjectBuilder stob2 = (ObjectBuilder) xmlDescriptor.getObjectBuilder();
-            org.eclipse.persistence.oxm.record.UnmarshalRecord wrapper = (org.eclipse.persistence.oxm.record.UnmarshalRecord) stob2.createRecord(unmarshalRecord.getSession());
-            UnmarshalRecord childRecord = wrapper.getUnmarshalRecord();
+            UnmarshalRecord childRecord = unmarshalRecord.getUnmarshaller().createUnmarshalRecord(xmlDescriptor, unmarshalRecord.getSession());
             childRecord.setUnmarshaller(unmarshalRecord.getUnmarshaller());


Input:
private void performAnnealing(ProjectEGFile file, MLDataSet trainingData) {
    InputAnneal dialog = new InputAnneal();
    if (dialog.process()) {
        final double startTemp = dialog.getStartTemp().getValue();
        final double stopTemp = dialog.getStartTemp().getValue();
        final int cycles = dialog.getCycles().getValue();
        CalculateScore score = new TrainingSetScore(trainingData);
        final Train train = new NeuralSimulatedAnnealing((BasicNetwork) file.getObject(), score, startTemp, stopTemp, cycles);
        startup(file, train, dialog.getMaxError().getValue() / 100.0);
    }
}

Output:
         CalculateScore score = new TrainingSetScore(trainingData);
-        final Train train = new NeuralSimulatedAnnealing((BasicNetwork) file.getObject(), score, startTemp, stopTemp, cycles);
+        final MLTrain train = new NeuralSimulatedAnnealing((BasicNetwork) file.getObject(), score, startTemp, stopTemp, cycles);
         startup(file, train, dialog.getMaxError().getValue() / 100.0);


Input:
public Response deleteGrant(UriInfo info, String domainId, String userId, String roleId) {
    Domain domain = null;
    User user;
    Role role;
    try {
        domain = iidMStore.readDomain(domainId);
    } catch (IDMStoreException e) {
        LOG.error("String_Node_Str", e);
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str");
        idmerror.setDetails(e.getMessage());
        return Response.status(500).entity(idmerror).build();
    }
    if (domain == null) {
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str" + domainId);
        return Response.status(404).entity(idmerror).build();
    }
    try {
        user = iidMStore.readUser(userId);
    } catch (IDMStoreException e) {
        LOG.error("String_Node_Str", e);
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str");
        idmerror.setDetails(e.getMessage());
        return Response.status(500).entity(idmerror).build();
    }
    if (user == null) {
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str" + userId);
        return Response.status(404).entity(idmerror).build();
    }
    try {
        role = iidMStore.readRole(roleId);
    } catch (IDMStoreException e) {
        LOG.error("String_Node_Str", e);
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str");
        idmerror.setDetails(e.getMessage());
        return Response.status(500).entity(idmerror).build();
    }
    if (role == null) {
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str" + roleId);
        return Response.status(404).entity(idmerror).build();
    }
    try {
        Grant existingGrant = iidMStore.readGrant(domainId, userId, roleId);
        if (existingGrant == null) {
            IDMError idmerror = new IDMError();
            idmerror.setMessage("String_Node_Str" + domainId + "String_Node_Str" + userId + "String_Node_Str" + roleId);
            return Response.status(404).entity(idmerror).build();
        }
        existingGrant = iidMStore.deleteGrant(existingGrant.getGrantid());
    } catch (IDMStoreException e) {
        LOG.error("String_Node_Str", e);
        IDMError idmerror = new IDMError();
        idmerror.setMessage("String_Node_Str");
        idmerror.setDetails(e.getMessage());
        return Response.status(500).entity(idmerror).build();
    }
    IdmLightProxy.clearClaimCache();
    return Response.status(204).build();
}

Output:
         }
-        existingGrant = iidMStore.deleteGrant(existingGrant.getGrantid());
+        iidMStore.deleteGrant(existingGrant.getGrantid());
     } catch (IDMStoreException e) {


Input:
public void testSet() {
    if (storage == null) {
        return;
    }
    assertEquals(null, storage.getItem("String_Node_Str"));
    assertEquals(0, storage.getLength());
    storage.setItem("String_Node_Str", "String_Node_Str");
    assertEquals("String_Node_Str", storage.getItem("String_Node_Str"));
    assertEquals(1, storage.getLength());
    storage.setItem("String_Node_Str", "String_Node_Str");
    assertEquals("String_Node_Str", "String_Node_Str", storage.getItem("String_Node_Str"));
    assertEquals(1, storage.getLength());
    if (!GWT.isScript()) {
        try {
            storage.setItem("String_Node_Str", "String_Node_Str");
            fail("String_Node_Str");
        } catch (AssertionError e) {
        }
    }
}

Output:
             storage.setItem("String_Node_Str", "String_Node_Str");
-            fail("String_Node_Str");
+            throw new Error("String_Node_Str");
         } catch (AssertionError e) {


Input:
public boolean performOta(BleTransaction.Ota txn) {
    if (is(PERFORMING_OTA))
        return false;
    if (!is(INITIALIZED))
        return false;
    m_txnMngr.onOta(txn);
    return true;
}

Output:
         return false;
-    m_txnMngr.onOta(txn);
+    m_txnMngr.startOta(txn);
     return true;


Input:
public Object clone() {
    final Listbox clone = (Listbox) super.clone();
    clone.init();
    clone._pgListener = null;
    clone._pgImpListener = null;
    clone.afterUnmarshal();
    if (clone._model != null) {
        if (clone._model instanceof ComponentCloneListener) {
            final ListModel model = (ListModel) ((ComponentCloneListener) clone._model).willClone(clone);
            if (model != null)
                clone._model = model;
        }
        clone._dataListener = null;
        clone.initDataListener();
        clone.getDataLoader().setLoadAll(_renderAll);
    }
    clone._groupsInfo.addAll(_groupsInfo);
    return clone;
}

Output:
     clone._pgImpListener = null;
-    clone.afterUnmarshal();
+    final int offset = clone.getDataLoader().getOffset();
+    clone.afterUnmarshal(offset);
+    final int limit = clone.getDataLoader().getLimit();
+    clone.resetDataLoader(false);
+    clone.getDataLoader().init(clone, offset, limit);
     if (clone._model != null) {