Input:
public void createControl(Composite parent) {
    Composite composite = new Composite(parent, SWT.BORDER);
    composite.setLayout(new GridLayout(1, false));
    browseViewer = new TableViewer(composite, SWT.FULL_SELECTION | SWT.MULTI | SWT.H_SCROLL);
    GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1);
    gd.widthHint = 600;
    browseViewer.getControl().setLayoutData(gd);
    ((GridData) browseViewer.getControl().getLayoutData()).heightHint = 100;
    Table table = browseViewer.getTable();
    TableColumn column = new TableColumn(table, SWT.CENTER);
    column.setText(INSTANCE_NAME);
    column.setWidth(615);
    table.setHeaderVisible(true);
    table.setLinesVisible(true);
    CellEditor[] editors = new CellEditor[1];
    editors[0] = new TextCellEditor(table);
    browseViewer.setCellEditors(editors);
    browseViewer.setContentProvider(new IStructuredContentProvider() {
        public void dispose() {
        }
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }
        public Object[] getElements(Object inputElement) {
            ArrayList<XSDElementDeclaration> values = (ArrayList<XSDElementDeclaration>) inputElement;
            return values.toArray(new XSDElementDeclaration[values.size()]);
        }
    });
    browseViewer.setLabelProvider(new ITableLabelProvider() {
        public boolean isLabelProperty(Object element, String property) {
            return false;
        }
        public void dispose() {
        }
        public void addListener(ILabelProviderListener listener) {
        }
        public void removeListener(ILabelProviderListener listener) {
        }
        public String getColumnText(Object element, int columnIndex) {
            return BROWSE_ITEMS + ((XSDElementDeclaration) element).getName();
        }
        public Image getColumnImage(Object element, int columnIndex) {
            return null;
        }
    });
    browseViewer.setCellModifier(new ICellModifier() {
        public boolean canModify(Object element, String property) {
            return true;
        }
        public void modify(Object element, String property, Object value) {
            TableItem item = (TableItem) element;
            String tValue = value.toString().trim();
            if (Pattern.compile("String_Node_Str").matcher(value.toString()).matches() || tValue.replaceAll("String_Node_Str", "String_Node_Str").length() != tValue.length()) {
                MessageDialog.openInformation(null, "String_Node_Str", "String_Node_Str");
                return;
            }
            XSDElementDeclaration elem = (XSDElementDeclaration) item.getData();
            if (!(BROWSE_ITEMS + elem.getName()).equals(tValue)) {
                for (XSDElementDeclaration theElem : declList) {
                    if (theElem == elem)
                        continue;
                    if ((BROWSE_ITEMS + theElem.getName()).equals(tValue)) {
                        MessageDialog.openInformation(null, "String_Node_Str", "String_Node_Str");
                        return;
                    }
                }
                List<Line> lines = browseItemToRoles.get(BROWSE_ITEMS + elem.getName());
                browseItemToRoles.remove(BROWSE_ITEMS + elem.getName());
                int prex = tValue.indexOf(BROWSE_ITEMS);
                if (prex != -1 && (prex + BROWSE_ITEMS.length()) <= tValue.length()) {
                    elem.setName(tValue.substring(prex + BROWSE_ITEMS.length()));
                }
                browseItemToRoles.put(tValue, lines);
                refreshRoleView(BROWSE_ITEMS + elem.getName());
                browseViewer.update(elem, null);
            }
        }
        public Object getValue(Object element, String property) {
            XSDElementDeclaration elem = (XSDElementDeclaration) element;
            return BROWSE_ITEMS + elem.getName();
        }
    });
    browseViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            applyChangeToRoles();
            IStructuredSelection selection = (IStructuredSelection) event.getSelection();
            if (selection.size() > 1) {
                List selectObjs = selection.toList();
                refreshRoleView(selectObjs);
                UpdateComplexViewButton(true);
            } else if (selection.size() == 1) {
                XSDElementDeclaration decl = (XSDElementDeclaration) selection.getFirstElement();
                refreshRoleView(BROWSE_ITEMS + decl.getName());
                UpdateComplexViewButton(true);
            }
        }
    });
    browseViewer.setInput(declList);
    browseViewer.setColumnProperties(new String[] { INSTANCE_NAME });
    browseViewer.refresh();
    if (Util.IsEnterPrise()) {
        Label infoLabel = new Label(composite, SWT.NONE);
        infoLabel.setText("String_Node_Str");
        ComplexTableViewerColumn ruleColumn = roleConfigurationColumns[0];
        ruleColumn.setColumnWidth(250);
        List<String> roles = getAllRoleNames();
        ruleColumn.setComboValues(roles.toArray(new String[] {}));
        ComplexTableViewerColumn acsColumn = roleConfigurationColumns[1];
        acsColumn.setColumnWidth(250);
        acsColumn.setComboValues(new String[] { "String_Node_Str", "String_Node_Str" });
        complexTableViewer = new ComplexTableViewer(Arrays.asList(roleConfigurationColumns), WidgetFactory.getWidgetFactory(), composite);
        complexTableViewer.setKeyColumns(new ComplexTableViewerColumn[] { roleConfigurationColumns[0] });
        complexTableViewer.create();
        complexTableViewer.getViewer().setInput(new ArrayList<Line>());
        UpdateComplexViewButton(false);
    }
    setControl(composite);
}

Output:
         Label infoLabel = new Label(composite, SWT.NONE);
-        infoLabel.setText("String_Node_Str");
+        infoLabel.setText(Messages.getString("String_Node_Str"));
         ComplexTableViewerColumn ruleColumn = roleConfigurationColumns[0];


Input:
private long checkJobQueue() {
    boolean emptyFetch = false;
    try {
        emptyFetch = Transactions.execute(transactional, new TxCallable<Boolean>() {
            public Boolean call(DatasetContext context) throws Exception {
                return checkJobConstraints();
            }
        });
        Transactions.execute(transactional, new TxCallable<Boolean>() {
            public Boolean call(DatasetContext context) throws Exception {
                return runReadyJobs(context);
            }
        });
        failureCount = 0;
    } catch (Exception e) {
        LOG.warn("String_Node_Str", e);
        failureCount++;
    }
    if (failureCount > 0) {
        return scheduleStrategy.nextRetry(failureCount, 0);
    }
    return emptyFetch ? 2000L : 0L;
}

Output:
         });
-        Transactions.execute(transactional, new TxCallable<Boolean>() {
-            public Boolean call(DatasetContext context) throws Exception {
-                return runReadyJobs(context);
-            }
-        });
+        runReadyJobs();
         failureCount = 0;


Input:
public void run() {
    saveAndCloseManagedViews();
}

Output:
 public void run() {
-    saveAndCloseManagedViews();
+    saveAndCloseManagedViews(determineManagedViews(), true);
 }


Input:
public static void initResourceMap() {
    if (resourcemapProperties == null) {
        resourcemapProperties = new Properties();
        InputStream in = HadoopConfigHolder.class.getClassLoader().getResourceAsStream(RESOURCEMAP_PROP_FILE);
        if (in != null) {
            try {
                resourcemapProperties.load(in);
                for (Map.Entry<Object, Object> entry : resourcemapProperties.entrySet()) {
                    String key = (String) entry.getKey();
                    String value = (String) entry.getValue();
                    if (RANGER_SECTION_NAME.equals(value)) {
                        rangerInternalPropertyKeys.add(key);
                    }
                }
            } catch (IOException e) {
                throw new HadoopException("String_Node_Str" + RESOURCEMAP_PROP_FILE + "String_Node_Str", e);
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException ioe) {
                    }
                }
            }
        } else {
            throw new HadoopException("String_Node_Str" + RESOURCEMAP_PROP_FILE + "String_Node_Str");
        }
    }
}

Output:
                     String key = (String) entry.getKey();
-                    String value = (String) entry.getValue();
-                    if (RANGER_SECTION_NAME.equals(value)) {
-                        rangerInternalPropertyKeys.add(key);
-                    }
+                    rangerInternalPropertyKeys.add(key);
                 }


Input:
public Node next() {
    Node p = toVisit.pop();
    for (Relationship r : p.getRelationships(Direction.INCOMING, relTypes)) {
        Node c = r.getStartNode();
        if (!observed.contains(c) && validate(c)) {
            queue(c);
        }
    }
    return p;
}

Output:
 public Node next() {
-    Node p = toVisit.pop();
-    for (Relationship r : p.getRelationships(Direction.INCOMING, relTypes)) {
-        Node c = r.getStartNode();
-        if (!observed.contains(c) && validate(c)) {
-            queue(c);
-        }
-    }
-    return p;
+    Node n = next;
+    loadNext();
+    return n;
 }


Input:
public static void handleOnRender(ForeignContent content, ExecutionContext context) {
    try {
        ReportItemDesign textItemDesign = (ReportItemDesign) content.getGenerateBy();
        IDynamicTextInstance text = new DynamicTextInstance(content);
        if (handleJS(text, textItemDesign.getOnRender(), context).didRun())
            return;
        IDynamicTextEventHandler eh = (IDynamicTextEventHandler) getInstance((TextDataHandle) textItemDesign.getHandle());
        if (eh != null)
            eh.onRender(text, context.getReportContext());
    } catch (Exception e) {
        log.log(Level.WARNING, e.getMessage(), e);
    }
}

Output:
         ReportItemDesign textItemDesign = (ReportItemDesign) content.getGenerateBy();
-        IDynamicTextInstance text = new DynamicTextInstance(content);
+        IDynamicTextInstance text = new DynamicTextInstance(content, context);
         if (handleJS(text, textItemDesign.getOnRender(), context).didRun())


Input:
private static AnalysisCategories loadFromFile() {
    EMFUtil util = new EMFUtil();
    String pathName = "String_Node_Str";
    URI uri = URI.createPlatformPluginURI(pathName, false);
    Resource catFile = null;
    try {
        catFile = util.getResourceSet().getResource(uri, true);
    } catch (RuntimeException e) {
        log.error(e.getMessage());
    }
    if (catFile == null) {
        catFile = util.getResourceSet().getResource(URI.createFileURI("String_Node_Str" + File.separator + pathName), true);
    }
    if (catFile == null) {
        log.error("String_Node_Str" + pathName + "String_Node_Str" + uri);
        return null;
    }
    EList<EObject> contents = catFile.getContents();
    if (contents == null) {
        log.error("String_Node_Str" + uri);
        return null;
    }
    CategorySwitch<AnalysisCategories> catSwitch = new CategorySwitch<AnalysisCategories>() {
        public AnalysisCategories caseAnalysisCategories(AnalysisCategories object) {
            return object;
        }
    };
    return catSwitch.doSwitch(contents.get(0));
}

Output:
 private static AnalysisCategories loadFromFile() {
-    EMFUtil util = new EMFUtil();
+    EMFUtil util = EMFUtil.getInstance();
     String pathName = "String_Node_Str";


Input:
private MetricQueryResult executeQuery(MetricQueryRequest queryRequest) throws Exception {
    if (queryRequest.getMetrics().size() == 0) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    Map<String, String> tagsSliceBy = humanToTagNames(transformTagMap(queryRequest.getTags()));
    MetricQueryRequest.TimeRange timeRange = queryRequest.getTimeRange();
    MetricDataQuery query = new MetricDataQuery(timeRange.getStart(), timeRange.getEnd(), timeRange.getResolutionInSeconds(), timeRange.getCount(), toMetrics(queryRequest.getMetrics()), tagsSliceBy, transformGroupByTags(queryRequest.getGroupBy()), timeRange.getInterpolate());
    Collection<MetricTimeSeries> queryResult = metricStore.query(query);
    long endTime = timeRange.getEnd();
    if (timeRange.getResolutionInSeconds() == Integer.MAX_VALUE && endTime == 0) {
        endTime = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());
    }
    return decorate(queryResult, timeRange.getStart(), endTime, timeRange.getResolutionInSeconds());
}

Output:
     }
-    return decorate(queryResult, timeRange.getStart(), endTime, timeRange.getResolutionInSeconds());
+    return decorate(queryResult, timeRange.getStart(), endTime, timeRange.getResolutionInSeconds().intValue());
 }


Input:
public int waitEvent(int eventMask) throws NoRoomException, IllegalActionException {
    Actor currentTask = _taskNames.get(Thread.currentThread().getName());
    if ((_actorsWithEvents.get(currentTask) != null) && ((_actorsWithEvents.get(currentTask).intValue() & eventMask) != 0)) {
        return 0;
    }
    _actorsWaitingForEvents.put(currentTask, eventMask);
    output.send(new ResourceToken(currentTask, null, TaskState.waiting));
    return 0;
}

Output:
     _actorsWaitingForEvents.put(currentTask, eventMask);
-    output.send(new ResourceToken(currentTask, null, TaskState.waiting));
+    ((CTask) currentTask).bufferOutput(new ResourceToken(currentTask, null, TaskState.waiting));
     return 0;


Input:
public void drawValues(Canvas c) {
    if (mChart.getCandleData().getYValCount() < mChart.getMaxVisibleCount() * mViewPortHandler.getScaleX()) {
        List<CandleDataSet> dataSets = mChart.getCandleData().getDataSets();
        for (int i = 0; i < dataSets.size(); i++) {
            CandleDataSet dataSet = dataSets.get(i);
            if (!dataSet.isDrawValuesEnabled())
                continue;
            applyValueTextStyle(dataSet);
            Transformer trans = mChart.getTransformer(dataSet.getAxisDependency());
            List<CandleEntry> entries = dataSet.getYVals();
            Entry entryFrom = dataSet.getEntryForXIndex(mMinX);
            Entry entryTo = dataSet.getEntryForXIndex(mMaxX);
            int minx = dataSet.getEntryPosition(entryFrom);
            int maxx = Math.min(dataSet.getEntryPosition(entryTo) + 1, entries.size());
            float[] positions = trans.generateTransformedValuesCandle(entries, mAnimator.getPhaseX(), mAnimator.getPhaseY(), minx, maxx);
            float yOffset = Utils.convertDpToPixel(5f);
            for (int j = 0; j < positions.length; j += 2) {
                float x = positions[j];
                float y = positions[j + 1];
                if (!mViewPortHandler.isInBoundsRight(x))
                    break;
                if (!mViewPortHandler.isInBoundsLeft(x) || !mViewPortHandler.isInBoundsY(y))
                    continue;
                float val = entries.get(j / 2 + minx).getHigh();
                c.drawText(dataSet.getValueFormatter().getFormattedValue(val), x, y - yOffset, mValuePaint);
            }
        }
    }
}

Output:
             Entry entryTo = dataSet.getEntryForXIndex(mMaxX);
-            int minx = dataSet.getEntryPosition(entryFrom);
+            int minx = Math.max(dataSet.getEntryPosition(entryFrom), 0);
             int maxx = Math.min(dataSet.getEntryPosition(entryTo) + 1, entries.size());


Input:
public BrokerMessage.MessageContent read(long offset) {
    if (offset >= startOffset + fileSize) {
        LOG.warn("String_Node_Str", offset);
        return null;
    }
    try {
        channel.position(offset - startOffset);
        ByteBuffer headerBuffer = ByteBuffer.allocate(MESSAGE_HEADER_LENGTH);
        int readLen = channel.read(headerBuffer);
        if (readLen != MESSAGE_HEADER_LENGTH) {
            LOG.warn("String_Node_Str");
            return null;
        }
        headerBuffer.flip();
        long crc32 = headerBuffer.getLong();
        int messageLen = headerBuffer.getInt();
        LOG.info("String_Node_Str", messageLen);
        ByteBuffer messageContentBuffer = ByteBuffer.allocate(messageLen);
        readLen = channel.read(messageContentBuffer);
        if (readLen != messageLen) {
            LOG.warn("String_Node_Str");
            return null;
        }
        if (BrokerUtils.getCRC32(messageContentBuffer.array()) != crc32) {
            LOG.warn("String_Node_Str");
            return null;
        }
        BrokerMessage.MessageContent message = BrokerMessage.MessageContent.parseFrom(messageContentBuffer.array());
        BrokerMessage.MessageContent result = BrokerMessage.MessageContent.newBuilder().mergeFrom(message).setSize(MESSAGE_HEADER_LENGTH + messageLen).build();
        return result;
    } catch (IOException ex) {
        LOG.warn("String_Node_Str", dirName, fileName, offset);
        return null;
    }
}

Output:
     if (offset >= startOffset + fileSize) {
-        LOG.warn("String_Node_Str", offset);
+        LOG.debug("String_Node_Str", offset);
         return null;


Input:
public void initialPlayer(int[] playerSID) {
    int playerNum = playerSID.length;
    allPlayers = new Player[playerNum];
    allUserInfo = new UserInfo[playerNum];
    heroChoices = new String[playerNum];
    teamResult = new int[playerNum];
    allPlayers = new Player[playerNum];
    allUserInfo = new UserInfo[playerNum];
    for (int i = 0; i < playerNum; i++) {
        allPlayers[i] = new Player();
        allPlayers[i].SID = playerSID[i];
        allUserInfo[i] = new UserInfo(i, allPlayers[i].nickName);
    }
}

Output:
 public void initialPlayer(int[] playerSID) {
-    int playerNum = playerSID.length;
+    playerNum = playerSID.length;
     allPlayers = new Player[playerNum];


Input:
public ResultSet executeQuery(String s) throws SQLException {
    logger.debug("String_Node_Str" + s);
    return getSql().executeQuery(s);
}

Output:
 public ResultSet executeQuery(String s) throws SQLException {
-    logger.debug("String_Node_Str" + s);
-    return getSql().executeQuery(s);
+    Statement sql1 = getSql();
+    logger.debug("String_Node_Str" + s + "String_Node_Str");
+    logger.debug("String_Node_Str" + (s == null ? "String_Node_Str" : "String_Node_Str"));
+    logger.debug("String_Node_Str" + (sql1 == null ? "String_Node_Str" : "String_Node_Str"));
+    return sql1.executeQuery(s);
 }


Input:
public static DatabaseMetaData getDatabaseMetaData(Connection conn, DatabaseConnection dbConn, boolean isSqlMode) {
    DatabaseMetaData dbMetaData = null;
    try {
        String dbType = dbConn.getDatabaseType();
        if ("String_Node_Str".equals(conn.getClass().getName())) {
            dbMetaData = createJtdsDatabaseMetaData(conn);
        } else if (dbType.equals(EDatabaseTypeName.IBMDB2ZOS.getXmlName())) {
            dbMetaData = createFakeDatabaseMetaData(conn);
        } else if (dbType.equals(EDatabaseTypeName.TERADATA.getXmlName()) && isSqlMode) {
            String database = dbConn.getSID();
            dbMetaData = createTeradataFakeDatabaseMetaData(conn);
            TeradataDataBaseMetadata teraDbmeta = (TeradataDataBaseMetadata) dbMetaData;
            teraDbmeta.setDatabaseName(database);
        } else if (dbType.equals(EDatabaseTypeName.SAS.getXmlName())) {
            dbMetaData = createSASFakeDatabaseMetaData(conn);
        } else if (EDatabaseTypeName.SYBASEASE.getDisplayName().equals(dbType)) {
            dbMetaData = createSybaseFakeDatabaseMetaData(conn);
        } else {
            dbMetaData = conn.getMetaData();
        }
    } catch (SQLException e) {
        log.error(e.toString());
        throw new RuntimeException(e);
    } catch (Exception e) {
        log.error(e.toString());
        throw new RuntimeException(e);
    }
    return dbMetaData;
}

Output:
             dbMetaData = createSASFakeDatabaseMetaData(conn);
-        } else if (EDatabaseTypeName.SYBASEASE.getDisplayName().equals(dbType)) {
+        } else if (EDatabaseTypeName.SYBASEASE.getDisplayName().equals(dbType) || SYBASE_DATABASE_PRODUCT_NAME.equals(dbType)) {
             dbMetaData = createSybaseFakeDatabaseMetaData(conn);


Input:
public void runOpMode() {
    dashboard = RobotDashboard.getInstance();
    telemetry = new MultipleTelemetry(telemetry, dashboard.getTelemetry());
    drive = new MecanumDrive(hardwareMap);
    drive.enablePositionEstimation();
    File logRoot = new File(LoggingUtil.getLogRoot(this), "String_Node_Str" + System.currentTimeMillis());
    logRoot.mkdirs();
    final CSVLoggingTelemetry axialLog = new CSVLoggingTelemetry(new File(logRoot, "String_Node_Str"));
    final CSVLoggingTelemetry lateralLog = new CSVLoggingTelemetry(new File(logRoot, "String_Node_Str"));
    final CSVLoggingTelemetry headingLog = new CSVLoggingTelemetry(new File(logRoot, "String_Node_Str"));
    state = State.TUNE_LATERAL;
    lastPose = new Pose2d(0, 0, 0);
    waitForStart();
    startTimestamp = TimestampedData.getCurrentTime();
    while (opModeIsActive() && state != State.DONE) {
        telemetry.addData("String_Node_Str", state);
        double elapsedTime = TimestampedData.getCurrentTime() - startTimestamp;
        double dt = elapsedTime - lastTime;
        lastTime = elapsedTime;
        Pose2d estimatedPose = drive.getEstimatedPose();
        switch(state) {
            case TUNE_AXIAL:
                {
                    if (Math.abs(estimatedPose.x()) > AXIAL_DISTANCE) {
                        drive.stop();
                        reset();
                        state = State.TUNE_HEADING;
                    } else {
                        double power = AXIAL_POWER_INCREMENT * elapsedTime;
                        double axialDelta = estimatedPose.x() - lastPose.x();
                        double axialSpeed = axialDelta / dt;
                        drive.setVelocity(new Vector2d(power, 0), 0);
                        axialLog.addData("String_Node_Str", power);
                        axialLog.addData("String_Node_Str", axialSpeed);
                        axialLog.update();
                    }
                    break;
                }
            case TUNE_LATERAL:
                {
                    if (Math.abs(estimatedPose.y()) > LATERAL_DISTANCE) {
                        drive.stop();
                        reset();
                        state = State.TUNE_AXIAL;
                    } else {
                        double power = LATERAL_POWER_INCREMENT * elapsedTime;
                        double lateralDelta = estimatedPose.y() - lastPose.y();
                        double lateralSpeed = lateralDelta / dt;
                        drive.setVelocity(new Vector2d(0, power), 0);
                        lateralLog.addData("String_Node_Str", power);
                        lateralLog.addData("String_Node_Str", lateralSpeed);
                        lateralLog.update();
                    }
                    break;
                }
            case TUNE_HEADING:
                {
                    double power = HEADING_POWER_INCREMENT * elapsedTime;
                    if (Math.abs(power) > MAX_HEADING_POWER) {
                        drive.stop();
                        reset();
                        state = State.DONE;
                    } else {
                        double headingDelta = estimatedPose.heading() - lastPose.heading();
                        if (Math.abs(headingDelta) > Math.PI / 2) {
                            headingDelta -= Math.signum(headingDelta) * 2 * Math.PI;
                        }
                        double omega = headingDelta / dt;
                        drive.setVelocity(new Vector2d(0, 0), power);
                        headingLog.addData("String_Node_Str", power);
                        headingLog.addData("String_Node_Str", omega);
                        headingLog.addData("String_Node_Str", estimatedPose.heading());
                        headingLog.update();
                    }
                    break;
                }
        }
        lastPose = estimatedPose;
        drive.update();
        telemetry.update();
    }
}

Output:
     telemetry = new MultipleTelemetry(telemetry, dashboard.getTelemetry());
-    drive = new MecanumDrive(hardwareMap);
+    drive = new MecanumDrive(hardwareMap, telemetry);
     drive.enablePositionEstimation();


Input:
protected AsyncTaskResult<KeyPair> doInBackground(Void... voids) {
    AsyncTaskResult<KeyPair> retval = null;
    for (Provider provider : Security.getProviders()) Log.d(TAG, "String_Node_Str" + provider.getName());
    try {
        for (PemToKeyPairConverter converter : converters) {
            KeyPair keyPair = converter.convert(new String(pemFile));
            if (keyPair != null) {
                retval = new AsyncTaskResult<KeyPair>(keyPair);
                break;
            }
        }
        if (retval == null)
            throw new IOException("String_Node_Str");
    } catch (IOException e) {
        Log.e(TAG, "String_Node_Str", e);
        retval = new AsyncTaskResult<KeyPair>(e);
    }
    return retval;
}

Output:
             if (keyPair != null) {
-                retval = new AsyncTaskResult<KeyPair>(keyPair);
-                break;
+                paused = false;
+                return keyPair;
             }


Input:
private void defineVarsForType(TypeElement type, AutoValueTemplateVars vars, Set<ExecutableElement> methods) {
    Types typeUtils = processingEnv.getTypeUtils();
    determineObjectMethodsToGenerate(methods, vars);
    ImmutableSet<ExecutableElement> methodsToImplement = methodsToImplement(type, methods);
    Set<TypeMirror> types = new TypeMirrorSet();
    types.addAll(returnTypesOf(methodsToImplement));
    TypeElement generatedTypeElement = processingEnv.getElementUtils().getTypeElement(Generated.class.getName());
    if (generatedTypeElement != null) {
        types.add(generatedTypeElement.asType());
    }
    TypeMirror javaUtilArrays = getTypeMirror(Arrays.class);
    if (containsArrayType(types)) {
        types.add(javaUtilArrays);
    }
    BuilderSpec builderSpec = new BuilderSpec(type, processingEnv, errorReporter);
    Optional<BuilderSpec.Builder> builder = builderSpec.getBuilder();
    ImmutableSet<ExecutableElement> toBuilderMethods;
    if (builder.isPresent()) {
        toBuilderMethods = builder.get().toBuilderMethods(typeUtils, methodsToImplement);
        types.addAll(builder.get().referencedTypes());
    } else {
        toBuilderMethods = ImmutableSet.of();
    }
    vars.toBuilderMethods = FluentIterable.from(toBuilderMethods).transform(SimpleNameFunction.INSTANCE).toList();
    Set<ExecutableElement> propertyMethods = Sets.difference(methodsToImplement, toBuilderMethods);
    types.addAll(allMethodAnnotationTypes(propertyMethods));
    String pkg = TypeSimplifier.packageNameOf(type);
    TypeSimplifier typeSimplifier = new TypeSimplifier(typeUtils, pkg, types, type.asType());
    vars.imports = typeSimplifier.typesToImport();
    vars.generated = generatedTypeElement == null ? "String_Node_Str" : typeSimplifier.simplify(generatedTypeElement.asType());
    vars.arrays = typeSimplifier.simplify(javaUtilArrays);
    ImmutableBiMap<ExecutableElement, String> methodToPropertyName = propertyNameToMethodMap(propertyMethods).inverse();
    Map<ExecutableElement, String> methodToIdentifier = Maps.newLinkedHashMap(methodToPropertyName);
    fixReservedIdentifiers(methodToIdentifier);
    List<Property> props = new ArrayList<Property>();
    for (ExecutableElement method : propertyMethods) {
        String propertyType = typeSimplifier.simplify(method.getReturnType());
        String propertyName = methodToPropertyName.get(method);
        String identifier = methodToIdentifier.get(method);
        props.add(new Property(propertyName, identifier, method, propertyType, typeSimplifier));
    }
    eclipseHack().reorderProperties(props);
    vars.props = ImmutableSet.copyOf(props);
    vars.serialVersionUID = getSerialVersionUID(type);
    vars.formalTypes = typeSimplifier.formalTypeParametersString(type);
    vars.actualTypes = TypeSimplifier.actualTypeParametersString(type);
    vars.wildcardTypes = wildcardTypeParametersString(type);
    if (builder.isPresent()) {
        builder.get().defineVars(vars, typeSimplifier, methodToPropertyName);
    }
}

Output:
     for (ExecutableElement method : propertyMethods) {
-        String propertyType = typeSimplifier.simplify(method.getReturnType());
+        TypeMirror returnType = returnTypeAsMemberOf(method, autoValueTypeMirror);
+        String propertyType = typeSimplifier.simplify(returnType);
         String propertyName = methodToPropertyName.get(method);


Input:
public InternalJobStatus getJobStatus() {
    return this.jobStatus;
}

Output:
 public InternalJobStatus getJobStatus() {
-    return this.jobStatus;
+    return this.jobStatus.get();
 }


Input:
private void runRnwScript(String rnwScript) throws REngineException, EoulsanException {
    if (EoulsanRuntime.getSettings().isRServeServerEnabled()) {
        this.rConnection.executeRnwCode(rnwScript);
    } else {
        try {
            final ProcessBuilder pb = new ProcessBuilder("String_Node_Str", "String_Node_Str", "String_Node_Str", StringUtils.bashEscaping(rnwScript));
            pb.environment().put("String_Node_Str", this.outPath.getAbsolutePath());
            ProcessUtils.logEndTime(pb.start(), pb.toString(), System.currentTimeMillis());
            if (!new File(rnwScript).delete())
                LOGGER.warning("String_Node_Str" + rnwScript);
        } catch (IOException e) {
            throw new EoulsanException("String_Node_Str" + e.getMessage());
        }
    }
}

Output:
         try {
-            final ProcessBuilder pb = new ProcessBuilder("String_Node_Str", "String_Node_Str", "String_Node_Str", StringUtils.bashEscaping(rnwScript));
+            final ProcessBuilder pb = new ProcessBuilder("String_Node_Str", "String_Node_Str", "String_Node_Str", rnwScript);
             pb.environment().put("String_Node_Str", this.outPath.getAbsolutePath());


Input:
public synchronized void processNextFrame(Frame frame, Constants.Direction direction) throws ProtocolException {
    boolean doDebugWhile = false;
    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
        Tr.debug(tc, "String_Node_Str" + myID + "String_Node_Str" + frame.getFrameType().toString() + "String_Node_Str" + direction.toString() + "String_Node_Str" + muxLink.hashCode());
    }
    if (isStreamClosed()) {
        if (direction.equals(Constants.Direction.WRITING_OUT)) {
            if (muxLink.significantlyPastCloseTime(myID)) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "String_Node_Str");
                }
                throw new ProtocolException("String_Node_Str");
            } else {
                if (frame.getFrameType() == FrameTypes.PRIORITY || frame.getFrameType() == FrameTypes.WINDOW_UPDATE || frame.getFrameType() == FrameTypes.RST_STREAM) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "String_Node_Str");
                    }
                    return;
                } else if (frame.getFrameType() == FrameTypes.HEADERS || frame.getFrameType() == FrameTypes.DATA || frame.getFrameType() == FrameTypes.PUSH_PROMISE) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "String_Node_Str");
                    }
                    throw new ProtocolException("String_Node_Str");
                }
            }
        } else if (direction.equals(Constants.Direction.READ_IN)) {
            if (frame.getFrameType() == FrameTypes.PRIORITY) {
                return;
            }
            if (muxLink.significantlyPastCloseTime(myID)) {
                throw new ProtocolException("String_Node_Str");
            }
            if (frame.getFrameType() == FrameTypes.DATA || frame.getFrameType() == FrameTypes.HEADERS) {
                throw new ProtocolException("String_Node_Str");
            } else if (frame.getFrameType() == FrameTypes.RST_STREAM) {
                return;
            }
        }
    }
    ADDITIONAL_FRAME addFrame = ADDITIONAL_FRAME.FIRST_TIME;
    Http2Exception addFrameException = null;
    currentFrame = frame;
    while (addFrame != ADDITIONAL_FRAME.NO) {
        if (doDebugWhile) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str" + myID + "String_Node_Str" + frame.getFrameType().toString() + "String_Node_Str" + direction.toString());
            }
        } else {
            doDebugWhile = true;
        }
        if (addFrame == ADDITIONAL_FRAME.RESET) {
            currentFrame = new FrameRstStream(myID, addFrameException.getErrorCode(), false);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str" + myID + "String_Node_Str" + addFrameException.getErrorString());
            }
            direction = Constants.Direction.WRITING_OUT;
        }
        if (addFrame == ADDITIONAL_FRAME.GOAWAY) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str" + muxLink.getHighestClientStreamId());
            }
            currentFrame = new FrameGoAway(0, addFrameException.getMessage().getBytes(), addFrameException.getErrorCode(), muxLink.getHighestClientStreamId(), false);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str" + addFrameException.getErrorString());
            }
            direction = Constants.Direction.WRITING_OUT;
        }
        frameType = currentFrame.getFrameType();
        if (frameType == FrameTypes.RST_STREAM && addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
            addFrame = ADDITIONAL_FRAME.RESET;
        } else if (frameType == FrameTypes.GOAWAY && addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
            addFrame = ADDITIONAL_FRAME.GOAWAY;
        }
        try {
            currentFrame.validate(muxLink.getConnectionSettings());
        } catch (Http2Exception e) {
            if (addFrame == ADDITIONAL_FRAME.FIRST_TIME || addFrame == ADDITIONAL_FRAME.RESET || addFrame == ADDITIONAL_FRAME.GOAWAY) {
                if (e.isConnectionError()) {
                    addFrame = ADDITIONAL_FRAME.GOAWAY;
                } else {
                    addFrame = ADDITIONAL_FRAME.RESET;
                }
                addFrameException = e;
            } else {
                if (direction == Constants.Direction.READ_IN) {
                    addFrame = ADDITIONAL_FRAME.RESET;
                    addFrameException = e;
                } else {
                }
                addFrame = ADDITIONAL_FRAME.NO;
            }
            continue;
        }
        if (direction == Constants.Direction.READ_IN) {
            if (muxLink.checkIfGoAwaySendingOrClosing()) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "String_Node_Str" + currentFrame.getFrameType() + "String_Node_Str" + this.myID + "String_Node_Str");
                }
                return;
            }
            if (isContinuationFrameExpected() && (frameType != FrameTypes.CONTINUATION || !this.continuationExpected)) {
                addFrame = ADDITIONAL_FRAME.GOAWAY;
                addFrameException = new ProtocolException("String_Node_Str");
                continue;
            }
            if (frameType == FrameTypes.SETTINGS || frameType == FrameTypes.GOAWAY || frameType == FrameTypes.PING) {
                switch(frameType) {
                    case SETTINGS:
                        processSETTINGSFrame();
                        break;
                    case GOAWAY:
                        processGOAWAYFrame();
                        updateStreamState(StreamState.CLOSED);
                        break;
                    case PING:
                        processPINGFrame();
                        break;
                    default:
                        break;
                }
                return;
            }
            try {
                verifyReadFrameSequence();
            } catch (Http2Exception e) {
                if (e.isConnectionError()) {
                    addFrame = ADDITIONAL_FRAME.GOAWAY;
                } else if (addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
                    addFrame = ADDITIONAL_FRAME.RESET;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                addFrameException = e;
                continue;
            }
            if (frameType == FrameTypes.PRIORITY) {
                processPriorityFrame();
                return;
            }
            if (frameType == FrameTypes.RST_STREAM) {
                processRstFrame();
                return;
            }
            try {
                if (frameType == FrameTypes.WINDOW_UPDATE) {
                    processWindowUpdateFrame();
                    if (dataWaitingForWindowUpdate != null) {
                        if (!this.isWindowLimitExceeded(dataWaitingForWindowUpdate.peek())) {
                            waitingForWindowUpdate = false;
                        }
                    } else {
                        return;
                    }
                }
            } catch (Http2Exception e) {
                if (addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
                    if (e.isConnectionError()) {
                        addFrame = ADDITIONAL_FRAME.GOAWAY;
                    } else {
                        addFrame = ADDITIONAL_FRAME.RESET;
                    }
                    addFrameException = e;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                continue;
            }
            try {
                updateStreamReadWindow();
            } catch (Http2Exception e) {
                if (addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
                    if (e.isConnectionError()) {
                        addFrame = ADDITIONAL_FRAME.GOAWAY;
                    } else {
                        addFrame = ADDITIONAL_FRAME.RESET;
                    }
                    addFrameException = e;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                continue;
            }
            try {
                readWriteTransitionState(direction);
            } catch (CompressionException e) {
                if (addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
                    addFrame = ADDITIONAL_FRAME.GOAWAY;
                    addFrameException = e;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                continue;
            } catch (Http2Exception e) {
                if (addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
                    if (e.isConnectionError()) {
                        addFrame = ADDITIONAL_FRAME.GOAWAY;
                    } else {
                        addFrame = ADDITIONAL_FRAME.RESET;
                    }
                    addFrameException = e;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                continue;
            }
        } else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str");
            }
            try {
                verifyWriteFrameSequence();
                readWriteTransitionState(direction);
            } catch (CompressionException e) {
                if ((addFrame == ADDITIONAL_FRAME.FIRST_TIME) || (addFrame == ADDITIONAL_FRAME.RESET)) {
                    Tr.info(tc, "String_Node_Str");
                    addFrame = ADDITIONAL_FRAME.GOAWAY;
                    addFrameException = e;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                continue;
            } catch (Http2Exception e) {
                if (addFrame == ADDITIONAL_FRAME.FIRST_TIME) {
                    if (e.isConnectionError()) {
                        addFrame = ADDITIONAL_FRAME.GOAWAY;
                    } else {
                        addFrame = ADDITIONAL_FRAME.RESET;
                    }
                    addFrameException = e;
                } else {
                    addFrame = ADDITIONAL_FRAME.NO;
                }
                continue;
            }
        }
        if (!waitingForWindowUpdate && dataWaitingForWindowUpdate != null && !this.isWindowLimitExceeded(this.dataWaitingForWindowUpdate.peek())) {
            addFrame = ADDITIONAL_FRAME.DATA;
            currentFrame = this.dataWaitingForWindowUpdate.remove();
            direction = Constants.Direction.WRITING_OUT;
            if (this.dataWaitingForWindowUpdate.isEmpty()) {
                this.dataWaitingForWindowUpdate = null;
            }
        } else {
            addFrame = ADDITIONAL_FRAME.NO;
        }
    }
}

Output:
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
-                    Tr.debug(tc, "String_Node_Str");
+                    Tr.debug(tc, "String_Node_Str" + myID);
                 }


Input:
public void resolveBorderConflict(CellArea cellArea, boolean isFirst) {
    IContent cellContent = cellArea.getContent();
    int columnID = cellArea.getColumnID();
    int colSpan = cellArea.getColSpan();
    IRowContent row = (IRowContent) cellContent.getParent();
    IStyle cellContentStyle = cellContent.getComputedStyle();
    IStyle cellAreaStyle = cellArea.getStyle();
    IStyle tableStyle = tableContent.getComputedStyle();
    IStyle rowStyle = row.getComputedStyle();
    IStyle columnStyle = getColumnStyle(columnID);
    IStyle preRowStyle = null;
    IStyle preColumnStyle = getColumnStyle(columnID - 1);
    IStyle leftCellContentStyle = null;
    IStyle topCellStyle = null;
    boolean rtl = tableContent.getReportContent().getDesign().getReportDesign().isDirectionRTL();
    Row lastRow = null;
    if (rows.size() > 0) {
        lastRow = (Row) rows.getCurrent();
    }
    leftCellContentStyle = getLeftCellContentStyle(lastRow, columnID);
    if (lastRow != null) {
        preRowStyle = lastRow.getContent().getComputedStyle();
        CellArea cell = lastRow.getCell(columnID);
        if (cell != null && cell.getContent() != null) {
            topCellStyle = cell.getContent().getComputedStyle();
        }
    }
    if (rows.size() == 0 && lastRow == null) {
        if (isFirst) {
            bcr.resolveTableTopBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
        } else {
            bcr.resolveTableTopBorder(tableStyle, null, columnStyle, null, cellAreaStyle);
        }
        if (columnID == startCol) {
            if (rtl) {
                bcr.resolveTableRightBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
                bcr.resolveCellLeftBorder(preColumnStyle, columnStyle, leftCellContentStyle, cellContentStyle, cellAreaStyle);
            } else
                bcr.resolveTableLeftBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
        } else {
            if (!rtl || columnID + colSpan - 1 != endCol)
                bcr.resolveCellLeftBorder(preColumnStyle, columnStyle, leftCellContentStyle, cellContentStyle, cellAreaStyle);
        }
        if (columnID + colSpan - 1 == endCol) {
            if (rtl)
                bcr.resolveTableLeftBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
            else
                bcr.resolveTableRightBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
        }
    } else {
        if (isFirst) {
            bcr.resolveCellTopBorder(preRowStyle, rowStyle, topCellStyle, cellContentStyle, cellAreaStyle);
        } else {
            bcr.resolveCellTopBorder(preRowStyle, null, topCellStyle, null, cellAreaStyle);
        }
        if (columnID == startCol) {
            if (rtl) {
                bcr.resolveTableRightBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
                bcr.resolveCellLeftBorder(preColumnStyle, columnStyle, leftCellContentStyle, cellContentStyle, cellAreaStyle);
            } else
                bcr.resolveTableLeftBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
        } else {
            if (!rtl || columnID + colSpan - 1 != endCol)
                bcr.resolveCellLeftBorder(preColumnStyle, columnStyle, leftCellContentStyle, cellContentStyle, cellAreaStyle);
        }
        if (columnID + colSpan - 1 == endCol) {
            if (rtl)
                bcr.resolveTableLeftBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
            else
                bcr.resolveTableRightBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
        }
    }
    lastCellContent = (ICellContent) cellContent;
}

Output:
         if (columnID == startCol) {
-            if (rtl) {
-                bcr.resolveTableRightBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
-                bcr.resolveCellLeftBorder(preColumnStyle, columnStyle, leftCellContentStyle, cellContentStyle, cellAreaStyle);
-            } else
-                bcr.resolveTableLeftBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
+            bcr.resolveTableLeftBorder(tableStyle, rowStyle, columnStyle, cellContentStyle, cellAreaStyle);
         } else {


Input:
public static void reconfigureParentKeymap() {
    final VirtualFile vimKeymapFile = getVimKeymapFile();
    if (vimKeymapFile == null) {
        Notifications.Bus.notify(new Notification("String_Node_Str", "String_Node_Str", "String_Node_Str", NotificationType.ERROR));
        return;
    }
    try {
        final String path = vimKeymapFile.getPath();
        final Document document = StorageUtil.loadDocument(new FileInputStream(path));
        if (document == null) {
            LOG.debug("String_Node_Str");
            Notifications.Bus.notify(new Notification("String_Node_Str", "String_Node_Str", "String_Node_Str", NotificationType.ERROR));
            return;
        }
        configureVimParentKeymap(path, document);
    } catch (Exception e) {
        LOG.debug("String_Node_Str" + e);
        Notifications.Bus.notify(new Notification("String_Node_Str", "String_Node_Str", "String_Node_Str" + e, NotificationType.ERROR));
    }
}

Output:
     } catch (Exception e) {
-        LOG.debug("String_Node_Str" + e);
+        LOG.error("String_Node_Str" + e);
         Notifications.Bus.notify(new Notification("String_Node_Str", "String_Node_Str", "String_Node_Str" + e, NotificationType.ERROR));


Input:
public static void createReportGenia(String ateOutputFolder, String gsFile, String outFile, boolean ignoreSymbols, boolean ignoreDigits, boolean lowercase, int minChar, int maxChar, int minTokens, int maxTokens, int... ranks) throws IOException {
    PrintWriter p = new PrintWriter(outFile);
    List<String> gs = GSLoader.loadGenia(gsFile, true, true);
    Map<String, double[]> scores = new HashMap<>();
    for (File f : new File(ateOutputFolder).listFiles()) {
        String name = f.getName();
        if (name.charAt(0) == '.')
            continue;
        System.out.println(f);
        List<String> terms = ATEResultLoader.load(f.toString());
        double[] s = computePrecisionAtRank(gs, terms, ignoreSymbols, ignoreDigits, lowercase, minChar, maxChar, minTokens, maxTokens, ranks);
        scores.put(name, s);
    }
    StringBuilder sb = new StringBuilder();
    for (int i : ranks) {
        sb.append("String_Node_Str").append(i);
    }
    sb.append("String_Node_Str");
    for (Map.Entry<String, double[]> en : scores.entrySet()) {
        sb.append(en.getKey()).append("String_Node_Str");
        double[] s = en.getValue();
        for (int i = 0; i < ranks.length; i++) {
            sb.append(s[i]).append("String_Node_Str");
        }
        sb.append("String_Node_Str");
    }
    p.println(sb.toString());
    p.close();
}

Output:
     PrintWriter p = new PrintWriter(outFile);
-    List<String> gs = GSLoader.loadGenia(gsFile, true, true);
+    List<String> gs = GSLoader.loadGenia(gsFile);
     Map<String, double[]> scores = new HashMap<>();


Input:
public HostVO getSecondaryStorageHost(long zoneId) {
    List<HostVO> hosts = _hostDao.listSecondaryStorageHosts(zoneId);
    if (hosts == null || hosts.size() == 0) {
        return null;
    }
    int size = hosts.size();
    Random rn = new Random();
    int index = rn.nextInt(size);
    return hosts.get(index);
}

Output:
     if (hosts == null || hosts.size() == 0) {
-        return null;
+        hosts = _hostDao.listLocalSecondaryStorageHosts(zoneId);
+        if (hosts.isEmpty()) {
+            return null;
+        }
     }


Input:
public void testGetDocumentWithLargeJSON() {
    Map<String, Object> props = new HashMap<String, Object>();
    props.put("String_Node_Str", "String_Node_Str");
    char[] chars = new char[2500000];
    Arrays.fill(chars, 'a');
    props.put("String_Node_Str", new String(chars));
    Document doc = createDocumentWithProperties(database, props);
    assertNotNull(doc);
    Document docFetched = database.getDocument(doc.getId());
    Map<String, Object> fetchedProps = docFetched.getCurrentRevision().getProperties();
    assertEquals(fetchedProps.get("String_Node_Str"), new String(chars));
}

Output:
     props.put("String_Node_Str", "String_Node_Str");
-    char[] chars = new char[2500000];
+    char[] chars = new char[3 * 1024 * 10243];
     Arrays.fill(chars, 'a');


Input:
public String value(String shortArg, String longArg, String defaultValue) {
    Collection<String> values = valueList(shortArg, longArg, defaultValue);
    if (values != null) {
        return values.iterator().next();
    }
    return null;
}

Output:
     Collection<String> values = valueList(shortArg, longArg, defaultValue);
-    if (values != null) {
-        return values.iterator().next();
+    if (values.isEmpty()) {
+        return null;
     }


Input:
private static Object generateDummyArg(Parameter param, FreshValueGenerator generator) throws ParameterNotInstantiableException {
    if (param.isAnnotationPresent(Nullable.class)) {
        return null;
    }
    Object arg = generator.generate(param.getType());
    if (arg == null) {
        throw new ParameterNotInstantiableException(param);
    }
    return arg;
}

Output:
     }
-    Object arg = generator.generate(param.getType());
+    Object arg = generator.generateFresh(param.getType());
     if (arg == null) {


Input:
public int type() {
    return Tokens.SEMICOLON;
}

Output:
 public int type() {
-    return Tokens.SEMICOLON;
+    return Symbols.SEMICOLON;
 }


Input:
public void setByte(Property property, byte value) {
    convertValueAndSet(property, new Byte(value));
}

Output:
 public void setByte(Property property, byte value) {
-    convertValueAndSet(property, new Byte(value));
+    convertValueAndSet(property, value);
 }


Input:
protected Object decode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
    if (msg instanceof Position) {
        Position position = (Position) msg;
        if (geocoder != null) {
            position.setAddress(geocoder.getAddress(position.getLatitude(), position.getLongitude()));
        }
    }
    return msg;
}

Output:
 protected Object decode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
-    if (msg instanceof Position) {
-        Position position = (Position) msg;
-        if (geocoder != null) {
+    if (geocoder != null) {
+        if (msg instanceof Position) {
+            Position position = (Position) msg;
             position.setAddress(geocoder.getAddress(position.getLatitude(), position.getLongitude()));


Input:
public boolean generateSchema(String persistenceUnitName, Map properties) {
    String puName = (persistenceUnitName == null) ? "String_Node_Str" : persistenceUnitName;
    Map nonNullProperties = (properties == null) ? new HashMap() : properties;
    if (checkForProviderProperty(nonNullProperties)) {
        JPAInitializer initializer = getInitializer(puName, nonNullProperties);
        SEPersistenceUnitInfo puInfo = initializer.findPersistenceUnitInfo(puName, nonNullProperties);
        if (puInfo != null) {
            generateSchema(puInfo, nonNullProperties);
            return true;
        }
    }
    return false;
}

Output:
         SEPersistenceUnitInfo puInfo = initializer.findPersistenceUnitInfo(puName, nonNullProperties);
-        if (puInfo != null) {
-            generateSchema(puInfo, nonNullProperties);
+        if (puInfo != null && checkForProviderProperty(properties)) {
+            createEntityManagerFactoryImpl(puInfo, properties, false).close();
             return true;


Input:
protected Expression generateSelector(ParameterExpression parameter, List<Integer> fields, JavaRowFormat targetFormat) {
    switch(fields.size()) {
        case 0:
            targetFormat = JavaRowFormat.EMPTY_LIST;
            break;
        case 1:
            targetFormat = JavaRowFormat.SCALAR;
            break;
    }
    final PhysType targetPhysType = project(fields, targetFormat);
    switch(format) {
        case SCALAR:
            return Expressions.call(BuiltinMethod.IDENTITY_SELECTOR.method);
        default:
            return Expressions.lambda(Function1.class, targetPhysType.record(fieldReferences(parameter, fields)), parameter);
    }
}

Output:
         case 0:
-            targetFormat = JavaRowFormat.EMPTY_LIST;
+            targetFormat = JavaRowFormat.LIST;
             break;


Input:
String processRequest(final RestfulMock mock, final Request req, final Response res) {
    RestfulResponse outcome;
    switch(mock.getMockType()) {
        case RULE:
            outcome = ruleEngine.process(req, mock.getRules());
            break;
        case PROXY:
            outcome = proxyService.waitForResponse(mock);
            break;
        case SEQ:
        default:
            outcome = mockOrderingCounterService.getNextInSequence(mock);
            break;
    }
    if (outcome == null) {
        outcome = getDefault(mock);
    }
    res.status(outcome.getHttpStatusCode());
    res.type(outcome.getResponseContentType());
    for (Map.Entry<String, String> e : outcome.getHeaders().entrySet()) {
        res.header(e.getKey(), e.getValue());
    }
    final String response = inboundParamMatchService.enrichWithInboundParamMatches(req, outcome.getResponseBody());
    return StringUtils.defaultIfBlank(response, "String_Node_Str");
}

Output:
         case PROXY:
-            outcome = proxyService.waitForResponse(mock);
+            outcome = proxyService.waitForResponse(req.pathInfo(), mock);
             break;


Input:
private static Expression parseOneElement(Lexer lexer) {
    TokenType tokenType = lexer.getTokenType();
    if (tokenType == null) {
        throw new ParserException(UNEXPECTED_END, lexer.getPrevEnd());
    }
    switch(tokenType) {
        case NUMBER:
            String text = lexer.getTokenText();
            ExNumber res = new ExNumber(Double.parseDouble(text.replace(',', '.')));
            lexer.advance();
            return res;
        case SYMBOL:
            if (lexer.getTokenChar() == '(') {
                lexer.advance();
                Expression expr = parseExpression(lexer);
                if (!lexer.isSymbol(')'))
                    throw new ParserException(CLOSED_BRACKET_NOT_FOUND, lexer.getPrevEnd());
                lexer.advance();
                return expr;
            }
            throw new ParserException(UNKNOWN_SYMBOL, lexer);
        case IDENTIFIER:
            {
                String name = lexer.getTokenText();
                lexer.advance();
                if (!lexer.isSymbol('('))
                    return new ExVariable(name);
                lexer.advance();
                if (lexer.isSymbol(')')) {
                    lexer.advance();
                    return new ExFunction(name);
                }
                Expression argument = parseExpression(lexer);
                Expression[] arguments;
                if (lexer.isSymbol(',')) {
                    List<Expression> list = new ArrayList<Expression>();
                    list.add(argument);
                    do {
                        lexer.advance();
                        list.add(parseExpression(lexer));
                    } while (lexer.isSymbol(','));
                    arguments = list.toArray(new Expression[list.size()]);
                } else if (lexer.isSymbol(')')) {
                    lexer.advance();
                    arguments = new Expression[] { argument };
                } else {
                    throw new ParserException(CLOSED_BRACKET_NOT_FOUND, lexer);
                }
                return new ExFunction(name, arguments);
            }
        default:
            throw new RuntimeException();
    }
}

Output:
                     arguments = list.toArray(new Expression[list.size()]);
-                } else if (lexer.isSymbol(')')) {
-                    lexer.advance();
+                } else {
                     arguments = new Expression[] { argument };


Input:
public void setInputInfo(List<String> inputInfo) {
    this.inputInfo = new ArrayList<String>(inputInfo);
}

Output:
 public void setInputInfo(List<String> inputInfo) {
-    this.inputInfo = new ArrayList<String>(inputInfo);
+    this.inputInfo = inputInfo;
 }


Input:
private void placeComponents() {
    FillLayout flMain = new FillLayout();
    flMain.marginHeight = 0;
    flMain.marginWidth = 0;
    GridLayout glContent = new GridLayout();
    glContent.verticalSpacing = 0;
    glContent.horizontalSpacing = 2;
    glContent.marginHeight = 0;
    glContent.marginWidth = 0;
    glContent.numColumns = 2;
    this.setLayout(flMain);
    cmpContent = new Composite(this, SWT.NONE);
    cmpContent.setLayout(glContent);
    cnvSelection = new FontCanvas(cmpContent, SWT.BORDER, fdCurrent, cdCurrent, false, true, false);
    GridData gdCNVSelection = new GridData(GridData.FILL_HORIZONTAL);
    gdCNVSelection.heightHint = iSize;
    cnvSelection.setLayoutData(gdCNVSelection);
    cnvSelection.setToolTipText(TOOLTIP);
    cnvSelection.addMouseListener(new MouseAdapter() {
        public void mouseUp(MouseEvent e) {
            openFontDialog();
        }
    });
    btnFont = new Button(cmpContent, SWT.NONE);
    GridData gdBEllipsis = new GridData();
    gdBEllipsis.widthHint = 20;
    gdBEllipsis.heightHint = 20;
    btnFont.setLayoutData(gdBEllipsis);
    btnFont.setImage(UIHelper.getImage("String_Node_Str"));
    btnFont.setToolTipText(TOOLTIP);
    btnFont.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            openFontDialog();
        }
    });
}

Output:
     btnFont.setLayoutData(gdBEllipsis);
-    btnFont.setImage(UIHelper.getImage("String_Node_Str"));
+    btnFont.setText("String_Node_Str");
+    btnFont.setFont(new Font(Display.getCurrent(), "String_Node_Str", 14, SWT.BOLD));
     btnFont.setToolTipText(TOOLTIP);


Input:
private void loadMap() {
    if (pluginParameters.isEmpty()) {
        deactivatedPlugins = new ArrayList<>();
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_SIP_TO_AIP_CLASS, new PluginParameter(RodaConstants.PLUGIN_PARAMS_SIP_TO_AIP_CLASS, "String_Node_Str", PluginParameterType.PLUGIN_SIP_TO_AIP, "String_Node_Str", true, false, "String_Node_Str"));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_PARENT_ID, new PluginParameter(RodaConstants.PLUGIN_PARAMS_PARENT_ID, "String_Node_Str", PluginParameterType.AIP_ID, "String_Node_Str", false, false, "String_Node_Str"));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_FORCE_PARENT_ID, new PluginParameter(RodaConstants.PLUGIN_PARAMS_FORCE_PARENT_ID, "String_Node_Str", PluginParameterType.BOOLEAN, "String_Node_Str", false, false, "String_Node_Str"));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_VIRUS_CHECK, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_VIRUS_CHECK, AntivirusPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, AntivirusPlugin.getStaticDescription()));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_DESCRIPTIVE_METADATA_VALIDATION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_DESCRIPTIVE_METADATA_VALIDATION, DescriptiveMetadataValidationPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, true, DescriptiveMetadataValidationPlugin.getStaticDescription()));
        PluginManager pluginManager = RodaCoreFactory.getPluginManager();
        Plugin<?> plugin = pluginManager.getPlugin(RodaConstants.PLUGIN_CLASS_VERAPDF);
        if (plugin != null) {
            pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_VERAPDF_CHECK, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_VERAPDF_CHECK, plugin.getName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, plugin.getDescription()));
        } else {
            deactivatedPlugins.add(RodaConstants.PLUGIN_CLASS_VERAPDF);
        }
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_CREATE_PREMIS_SKELETON, new PluginParameter(RodaConstants.PLUGIN_PARAMS_CREATE_PREMIS_SKELETON, PremisSkeletonPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, true, PremisSkeletonPlugin.getStaticDescription()));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_PRODUCER_AUTHORIZATION_CHECK, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_PRODUCER_AUTHORIZATION_CHECK, VerifyProducerAuthorizationPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, true, VerifyProducerAuthorizationPlugin.getStaticDescription()));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_FILE_FORMAT_IDENTIFICATION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_FILE_FORMAT_IDENTIFICATION, SiegfriedPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, SiegfriedPlugin.getStaticDescription()));
        plugin = pluginManager.getPlugin(RodaConstants.PLUGIN_CLASS_TIKA_FULLTEXT);
        if (plugin != null) {
            pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_FEATURE_EXTRACTION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_FEATURE_EXTRACTION, "String_Node_Str", PluginParameterType.BOOLEAN, "String_Node_Str", true, false, "String_Node_Str"));
            pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_FULL_TEXT_EXTRACTION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_FULL_TEXT_EXTRACTION, "String_Node_Str", PluginParameterType.BOOLEAN, "String_Node_Str", true, false, "String_Node_Str"));
        } else {
            deactivatedPlugins.add(RodaConstants.PLUGIN_CLASS_TIKA_FULLTEXT);
        }
        plugin = pluginManager.getPlugin(RodaConstants.PLUGIN_CLASS_DIGITAL_SIGNATURE);
        if (plugin != null) {
            pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_DIGITAL_SIGNATURE_VALIDATION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_DIGITAL_SIGNATURE_VALIDATION, plugin.getName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, plugin.getDescription()));
        } else {
            deactivatedPlugins.add(RodaConstants.PLUGIN_CLASS_DIGITAL_SIGNATURE);
        }
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_AUTO_ACCEPT, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_AUTO_ACCEPT, AutoAcceptSIPPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, AutoAcceptSIPPlugin.getStaticDescription()));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_REPLICATION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_REPLICATION, ReplicationPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, ReplicationPlugin.getStaticDescription()));
        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_EMAIL_NOTIFICATION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_EMAIL_NOTIFICATION, "String_Node_Str", PluginParameterType.STRING, "String_Node_Str", false, false, "String_Node_Str"));
    }
}

Output:
         pluginParameters.put(RodaConstants.PLUGIN_PARAMS_CREATE_PREMIS_SKELETON, new PluginParameter(RodaConstants.PLUGIN_PARAMS_CREATE_PREMIS_SKELETON, PremisSkeletonPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, true, PremisSkeletonPlugin.getStaticDescription()));
-        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_PRODUCER_AUTHORIZATION_CHECK, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_PRODUCER_AUTHORIZATION_CHECK, VerifyProducerAuthorizationPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, true, VerifyProducerAuthorizationPlugin.getStaticDescription()));
+        pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_PRODUCER_AUTHORIZATION_CHECK, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_PRODUCER_AUTHORIZATION_CHECK, VerifyUserAuthorizationPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, true, VerifyUserAuthorizationPlugin.getStaticDescription()));
         pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DO_FILE_FORMAT_IDENTIFICATION, new PluginParameter(RodaConstants.PLUGIN_PARAMS_DO_FILE_FORMAT_IDENTIFICATION, SiegfriedPlugin.getStaticName(), PluginParameterType.BOOLEAN, "String_Node_Str", true, false, SiegfriedPlugin.getStaticDescription()));


Input:
public List<CourseData> getCourseListForStudent(String googleId) {
    List<Student> studentList = getStudentCourseList(googleId);
    ArrayList<CourseData> courseList = new ArrayList<CourseData>();
    for (Student s : studentList) {
        CourseData c = new CourseData();
        c.id = s.getCourseID();
        c.name = CoursesStorage.inst().getCourse(c.id).getName();
        courseList.add(c);
    }
    return courseList;
}

Output:
 public List<CourseData> getCourseListForStudent(String googleId) {
-    List<Student> studentList = getStudentCourseList(googleId);
+    List<Student> studentList = getStudentListForGoogleId(googleId);
     ArrayList<CourseData> courseList = new ArrayList<CourseData>();


Input:
private Map getColumnBindings(IBaseQueryDefinition defn) {
    Map result = defn.getResultSetExpressions();
    result.putAll(populateGroupColumnBindings(defn.getGroups().iterator()));
    result.putAll(populateSubQueryColumnBindings(defn.getSubqueries().iterator()));
    return result;
}

Output:
 private Map getColumnBindings(IBaseQueryDefinition defn) {
-    Map result = defn.getResultSetExpressions();
+    Map result = new HashMap();
+    Iterator temp = defn.getResultSetExpressions().keySet().iterator();
+    while (temp.hasNext()) {
+        Object key = temp.next();
+        result.put(key, defn.getResultSetExpressions().get(key));
+    }
     result.putAll(populateGroupColumnBindings(defn.getGroups().iterator()));


Input:
public String processRefToExternalDefinition(String $ref, RefFormat refFormat) {
    String renamedRef = cache.getRenamedRef($ref);
    if (renamedRef != null) {
        return renamedRef;
    }
    final Model model = cache.loadRef($ref, refFormat, Model.class);
    if (model == null) {
        LOGGER.warn("String_Node_Str" + $ref + "String_Node_Str" + "String_Node_Str");
        return $ref;
    }
    String newRef;
    Map<String, Model> definitions = swagger.getDefinitions();
    if (definitions == null) {
        definitions = new LinkedHashMap<>();
    }
    final String possiblyConflictingDefinitionName = computeDefinitionName($ref, definitions.keySet());
    Model existingModel = definitions.get(possiblyConflictingDefinitionName);
    if (existingModel != null) {
        LOGGER.debug("String_Node_Str" + existingModel + "String_Node_Str");
        if (existingModel instanceof RefModel) {
            existingModel = null;
        }
    }
    newRef = possiblyConflictingDefinitionName;
    cache.putRenamedRef($ref, newRef);
    if (existingModel == null) {
        swagger.addDefinition(newRef, model);
        cache.addReferencedKey(newRef);
        String file = $ref.split("String_Node_Str")[0];
        if (model instanceof RefModel) {
            RefModel refModel = (RefModel) model;
            if (isAnExternalRefFormat(refModel.getRefFormat())) {
                refModel.set$ref(processRefToExternalDefinition(refModel.get$ref(), refModel.getRefFormat()));
            } else {
                processRefToExternalDefinition(file + refModel.get$ref(), RefFormat.RELATIVE);
            }
        }
        if (model instanceof ComposedModel) {
            ComposedModel composedModel = (ComposedModel) model;
            List<Model> listOfAllOF = composedModel.getAllOf();
            for (Model allOfModel : listOfAllOF) {
                if (allOfModel instanceof RefModel) {
                    RefModel refModel = (RefModel) allOfModel;
                    if (isAnExternalRefFormat(refModel.getRefFormat())) {
                        String joinedRef = join(file, refModel.get$ref());
                        refModel.set$ref(processRefToExternalDefinition(joinedRef, refModel.getRefFormat()));
                    } else {
                        processRefToExternalDefinition(file + refModel.get$ref(), RefFormat.RELATIVE);
                    }
                } else if (allOfModel instanceof ModelImpl) {
                    processProperties(allOfModel.getProperties(), file);
                }
            }
        }
        processProperties(model.getProperties(), file);
        if (model instanceof ModelImpl) {
            ModelImpl modelImpl = (ModelImpl) model;
            Property additionalProperties = modelImpl.getAdditionalProperties();
            if (additionalProperties != null) {
                if (additionalProperties instanceof RefProperty) {
                    processRefProperty(((RefProperty) additionalProperties), file);
                } else if (additionalProperties instanceof ArrayProperty) {
                    ArrayProperty arrayProp = (ArrayProperty) additionalProperties;
                    if (arrayProp.getItems() instanceof RefProperty) {
                        processRefProperty((RefProperty) arrayProp.getItems(), file);
                    }
                } else if (additionalProperties instanceof MapProperty) {
                    MapProperty mapProp = (MapProperty) additionalProperties;
                    if (mapProp.getAdditionalProperties() instanceof RefProperty) {
                        processRefProperty((RefProperty) mapProp.getAdditionalProperties(), file);
                    } else if (mapProp.getAdditionalProperties() instanceof ArrayProperty && ((ArrayProperty) mapProp.getAdditionalProperties()).getItems() instanceof RefProperty) {
                        processRefProperty((RefProperty) ((ArrayProperty) mapProp.getAdditionalProperties()).getItems(), file);
                    }
                }
            }
        }
        if (model instanceof ArrayModel && ((ArrayModel) model).getItems() instanceof RefProperty) {
            processRefProperty((RefProperty) ((ArrayModel) model).getItems(), file);
        }
    }
    return newRef;
}

Output:
     }
-    final String possiblyConflictingDefinitionName = computeDefinitionName($ref, definitions.keySet());
+    final String possiblyConflictingDefinitionName = computeDefinitionName($ref);
+    String tryName = null;
     Model existingModel = definitions.get(possiblyConflictingDefinitionName);


Input:
public JSObjectMetaData getReturn() {
    JSObjectMetaData meta = JSSyntaxContext.getEnginJSObject(method.getReturnType());
    if (meta == null)
        try {
            return JSSyntaxContext.getJavaClassMeta(method.getReturnType());
        } catch (ClassNotFoundException e) {
            return null;
        }
    return meta;
}

Output:
     JSObjectMetaData meta = JSSyntaxContext.getEnginJSObject(method.getReturnType());
-    if (meta == null)
+    if (meta == null) {
         try {


Input:
public void execute(InterpretContext ctx) throws InterpretException {
    Object[] arguments;
    if (argumentList == null) {
        arguments = ArrayUtils.EMPTY_OBJECT_ARRAY;
    } else {
        arguments = argumentList.execute(ctx);
    }
    JetTemplateMacro macro = last;
    if (macro == null) {
        Class<?>[] argumentTypes = ParameterUtils.getParameterTypes(arguments);
        macro = ctx.getTemplate().resolveMacro(name, argumentTypes);
        if (macro == null) {
            throw new InterpretException(Errors.MACRO_NOT_FOUND, name).set(position);
        }
        this.last = macro;
    }
    ctx.doMacroCall(macro, arguments);
}

Output:
         Class<?>[] argumentTypes = ParameterUtils.getParameterTypes(arguments);
-        macro = ctx.getTemplate().resolveMacro(name, argumentTypes);
+        macro = ctx.getTemplate().resolveMacro(name, argumentTypes, true);
         if (macro == null) {


Input:
private void copyFileToFolder(InputStream inputStream, String fileName, IFolder folder) throws CoreException, IOException {
    if (inputStream == null) {
        return;
    }
    IFile element = folder.getFile(fileName);
    if (!element.exists()) {
        element.create(inputStream, false, null);
        ModelElement modelElement = ModelElementFileFactory.getModelElement(element);
        if (modelElement != null) {
            AElementPersistance writer = ElementWriterFactory.getInstance().create(element.getFileExtension());
            if (writer != null) {
                writer.create(modelElement, folder);
                element.delete(true, null);
            }
        }
    }
}

Output:
             if (writer != null) {
-                writer.create(modelElement, folder);
+                writer.create(modelElement, folder, isImportItem);
                 element.delete(true, null);


Input:
public static boolean deleteServiceFunctionForwarderStateExecutor(String sffName) {
    printTraceStart(LOG);
    boolean ret = false;
    Object[] servicePathObj = { sffName };
    Class[] servicePathClass = { String.class };
    SfcProviderServiceForwarderAPI sfcProviderServiceForwarderAPI = SfcProviderServiceForwarderAPI.getDeleteServiceFunctionForwarderState(servicePathObj, servicePathClass);
    Future future = odlSfc.executor.submit(sfcProviderServiceForwarderAPI);
    try {
        ret = (boolean) future.get();
        LOG.info("String_Node_Str", future.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    printTraceStop(LOG);
    return ret;
}

Output:
         ret = (boolean) future.get();
-        LOG.info("String_Node_Str", future.get());
+        LOG.debug("String_Node_Str", future.get());
     } catch (InterruptedException e) {


Input:
public List<String> getNeedInstallModuleForBundle(String bundleName) {
    List<ModuleNeeded> allModulesNeededExtensionsForPlugin = ModulesNeededProvider.getAllModulesNeededExtensionsForPlugin();
    List<ModuleNeeded> requiredModulesForBundle = ModulesNeededProvider.filterRequiredModulesForBundle(bundleName, allModulesNeededExtensionsForPlugin);
    List<String> requiredJars = new ArrayList<String>(requiredModulesForBundle.size());
    for (ModuleNeeded module : requiredModulesForBundle) {
        String moduleName = module.getModuleName();
        if (!new File(getLibrariesPath(ECodeLanguage.JAVA), moduleName).exists()) {
            requiredJars.add(moduleName);
        }
    }
    return requiredJars;
}

Output:
     List<String> requiredJars = new ArrayList<String>(requiredModulesForBundle.size());
-    for (ModuleNeeded module : requiredModulesForBundle) {
-        String moduleName = module.getModuleName();
-        if (!new File(getLibrariesPath(ECodeLanguage.JAVA), moduleName).exists()) {
-            requiredJars.add(moduleName);
+    ILibraryManagerService service;
+    if (GlobalServiceRegister.getDefault().isServiceRegistered(ILibraryManagerService.class)) {
+        service = (ILibraryManagerService) GlobalServiceRegister.getDefault().getService(ILibraryManagerService.class);
+        for (ModuleNeeded module : requiredModulesForBundle) {
+            String moduleName = module.getModuleName();
+            if (!service.contains(moduleName)) {
+                requiredJars.add(moduleName);
+            }
         }


Input:
private NodeRef resolveParent(NodeRef context, String[] pathValues, boolean create) {
    NodeRef result = null;
    if (ArrayUtils.isEmpty(pathValues) == true) {
        throw new AlfrescoRuntimeException("String_Node_Str");
    } else if (pathValues.length == 1) {
        result = context;
    } else {
        pathValues = (String[]) ArrayUtils.remove(pathValues, pathValues.length - 1);
        result = resolvePath(context, pathValues, create);
    }
    return result;
}

Output:
     NodeRef result = null;
-    if (ArrayUtils.isEmpty(pathValues) == true) {
+    if (ArrayUtils.isEmpty(pathValues)) {
         throw new AlfrescoRuntimeException("String_Node_Str");


Input:
public void mouseDragged(MouseEvent evt) {
    if ((_target != null) && ((evt.getModifiers() & MouseEvent.BUTTON3_MASK) != 0)) {
        setScale(evt.getX(), evt.getY());
    }
}

Output:
 public void mouseDragged(MouseEvent evt) {
-    if ((_target != null) && ((evt.getModifiers() & MouseEvent.BUTTON3_MASK) != 0)) {
+    if ((_target != null) && ((evt.getModifiers() & InputEvent.BUTTON3_MASK) != 0)) {
         setScale(evt.getX(), evt.getY());


Input:
public void undeployApplication(String applicationId) throws CommandException {
    DefaultHttpClient httpClient = new DefaultHttpClient();
    try {
        HttpResponse response = restClient.doPost(httpClient, restClient.getBaseURL() + ENDPOINT_UNDEPLOY_APPLICATION.replace("String_Node_Str", applicationId), "String_Node_Str");
        String responseCode = "String_Node_Str" + response.getStatusLine().getStatusCode();
        GsonBuilder gsonBuilder = new GsonBuilder();
        Gson gson = gsonBuilder.create();
        if (Integer.parseInt(responseCode) < 300 && Integer.parseInt(responseCode) >= 200) {
            System.out.println("String_Node_Str" + applicationId);
            return;
        } else {
            String resultString = CliUtils.getHttpResponseString(response);
            ExceptionMapper exception = gson.fromJson(resultString, ExceptionMapper.class);
            System.out.println(exception);
        }
    } catch (Exception e) {
        String message = "String_Node_Str";
        printError(message, e);
    } finally {
        httpClient.getConnectionManager().shutdown();
    }
}

Output:
     } catch (Exception e) {
-        String message = "String_Node_Str";
+        String message = "String_Node_Str" + applicationId;
         printError(message, e);


Input:
private void validateAndUpdateParameters(List<Parameter> previousParameters, List<Parameter> nextParameters) throws ValidationErrorException {
    Map<String, String> previousParameterMap = Maps.newHashMap();
    for (Parameter previousParameter : previousParameters) {
        previousParameterMap.put(previousParameter.getParameterKey(), previousParameter.getParameterValue());
    }
    if (nextParameters != null) {
        for (Parameter nextParameter : nextParameters) {
            if (nextParameter.getUsePreviousValue() == Boolean.TRUE) {
                if (Strings.isNullOrEmpty(nextParameter.getParameterValue())) {
                    throw new ValidationErrorException("String_Node_Str" + nextParameter.getParameterKey() + "String_Node_Str");
                }
                if (!previousParameterMap.containsKey(nextParameter.getParameterKey())) {
                    throw new ValidationErrorException("String_Node_Str" + nextParameter.getParameterKey() + "String_Node_Str");
                }
                nextParameter.setParameterValue(previousParameterMap.get(nextParameter.getParameterKey()));
            }
        }
    }
}

Output:
         for (Parameter nextParameter : nextParameters) {
-            if (nextParameter.getUsePreviousValue() == Boolean.TRUE) {
+            if (Boolean.TRUE.equals(nextParameter.getUsePreviousValue())) {
                 if (Strings.isNullOrEmpty(nextParameter.getParameterValue())) {


Input:
public Point random(int m) {
    return new Point(Random.Int(left + m, right - m), Random.Int(top + m, bottom - m));
}

Output:
 public Point random(int m) {
-    return new Point(Random.Int(left + m, right - m), Random.Int(top + m, bottom - m));
+    return new Point(Random.IntRange(left + m, right - m), Random.IntRange(top + m, bottom - m));
 }


Input:
public void testNearCacheMisses() {
    final IMap map = client.getMap(mapWithBasicCash + randomString());
    final int size = 1321;
    for (int i = 0; i < size; i++) {
        map.get("String_Node_Str" + i);
    }
    NearCacheStats stats = map.getLocalMapStats().getNearCacheStats();
    assertEquals(size, stats.getMisses());
    assertEquals(size, stats.getOwnedEntryCount());
}

Output:
 public void testNearCacheMisses() {
-    final IMap map = client.getMap(mapWithBasicCash + randomString());
+    final IMap map = client.getMap(mapWithBasicCashNoInvalidation + randomString());
     final int size = 1321;


Input:
public String getAcceptContentType() {
    String contentType = httpServletRequest.getHeader("String_Node_Str");
    if (contentType == null) {
        return Result.TEXT_HTML;
    }
    if (contentType.indexOf("String_Node_Str") != -1 || contentType.indexOf("String_Node_Str") != -1 || contentType.startsWith("String_Node_Str")) {
        return Result.TEXT_HTML;
    }
    if (contentType.indexOf("String_Node_Str") != -1 || contentType.indexOf("String_Node_Str") != -1) {
        return Result.APPLICATION_XML;
    }
    if (contentType.indexOf("String_Node_Str") != -1 || contentType.indexOf("String_Node_Str") != -1) {
        return Result.APPLICATON_JSON;
    }
    if (contentType.indexOf("String_Node_Str") != -1) {
        return Result.TEXT_PLAIN;
    }
    if (contentType.indexOf("String_Node_Str") != -1) {
        return Result.APPLICATION_OCTET_STREAM;
    }
    if (contentType.endsWith("String_Node_Str")) {
        return Result.TEXT_HTML;
    }
    return Result.TEXT_HTML;
}

Output:
     if (contentType.indexOf("String_Node_Str") != -1 || contentType.indexOf("String_Node_Str") != -1) {
-        return Result.APPLICATON_JSON;
+        return Result.APPLICATION_JSON;
     }


Input:
public ReferenceSequence get(final int sequenceIndex) {
    if (referenceSequence != null && referenceSequence.getContigIndex() == sequenceIndex) {
        return referenceSequence;
    }
    if (referenceSequence != null && referenceSequence.getContigIndex() > sequenceIndex) {
        throw new SAMException("String_Node_Str" + sequenceIndex + "String_Node_Str" + referenceSequence.getContigIndex());
    }
    referenceSequence = null;
    if (referenceSequenceFile.isIndexed()) {
        final SAMSequenceRecord samSequenceRecord = referenceSequenceFile.getSequenceDictionary().getSequence(sequenceIndex);
        if (samSequenceRecord != null) {
            referenceSequence = referenceSequenceFile.getSequence(samSequenceRecord.getSequenceName());
        }
    } else {
        do {
            referenceSequence = referenceSequenceFile.nextSequence();
        } while (referenceSequence != null && referenceSequence.getContigIndex() < sequenceIndex);
    }
    if (referenceSequence == null || referenceSequence.getContigIndex() != sequenceIndex) {
        throw new SAMException("String_Node_Str" + sequenceIndex + "String_Node_Str" + referenceSequenceFile.toString());
    }
    return referenceSequence;
}

Output:
     referenceSequence = null;
-    if (referenceSequenceFile.isIndexed()) {
+    if (referenceSequenceFile.isIndexed() && referenceSequenceFile.getSequenceDictionary() != null) {
         final SAMSequenceRecord samSequenceRecord = referenceSequenceFile.getSequenceDictionary().getSequence(sequenceIndex);


Input:
public void onEnable() {
    if (Float.parseFloat(System.getProperty("String_Node_Str")) < 52.0) {
        getLogger().severe("String_Node_Str");
        getLogger().severe("String_Node_Str");
        return;
    }
    if (!getProxy().getPlayers().isEmpty() && getProxy().getPluginManager().getPlugin("String_Node_Str") != null) {
        getLogger().severe("String_Node_Str");
        getLogger().severe("String_Node_Str");
        throw new RuntimeException("String_Node_Str");
    }
    BungeeTabListPlus.getInstance(this).onEnable();
}

Output:
     }
-    if (!getProxy().getPlayers().isEmpty() && getProxy().getPluginManager().getPlugin("String_Node_Str") != null) {
-        getLogger().severe("String_Node_Str");
-        getLogger().severe("String_Node_Str");
-        throw new RuntimeException("String_Node_Str");
+    if (!getProxy().getPlayers().isEmpty()) {
+        for (ProxiedPlayer proxiedPlayer : getProxy().getPlayers()) {
+            proxiedPlayer.disconnect("String_Node_Str");
+        }
     }


Input:
private boolean releaseWifiLockLocked(IBinder lock) {
    boolean hadLock;
    WifiLock wifiLock = mLocks.removeLock(lock);
    hadLock = (wifiLock != null);
    if (hadLock) {
        int uid = Binder.getCallingUid();
        long ident = Binder.clearCallingIdentity();
        try {
            switch(wifiLock.mLockMode) {
                case (WifiManager.WIFI_MODE_FULL):
                    mBatteryStats.noteFullWifiLockReleased(uid);
                case (WifiManager.WIFI_MODE_SCAN_ONLY):
                    mBatteryStats.noteScanWifiLockReleased(uid);
            }
        } catch (RemoteException e) {
        } finally {
            Binder.restoreCallingIdentity(ident);
        }
    }
    updateWifiState();
    return hadLock;
}

Output:
             switch(wifiLock.mLockMode) {
-                case (WifiManager.WIFI_MODE_FULL):
+                case WifiManager.WIFI_MODE_FULL:
+                    ++mFullLocksReleased;
                     mBatteryStats.noteFullWifiLockReleased(uid);


Input:
public void testMultiplLocalsAndScopesNumbering() {
    SoyFileSetNode soyTree = SoyFileSetParserBuilder.forFileContents(constructTemplateSource("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")).parse().fileSet();
    createResolveNamesVisitorForMaxSyntaxVersion().exec(soyTree);
    TemplateNode n = soyTree.getChild(0).getChild(0);
    assertThat(n.getMaxLocalVariableTableSize()).isEqualTo(6);
    assertThat(n.getParams().get(0).localVariableIndex()).isEqualTo(0);
    assertThat(n.getParams().get(1).localVariableIndex()).isEqualTo(1);
    assertThat(((LetValueNode) n.getChild(0)).getVar().localVariableIndex()).isEqualTo(2);
    ForeachNonemptyNode foreachNonEmptyNode = (ForeachNonemptyNode) ((ForeachNode) n.getChild(1)).getChild(0);
    assertThat(foreachNonEmptyNode.getVar().currentLoopIndexIndex()).isEqualTo(3);
    assertThat(foreachNonEmptyNode.getVar().isLastIteratorIndex()).isEqualTo(4);
    assertThat(foreachNonEmptyNode.getVar().localVariableIndex()).isEqualTo(5);
    assertThat(((LetValueNode) n.getChild(2)).getVar().localVariableIndex()).isEqualTo(3);
}

Output:
     SoyFileSetNode soyTree = SoyFileSetParserBuilder.forFileContents(constructTemplateSource("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")).parse().fileSet();
-    createResolveNamesVisitorForMaxSyntaxVersion().exec(soyTree);
+    new ResolveNamesVisitor(ExplodingErrorReporter.get()).exec(soyTree);
     TemplateNode n = soyTree.getChild(0).getChild(0);


Input:
public void onContainerClosed(EntityPlayer playerIn) {
    super.onContainerClosed(playerIn);
    if (!playerIn.getEntityWorld().isRemote) {
        for (int i = 0; i < 1; ++i) {
            ItemStack itemstack = this.tile.removeStackFromSlot(i);
            if (!ItemStackUtil.isEmpty(itemstack)) {
                playerIn.dropItem(itemstack, false);
            }
        }
    }
}

Output:
     if (!playerIn.getEntityWorld().isRemote) {
-        for (int i = 0; i < 1; ++i) {
+        for (int i = 0; i < this.tile.getSizeInventory(); ++i) {
             ItemStack itemstack = this.tile.removeStackFromSlot(i);


Input:
private Object getCascadedInstance(String methodNameAndDesc, String returnTypeInternalName, Object mockInstance) {
    MockedTypeCascade nextLevel = this;
    Type returnType = cascadedTypesAndMocks.get(returnTypeInternalName);
    Class<?> returnClass;
    if (returnType == null) {
        Class<?> cascadingClass = getClassWithCalledMethod();
        Type genericReturnType;
        try {
            genericReturnType = getGenericReturnType(cascadingClass, methodNameAndDesc);
        } catch (NoSuchMethodException ignore) {
            return null;
        }
        if (genericReturnType == Object.class) {
            return null;
        }
        Class<?> resolvedReturnType = getClassType(genericReturnType);
        if (resolvedReturnType.isAssignableFrom(cascadingClass)) {
            if (mockInstance != null) {
                return mockInstance;
            }
            returnType = mockedType;
            returnClass = cascadingClass;
        } else {
            Object defaultReturnValue = DefaultValues.computeForType(resolvedReturnType);
            if (defaultReturnValue != null) {
                return defaultReturnValue;
            }
            cascadedTypesAndMocks.put(returnTypeInternalName, genericReturnType);
            nextLevel = CASCADING_TYPES.add(returnTypeInternalName, false, genericReturnType);
            returnType = genericReturnType;
            returnClass = resolvedReturnType;
        }
    } else {
        nextLevel = CASCADING_TYPES.getCascade(returnType);
        returnClass = getClassType(returnType);
    }
    if (getReturnTypeIfCascadingSupportedForIt(returnClass) == null) {
        return null;
    }
    return nextLevel.createNewCascadedInstanceOrUseNonCascadedOneIfAvailable(methodNameAndDesc, returnType);
}

Output:
         Class<?> cascadingClass = getClassWithCalledMethod();
-        Type genericReturnType;
-        try {
-            genericReturnType = getGenericReturnType(cascadingClass, methodNameAndDesc);
-        } catch (NoSuchMethodException ignore) {
-            return null;
-        }
-        if (genericReturnType == Object.class) {
+        Type genericReturnType = getGenericReturnType(cascadingClass, methodNameAndDesc);
+        if (genericReturnType == null) {
             return null;


Input:
public Buffer requestEmptyBuffer(final int minimumSizeOfBuffer) throws IOException {
    throw new IllegalStateException("String_Node_Str");
}

Output:
 public Buffer requestEmptyBuffer(final int minimumSizeOfBuffer) throws IOException {
-    throw new IllegalStateException("String_Node_Str");
+    return this.inputGateContext.requestEmptyBuffer(minimumSizeOfBuffer);
 }


Input:
private void updateSchema() {
    IElement element = this.getElement();
    if (element instanceof Node) {
        Node node = (Node) element;
        List<IMetadataTable> metadataList = node.getMetadataList();
        if (metadataList.size() > 0) {
            IMetadataTable oldTable = metadataList.get(0);
            String schemaPropertyName = oldTable.getAdditionalProperties().get(IComponentConstants.COMPONENT_SCHEMA_TAG);
            Object schemaObj = null;
            try {
                schemaObj = ComponentsUtils.getGenericPropertyValue(componentProperties, schemaPropertyName);
                if (schemaObj instanceof String) {
                    schemaObj = new Schema.Parser().parse((String) schemaObj);
                }
            } catch (Exception e) {
            }
            if (schemaObj != null && schemaObj instanceof Schema) {
                MetadataTable metadataTable = SchemaUtils.createSchema(String.valueOf(getValue()), componentProperties, schemaPropertyName);
                IMetadataTable newTable = MetadataToolHelper.convert(metadataTable);
                if (!newTable.sameMetadataAs(oldTable)) {
                    IElementParameter schemaParameter = node.getElementParameterFromField(EParameterFieldType.SCHEMA_REFERENCE);
                    ChangeMetadataCommand cmd = new ChangeMetadataCommand(node, schemaParameter, oldTable, newTable, null);
                    IProcess process = node.getProcess();
                    if (process instanceof org.talend.designer.core.ui.editor.process.Process) {
                        CommandStack commandStack = ((org.talend.designer.core.ui.editor.process.Process) process).getCommandStack();
                        commandStack.execute(cmd);
                    }
                }
            }
        }
    }
}

Output:
             if (schemaObj != null && schemaObj instanceof Schema) {
-                MetadataTable metadataTable = SchemaUtils.createSchema(String.valueOf(getValue()), componentProperties, schemaPropertyName);
+                MetadataTable metadataTable = SchemaUtils.createSchema(oldTable.getTableName(), componentProperties, schemaPropertyName);
                 IMetadataTable newTable = MetadataToolHelper.convert(metadataTable);


Input:
public void mouseWheelMoved(MouseWheelEvent e) {
    int notches = e.getWheelRotation();
    IAxis xAxis = chart.getAxisX();
    IAxis yAxis = chart.getAxisY();
    double xAxisRange = xAxis.getMax() - xAxis.getMin();
    double yAxisRange = yAxis.getMax() - yAxis.getMin();
    double zoomFactor;
    if (notches > 0) {
        zoomFactor = notches * 1.2;
    } else {
        zoomFactor = -notches * 0.8;
    }
    double xSqSize = xAxisRange * zoomFactor;
    double ySqSize = yAxisRange * zoomFactor;
    double xPercent = ((double) e.getX() - (double) chart.getXChartStart()) / (double) (chart.getXChartEnd() - chart.getXChartStart());
    double yPercent = ((double) e.getY() - (double) chart.getYChartEnd()) / (double) (chart.getYChartStart() - chart.getYChartEnd());
    double xValueUnderCursor = xAxis.translatePxToValue(e.getX());
    double xMin = xValueUnderCursor - xSqSize * xPercent;
    double xMax = xValueUnderCursor + xSqSize * (1 - xPercent);
    double yValueUnderCursor = yAxis.translatePxToValue(e.getY());
    double yMin = yValueUnderCursor - ySqSize * (1 - yPercent);
    double yMax = yValueUnderCursor + ySqSize * yPercent;
    if (Double.isNaN(xMin) || Double.isNaN(xMax) || Double.isNaN(yMin) || Double.isNaN(yMax)) {
        return;
    }
    chart.zoom(xMin, xMax, yMin, yMax);
    for (int i = 0; i < rightYAxis.size(); i++) {
        AAxis axis = rightYAxis.get(i);
        double axisRange = axis.getMax() - axis.getMin();
        double sqSize = axisRange * zoomFactor;
        double underCursor = axis.translatePxToValue(e.getY());
        double minVal = underCursor - sqSize * (1 - yPercent);
        double maxVal = underCursor + sqSize * yPercent;
        zoom(axis, axis.translateValueToPx(minVal), axis.translateValueToPx(maxVal));
    }
}

Output:
     IAxis yAxis = chart.getAxisY();
-    double xAxisRange = xAxis.getMax() - xAxis.getMin();
-    double yAxisRange = yAxis.getMax() - yAxis.getMin();
+    double xAxisRange = xAxis.getRange().getExtent();
+    double yAxisRange = yAxis.getRange().getExtent();
     double zoomFactor;


Input:
public String toString() {
    return "String_Node_Str" + this.element + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + this.element + "String_Node_Str";
+    return new StringBuilder('[').append(this.element).append(']').toString();
 }


Input:
public static void updateForeignKeyRelatedInfo(String oldValue, String newValue, Object[] allForeignKeyAndInfos) {
    if (allForeignKeyAndInfos == null || allForeignKeyAndInfos.length == 0) {
        return;
    }
    for (Object obj : allForeignKeyAndInfos) {
        Element e = (Element) obj;
        String nodeValue = e.getChildNodes().item(0).getNodeValue();
        String source = e.getAttribute("String_Node_Str");
        if (source.equals("String_Node_Str")) {
            StringBuilder build = new StringBuilder();
            String[] splits = nodeValue.split(FKFilterParser.endSeparator);
            for (String str : splits) {
                if (!str.trim().isEmpty() && str.startsWith(oldValue)) {
                    str = str.replaceFirst(oldValue, newValue);
                }
                build.append(str).append(FKFilterParser.endSeparator);
            }
            e.getChildNodes().item(0).setNodeValue(build.toString());
        } else {
            boolean changed = false;
            if (nodeValue.contains("String_Node_Str")) {
                changed = nodeValue.startsWith(oldValue + "String_Node_Str");
            } else {
                changed = nodeValue.startsWith(oldValue);
            }
            if (changed) {
                nodeValue = nodeValue.replaceFirst(oldValue, newValue);
                e.getChildNodes().item(0).setNodeValue(nodeValue);
            }
        }
    }
}

Output:
         } else {
-            boolean changed = false;
-            if (nodeValue.contains("String_Node_Str")) {
-                changed = nodeValue.startsWith(oldValue + "String_Node_Str");
-            } else {
-                changed = nodeValue.startsWith(oldValue);
-            }
-            if (changed) {
-                nodeValue = nodeValue.replaceFirst(oldValue, newValue);
-                e.getChildNodes().item(0).setNodeValue(nodeValue);
+            if (nodeValue.equals(oldValue)) {
+                e.getChildNodes().item(0).setNodeValue(newValue);
             }


Input:
public void checkBrowserConfEquality_RemoteFlagOFF() {
    browserConfValues1.clear();
    browserConfValues2.clear();
    browserConfValues1.put(DriverConfigurations.LocalEnvironmentConfig.browserName.toString(), "String_Node_Str");
    browserConfValues1.put(DriverConfigurations.FrameworkConfig.remoteFlag.toString(), "String_Node_Str");
    browserConfValues2.put(DriverConfigurations.LocalEnvironmentConfig.browserName.toString(), "String_Node_Str");
    browserConfValues2.put(DriverConfigurations.FrameworkConfig.remoteFlag.toString(), "String_Node_Str");
    BrowserConfR obj1 = new BrowserConfR(browserConfValues1);
    BrowserConfR obj2 = new BrowserConfR(browserConfValues2);
    browserConfList.add(obj1);
    browserConfList.add(obj2);
    Assert.assertEquals(browserConfList.size(), 2);
    Set<IBrowserConf> s = new HashSet<IBrowserConf>(browserConfList);
    List<IBrowserConf> newList = new ArrayList<IBrowserConf>(s);
    Assert.assertEquals(obj1, obj2);
    Assert.assertEquals(s.size(), 1);
    Assert.assertEquals(newList.size(), 1);
}

Output:
 public void checkBrowserConfEquality_RemoteFlagOFF() {
-    browserConfValues1.clear();
-    browserConfValues2.clear();
-    browserConfValues1.put(DriverConfigurations.LocalEnvironmentConfig.browserName.toString(), "String_Node_Str");
+    browserConfValues1.put(DriverConfigurations.LocalEnvironmentConfig.browserName.toString(), new String("String_Node_Str"));
     browserConfValues1.put(DriverConfigurations.FrameworkConfig.remoteFlag.toString(), "String_Node_Str");