Input:
protected List<DerivedField> createNumericalDerivedField(ColumnConfig config, double cutoff) {
    LinearNorm from = new LinearNorm().withOrig(config.getMean() - config.getStdDev() * cutoff).withNorm(-cutoff);
    LinearNorm to = new LinearNorm().withOrig(config.getMean() + config.getStdDev() * cutoff).withNorm(cutoff);
    NormContinuous normContinuous = new NormContinuous(FieldName.create(config.getColumnName())).withLinearNorms(from, to).withMapMissingTo(0.0).withOutliers(OutlierTreatmentMethodType.AS_EXTREME_VALUES);
    List<DerivedField> derivedFields = new ArrayList<DerivedField>();
    derivedFields.add(new DerivedField(OpType.CONTINUOUS, DataType.DOUBLE).withName(FieldName.create(genPmmlColumnName(config.getColumnName()))).withExpression(normContinuous));
    return derivedFields;
}

Output:
     List<DerivedField> derivedFields = new ArrayList<DerivedField>();
-    derivedFields.add(new DerivedField(OpType.CONTINUOUS, DataType.DOUBLE).withName(FieldName.create(genPmmlColumnName(config.getColumnName()))).withExpression(normContinuous));
+    derivedFields.add(new DerivedField(OpType.CONTINUOUS, DataType.DOUBLE).withName(FieldName.create(genPmmlColumnName(config.getColumnName(), normType))).withExpression(normContinuous));
     return derivedFields;


Input:
public static byte[] createCodeParamsScript(List<Object> list) {
    ScriptBuilder sb = new ScriptBuilder();
    try {
        for (int i = list.size() - 1; i >= 0; i--) {
            Object val = list.get(i);
            if (val instanceof byte[]) {
                sb.push((byte[]) val);
            } else if (val instanceof Boolean) {
                sb.push((Boolean) val);
            } else if (val instanceof Integer) {
                sb.push(Helper.BigInt2Bytes(BigInteger.valueOf((int) val)));
            } else if (val instanceof Long) {
                sb.push(Helper.BigInt2Bytes(BigInteger.valueOf((Long) val)));
            } else if (val instanceof BigInteger) {
                sb.push((BigInteger) val);
            } else if (val instanceof Map) {
                byte[] bys = getMapBytes(val);
                sb.push(bys);
            } else if (val instanceof Struct) {
                byte[] bys = getStructBytes(val);
                sb.push(bys);
            } else if (val instanceof List) {
                List tmp = (List) val;
                createCodeParamsScript(sb, tmp);
                sb.push(new BigInteger(String.valueOf(tmp.size())));
                sb.pushPack();
            } else {
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return sb.toArray();
}

Output:
             } else if (val instanceof Integer) {
-                sb.push(Helper.BigInt2Bytes(BigInteger.valueOf((int) val)));
+                sb.push(Helper.BigIntToNeoBytes(BigInteger.valueOf((int) val)));
             } else if (val instanceof Long) {


Input:
public void addInterface(TypeX typeX, ISourceLocation sourceLocation) {
    myGen.addInterface(typeX.getName());
    warnOnAddedInterface(typeX.getName(), sourceLocation);
}

Output:
     myGen.addInterface(typeX.getName());
-    warnOnAddedInterface(typeX.getName(), sourceLocation);
+    if (!typeX.equals(TypeX.SERIALIZABLE))
+        warnOnAddedInterface(typeX.getName(), sourceLocation);
 }


Input:
private static String readScript(File scriptFile) throws UnsupportedEncodingException, FileNotFoundException, IOException {
    Reader reader = null;
    try {
        reader = new InputStreamReader(new FileInputStream(scriptFile), PACK_FILE_ENCODING);
        StringWriter writer = new StringWriter();
        int i = 0;
        char[] buff = new char[BUFFER_SIZE];
        while (i >= 0) {
            i = reader.read(buff);
            if (i > 0) {
                writer.write(buff, 0, i);
            }
        }
        return writer.toString();
    } catch (IOException e) {
        throw new IOException("String_Node_Str" + scriptFile.getAbsolutePath(), e);
    } finally {
        if (reader != null) {
            reader.close();
        }
    }
}

Output:
     } catch (IOException e) {
-        throw new IOException("String_Node_Str" + scriptFile.getAbsolutePath(), e);
+        IOException ee = new IOException("String_Node_Str" + scriptFile.getAbsolutePath());
+        ee.initCause(e);
+        throw ee;
     } finally {


Input:
ImmutableList<String> getCompilationFlags(Path workingDir) {
    if (cxxType == CxxToolProvider.Type.WINDOWS) {
        return ImmutableList.of();
    }
    ImmutableList.Builder<String> flags = ImmutableList.builder();
    Iterable<Map.Entry<Path, String>> iter = ImmutableList.copyOf(getAllPaths(Optional.of(workingDir))).reverse();
    for (Map.Entry<Path, String> mappings : iter) {
        flags.add(getDebugPrefixMapFlag(mappings.getKey(), mappings.getValue()));
    }
    if (isGcc) {
        flags.add("String_Node_Str");
    }
    return flags.build();
}

Output:
     ImmutableList.Builder<String> flags = ImmutableList.builder();
-    Iterable<Map.Entry<Path, String>> iter = ImmutableList.copyOf(getAllPaths(Optional.of(workingDir))).reverse();
-    for (Map.Entry<Path, String> mappings : iter) {
-        flags.add(getDebugPrefixMapFlag(mappings.getKey(), mappings.getValue()));
-    }
+    RichStream.from(prefixMap.entrySet()).<Map.Entry<Path, String>>map(e -> new AbstractMap.SimpleEntry<>(e.getKey(), e.getValue().toString())).concat(RichStream.from(getAllPaths(Optional.of(workingDir)))).sorted(Comparator.comparingInt(entry -> entry.getKey().toString().length())).map(p -> getDebugPrefixMapFlag(p.getKey(), p.getValue())).forEach(flags::add);
     if (isGcc) {


Input:
public boolean equals(Object obj) {
    if (obj instanceof IComponentIdentifier) {
        IComponentIdentifier compId = (IComponentIdentifier) obj;
        return new EqualsBuilder().append(getHierarchyNames(), compId.getHierarchyNames()).append(getNeighbours(), compId.getNeighbours()).isEquals();
    }
    return super.equals(obj);
}

Output:
         IComponentIdentifier compId = (IComponentIdentifier) obj;
-        return new EqualsBuilder().append(getHierarchyNames(), compId.getHierarchyNames()).append(getNeighbours(), compId.getNeighbours()).isEquals();
+        List neighbours1 = new ArrayList(getNeighbours());
+        List neighbours2 = new ArrayList(compId.getNeighbours());
+        Collections.sort(neighbours1);
+        Collections.sort(neighbours2);
+        return new EqualsBuilder().append(getHierarchyNames(), compId.getHierarchyNames()).append(neighbours1, neighbours2).isEquals();
     }


Input:
public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
    if (_support == null) {
        synchronized (this) {
            if (_support == null)
                _support = new PropertyChangeSupport(_element);
        }
    }
    _support.addPropertyChangeListener(l);
}

Output:
 public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
-    if (_support == null) {
-        synchronized (this) {
-            if (_support == null)
-                _support = new PropertyChangeSupport(_element);
-        }
-    }
+    if (_support == null)
+        _support = new PropertyChangeSupport(_element);
     _support.addPropertyChangeListener(l);


Input:
public void run() {
    fillClassesList(1);
    TaskManager.getInstance().setTaskFinished();
}

Output:
 public void run() {
-    fillClassesList(1);
+    fillClassesList(3);
     TaskManager.getInstance().setTaskFinished();


Input:
public ColumnDefinition getColumnDefinition(String tableName, int ordinalPosition) {
    return new ColumnDefinition(tableName, name, "String_Node_Str", ordinalPosition, false, true);
}

Output:
 public ColumnDefinition getColumnDefinition(String tableName, int ordinalPosition) {
-    return new ColumnDefinition(tableName, name, "String_Node_Str", ordinalPosition, false, true);
+    return new ColumnDefinition(tableName, name, "String_Node_Str", null, ordinalPosition, false, true);
 }


Input:
private void actionRejectRecommendation(AnnotationActionHandler aActionHandler, AnnotatorState aState, AjaxRequestTarget aTarget, JCas aJCas, VID aVID, int aBegin, int aEnd) throws AnnotationException {
    Predictions model = recommendationService.getPredictions(aState.getUser(), aState.getProject());
    Recommender recommender = recommendationService.getRecommender(aVID.getId());
    AnnotationLayer layer = annotationService.getLayer(aVID.getLayerId());
    AnnotationFeature feature = annotationService.getFeature(recommender.getFeature(), layer);
    AnnotationObject prediction = model.getPredictionByVID(aVID);
    String predictedValue = prediction.getAnnotation();
    String tokenText = aJCas.getDocumentText().substring(aBegin, aEnd);
    LearningRecord record = new LearningRecord();
    record.setUser(aState.getUser().getUsername());
    record.setSourceDocument(aState.getDocument());
    record.setUserAction(LearningRecordUserAction.REJECTED);
    record.setOffsetCharacterBegin(prediction.getOffset().getBeginCharacter());
    record.setOffsetCharacterEnd(prediction.getOffset().getEndCharacter());
    record.setOffsetTokenBegin(prediction.getOffset().getBeginToken());
    record.setOffsetTokenEnd(prediction.getOffset().getEndToken());
    record.setTokenText(tokenText);
    record.setAnnotation(predictedValue);
    record.setLayer(layer);
    record.setChangeLocation(LearningRecordChangeLocation.MAIN_EDITOR);
    learningRecordService.create(record);
    aActionHandler.actionSelect(aTarget, aJCas);
    aTarget.getPage().send(aTarget.getPage(), Broadcast.BREADTH, new AjaxRecommendationRejectedEvent(aTarget, aState, aVID));
    applicationEventPublisher.publishEvent(new RecommendationRejectedEvent(this, aState.getDocument(), aState.getUser().getUsername(), aBegin, aEnd, tokenText, feature, predictedValue));
}

Output:
     AnnotationFeature feature = annotationService.getFeature(recommender.getFeature(), layer);
-    AnnotationObject prediction = model.getPredictionByVID(aVID);
+    SourceDocument document = aState.getDocument();
+    Optional<AnnotationObject> oPrediction = model.getPredictionByVID(document, aVID);
+    if (!oPrediction.isPresent()) {
+        log.error("String_Node_Str", document, aVID);
+        aTarget.getPage().error("String_Node_Str");
+        aTarget.addChildren(aTarget.getPage(), IFeedback.class);
+        return;
+    }
+    AnnotationObject prediction = oPrediction.get();
     String predictedValue = prediction.getAnnotation();


Input:
public void getAppInfo(HttpRequest request, HttpResponder responder, String appId) {
    appLifecycleHttpHandler.getAppInfo(rewriteRequest(request), responder, Constants.DEFAULT_NAMESPACE, appId);
}

Output:
 public void getAppInfo(HttpRequest request, HttpResponder responder, String appId) {
-    appLifecycleHttpHandler.getAppInfo(rewriteRequest(request), responder, Constants.DEFAULT_NAMESPACE, appId);
+    appLifecycleHttpHandler.getAppInfo(RESTMigrationUtils.rewriteV2RequestToV3(request), responder, Constants.DEFAULT_NAMESPACE, appId);
 }


Input:
public void addPoint(int x, int y, long time) {
    if (xs.size() > 0) {
        int dx = xs.get(xs.size() - 1) - x;
        int dy = ys.get(ys.size() - 1) - y;
        if (dx * dx + dy * dy <= 5)
            return;
    }
    xs.add(x);
    ys.add(y);
    times.add(time);
}

Output:
 public void addPoint(int x, int y, long time) {
-    if (xs.size() > 0) {
-        int dx = xs.get(xs.size() - 1) - x;
-        int dy = ys.get(ys.size() - 1) - y;
+    if (mXs.size() > 0) {
+        int dx = mXs.get(mXs.size() - 1) - x;
+        int dy = mYs.get(mYs.size() - 1) - y;
         if (dx * dx + dy * dy <= 5)


Input:
public void drawBackgroundImage(String imageURI, float x, float y, float width, float height, float positionX, float positionY, String repeat) {
    if (imageURI == null || imageURI.length() == 0) {
        return;
    }
    float imageWidth = 0;
    float imageHeight = 0;
    byte[] imageData = null;
    InputStream imageStream = null;
    try {
        URL url = new URL(imageURI);
        imageStream = url.openStream();
        imageData = new byte[imageStream.available()];
        imageStream.read(imageData);
        imageStream.close();
        imageStream = url.openStream();
        Image image = ImageIO.read(imageStream);
        ImageIcon imageIcon = new ImageIcon(image);
        imageWidth = imageIcon.getIconWidth();
        imageHeight = imageIcon.getIconHeight();
    } catch (IOException ioe) {
        logger.log(Level.WARNING, ioe.getMessage(), ioe);
    } finally {
        if (imageStream != null) {
            try {
                imageStream.close();
            } catch (IOException e) {
            }
        }
    }
    String imageTitle = "String_Node_Str" + currentPageNum + "String_Node_Str" + (++shapeCount);
    imageTitles.add(imageTitle);
    String imageName;
    if (imageNames.containsKey(imageURI)) {
        imageName = (String) imageNames.get(imageURI);
    } else {
        String extension = getImageExtension(imageURI);
        imageName = imageTitle + "String_Node_Str" + extension;
        imageNames.put(imageTitle, imageName);
        imageExtensions.put(imageTitle, extension);
        recordFileLists(imageName);
        currentImageData.put(imageTitle, imageData);
    }
    Position areaPosition = new Position(x, y);
    Position areaSize = new Position(width, height);
    Position imagePosition = new Position(x + positionX, y + positionY);
    Position imageSize = new Position(imageWidth, imageHeight);
    BackgroundImageLayout layout = new BackgroundImageLayout(areaPosition, areaSize, imagePosition, imageSize);
    Collection positions = layout.getImagePositions(repeat);
    Iterator iterator = positions.iterator();
    while (iterator.hasNext()) {
        Position position = (Position) iterator.next();
        exportImageDefn(imageName, imageTitle, imageWidth, imageHeight, position.getX(), position.getY());
    }
}

Output:
         imageStream = url.openStream();
-        imageData = new byte[imageStream.available()];
-        imageStream.read(imageData);
+        imageData = getImageData(imageStream);
         imageStream.close();


Input:
public void endElement(XPathFragment xPathFragment, UnmarshalRecord unmarshalRecord) {
    Object value = unmarshalRecord.getCharacters().toString();
    boolean isCDATA = unmarshalRecord.isBufferCDATA();
    unmarshalRecord.resetStringBuffer();
    Field toWrite = xmlField;
    if (xmlField.isCDATA() != isCDATA) {
        toWrite = new XMLField(xmlField.getName());
        toWrite.setNamespaceResolver(xmlField.getNamespaceResolver());
        toWrite.setIsCDATA(isCDATA);
    }
    XMLConversionManager xmlConversionManager = (XMLConversionManager) unmarshalRecord.getSession().getDatasourcePlatform().getConversionManager();
    if (unmarshalRecord.getTypeQName() != null) {
        Class typeClass = xmlField.getJavaClass(unmarshalRecord.getTypeQName());
        value = xmlConversionManager.convertObject(value, typeClass, unmarshalRecord.getTypeQName());
    } else {
        value = unmarshalRecord.getXMLReader().convertValueBasedOnSchemaType(xmlField, value, xmlConversionManager, unmarshalRecord);
    }
    if (null == unmarshalRecord.getTransformationRecord()) {
        unmarshalRecord.setTransformationRecord(new XMLTransformationRecord("String_Node_Str", unmarshalRecord));
    }
    unmarshalRecord.getTransformationRecord().put(toWrite, value);
}

Output:
     }
-    XMLConversionManager xmlConversionManager = (XMLConversionManager) unmarshalRecord.getSession().getDatasourcePlatform().getConversionManager();
+    ConversionManager conversionManager = (ConversionManager) unmarshalRecord.getSession().getDatasourcePlatform().getConversionManager();
     if (unmarshalRecord.getTypeQName() != null) {


Input:
private static List<Class> findClassesInJar(File file, List<String> packages, Class<?> type) {
    List<Class> cards = new ArrayList<Class>();
    if (!file.exists()) {
        return cards;
    }
    JarInputStream jarFile = null;
    try {
        jarFile = new JarInputStream(new FileInputStream(file));
        while (true) {
            JarEntry jarEntry = jarFile.getNextJarEntry();
            if (jarEntry == null) {
                break;
            }
            if (jarEntry.getName().endsWith("String_Node_Str")) {
                String className = jarEntry.getName().replace('/', '.').replace("String_Node_Str", "String_Node_Str");
                int packageNameEnd = className.lastIndexOf('.');
                String packageName = packageNameEnd != -1 ? className.substring(0, packageNameEnd) : "String_Node_Str";
                if (packages.contains(packageName)) {
                    Class<?> clazz;
                    try {
                        clazz = Class.forName(className);
                        if (type.isAssignableFrom(clazz)) {
                            cards.add(clazz);
                        }
                    } catch (ClassNotFoundException ex) {
                    }
                }
            }
        }
    } catch (IOException ex) {
    } finally {
        try {
            jarFile.close();
        } catch (IOException ex) {
        }
    }
    return cards;
}

Output:
 private static List<Class> findClassesInJar(File file, List<String> packages, Class<?> type) {
-    List<Class> cards = new ArrayList<Class>();
+    List<Class> cards = new ArrayList<>();
     if (!file.exists()) {


Input:
public Representation getMedia() {
    setServerHeader();
    Request request = getRequest();
    String userId = null;
    String token = null;
    String entityId = (String) request.getAttributes().get(Constants.ENTITY_ARG);
    String mediaId = (String) request.getAttributes().get(Constants.MEDIA_ARG);
    boolean isChannelPublic = XMPPToolBox.getInstance().getPubSubClient().isChannelPublic(entityId);
    if (!isChannelPublic && !mediaId.equals(Constants.AVATAR_ARG)) {
        String auth = getQueryValue(Constants.AUTH_QUERY);
        try {
            userId = getUserId(request, auth);
            token = getTransactionId(request, auth);
        } catch (Throwable t) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            return new StringRepresentation("String_Node_Str", MediaType.APPLICATION_JSON);
        }
        Representation verifyRequest = verifyRequest(userId, token, request.getResourceRef().getIdentifier());
        if (verifyRequest != null) {
            return verifyRequest;
        }
    }
    Integer maxHeight = null;
    Integer maxWidth = null;
    try {
        String queryValue = getQueryValue(Constants.MAX_HEIGHT_QUERY);
        if (queryValue != null) {
            maxHeight = Integer.valueOf(queryValue);
        }
        queryValue = getQueryValue(Constants.MAX_WIDTH_QUERY);
        if (queryValue != null) {
            maxWidth = Integer.valueOf(queryValue);
        }
    } catch (Throwable t) {
        setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
        return new StringRepresentation("String_Node_Str", MediaType.APPLICATION_JSON);
    }
    try {
        MediaDAO mediaDAO = DAOFactory.getInstance().getDAO();
        int maxAge = mediaDAO.getMaxAge();
        addCacheHeaders(maxAge);
        if (maxHeight == null && maxWidth == null) {
            MediaType mediaType = new MediaType(mediaDAO.getMediaType(entityId, mediaId));
            File media = mediaDAO.getMedia(userId, entityId, mediaId);
            return new FileRepresentation(media, mediaType, maxAge);
        }
        Thumbnail thumbnail = null;
        if (maxHeight != null && maxWidth == null) {
            thumbnail = mediaDAO.getMediaPreview(userId, entityId, mediaId, maxHeight);
        } else if (maxHeight == null && maxWidth != null) {
            thumbnail = mediaDAO.getMediaPreview(userId, entityId, mediaId, maxWidth);
        } else {
            thumbnail = mediaDAO.getMediaPreview(userId, entityId, mediaId, maxHeight, maxWidth);
        }
        return new DynamicFileRepresentation(new MediaType(thumbnail.getMimeType()), thumbnail.getImg(), maxAge);
    } catch (MetadataSourceException e) {
        setStatus(Status.SERVER_ERROR_INTERNAL);
    } catch (IOException e) {
        setStatus(Status.SERVER_ERROR_INTERNAL);
    } catch (MediaNotFoundException e) {
        setStatus(Status.CLIENT_ERROR_NOT_FOUND);
    } catch (InvalidPreviewFormatException e) {
        setStatus(Status.CLIENT_ERROR_PRECONDITION_FAILED);
    } catch (UserNotAllowedException e) {
        setStatus(Status.CLIENT_ERROR_FORBIDDEN);
    } catch (Throwable t) {
        return unexpectedError(t);
    }
    return new EmptyRepresentation();
}

Output:
         }
-        Representation verifyRequest = verifyRequest(userId, token, request.getResourceRef().getIdentifier());
+        Representation verifyRequest = checkRequest(userId, token, request.getResourceRef().getIdentifier());
         if (verifyRequest != null) {


Input:
public boolean selectPreviousVisualMode(Editor editor, DataContext context) {
    VisualRange vr = EditorData.getLastVisualRange(editor);
    if (vr == null) {
        return false;
    }
    CommandState.getInstance().pushState(CommandState.MODE_VISUAL, vr.getType(), KeyParser.MAPPING_VISUAL);
    visualStart = vr.getStart();
    visualEnd = vr.getEnd();
    updateSelection(editor, context, visualEnd);
    MotionGroup.moveCaret(editor, context, visualEnd);
    return true;
}

Output:
     updateSelection(editor, context, visualEnd);
-    MotionGroup.moveCaret(editor, context, visualEnd);
+    editor.getCaretModel().moveToOffset(visualOffset);
+    editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
     return true;


Input:
public List<CssDeclaration> resolveShorthand(String shorthandExpression) {
    if (UNSUPPORTED_VALUES_OF_FONT_SHORTHAND.contains(shorthandExpression)) {
        Logger logger = LoggerFactory.getLogger(FontShorthandResolver.class);
        logger.error(MessageFormat.format("String_Node_Str", shorthandExpression));
    }
    if (CssConstants.INITIAL.equals(shorthandExpression) || CssConstants.INHERIT.equals(shorthandExpression)) {
        return Arrays.asList(new CssDeclaration(CssConstants.FONT_STYLE, shorthandExpression), new CssDeclaration(CssConstants.FONT_VARIANT, shorthandExpression), new CssDeclaration(CssConstants.FONT_WEIGHT, shorthandExpression), new CssDeclaration(CssConstants.FONT_SIZE, shorthandExpression), new CssDeclaration(CssConstants.LINE_HEIGHT, shorthandExpression), new CssDeclaration(CssConstants.FONT_FAMILY, shorthandExpression));
    }
    String fontStyleValue = null;
    String fontVariantValue = null;
    String fontWeightValue = null;
    String fontSizeValue = null;
    String lineHeightValue = null;
    String fontFamilyValue = null;
    String[] props = shorthandExpression.replaceAll("String_Node_Str", "String_Node_Str").split("String_Node_Str");
    for (String value : props) {
        int slashSymbolIndex = value.indexOf('/');
        if (CssConstants.ITALIC.equals(value) || CssConstants.OBLIQUE.equals(value)) {
            fontStyleValue = value;
        } else if (CssConstants.SMALL_CAPS.equals(value)) {
            fontVariantValue = value;
        } else if (FONT_WEIGHT_NOT_DEFAULT_VALUES.contains(value)) {
            fontWeightValue = value;
        } else if (slashSymbolIndex > 0) {
            fontSizeValue = value.substring(0, slashSymbolIndex);
            lineHeightValue = value.substring(slashSymbolIndex + 1, value.length());
        } else if (FONT_SIZE_VALUES.contains(value)) {
            fontSizeValue = value;
        } else {
            fontFamilyValue = value;
        }
    }
    List<CssDeclaration> cssDeclarations = Arrays.asList(new CssDeclaration(CssConstants.FONT_STYLE, fontStyleValue == null ? CssConstants.INITIAL : fontStyleValue), new CssDeclaration(CssConstants.FONT_VARIANT, fontVariantValue == null ? CssConstants.INITIAL : fontVariantValue), new CssDeclaration(CssConstants.FONT_WEIGHT, fontWeightValue == null ? CssConstants.INITIAL : fontWeightValue), new CssDeclaration(CssConstants.FONT_SIZE, fontSizeValue == null ? CssConstants.INITIAL : fontSizeValue), new CssDeclaration(CssConstants.LINE_HEIGHT, lineHeightValue == null ? CssConstants.INITIAL : lineHeightValue), new CssDeclaration(CssConstants.FONT_FAMILY, fontFamilyValue == null ? CssConstants.INITIAL : fontFamilyValue));
    return cssDeclarations;
}

Output:
             lineHeightValue = value.substring(slashSymbolIndex + 1, value.length());
-        } else if (FONT_SIZE_VALUES.contains(value)) {
+        } else if (FONT_SIZE_VALUES.contains(value) || CssUtils.isMetricValue(value) || CssUtils.isNumericValue(value)) {
             fontSizeValue = value;


Input:
public void handleDragging(GL gl, float mouseCoordinateX, float mouseCoordinateY) {
    switch(draggingSelection) {
        case COMPARE_SELECTION_WINDOW_SELECTION:
            handleWindowDragging(gl, mouseCoordinateX, mouseCoordinateY);
            break;
        case COMPARE_SELECTION_WINDOW_ARROW_LEFT_SELECTION:
            handleArrowLeftDragging(gl, mouseCoordinateX, mouseCoordinateY);
            break;
        case COMPARE_SELECTION_WINDOW_ARROW_RIGHT_SELECTION:
            handleArrowRightDragging(gl, mouseCoordinateX, mouseCoordinateY);
            break;
    }
    if (dragged) {
        renderWindow(gl, numSelectedItemsDragging, lowestItemIndexDragging, 0.5f, false, -0.05f);
    }
}

Output:
     if (dragged) {
-        renderWindow(gl, numSelectedItemsDragging, lowestItemIndexDragging, 0.5f, false, -0.05f);
+        renderWindow(gl, numSelectedItemsDragging, lowestItemIndexDragging, 0.5f, false, -0.001f);
     }


Input:
public void removeComponentServerState(Class clazz) {
    internalComponentMap.remove(clazz);
}

Output:
 public void removeComponentServerState(Class clazz) {
-    internalComponentMap.remove(clazz);
+    Class lookupClass = CellComponentUtils.getLookupClass(clazz);
+    internalComponentMap.remove(lookupClass);
 }


Input:
public void onClick(DialogInterface dialog, int which) {
    Log.d("String_Node_Str", "String_Node_Str" + ((InstanceIndexItem) item).getTitle());
    ((InstanceIndexItem) item).deleteAssociatedFiles(context, false);
    mDataset.remove(position);
    notifyItemRemoved(position);
}

Output:
     ((InstanceIndexItem) item).deleteAssociatedFiles(context, false);
-    mDataset.remove(position);
-    notifyItemRemoved(position);
+    mDataset.remove(safePosition);
+    notifyItemRemoved(safePosition);
 }


Input:
public FinalSetOperationCTECriteriaBuilder<T> endSet() {
    subListener.verifyBuilderEnded();
    listener.onBuilderEnded(this);
    return (FinalSetOperationCTECriteriaBuilder<T>) finalSetOperationBuilder;
}

Output:
     listener.onBuilderEnded(this);
-    return (FinalSetOperationCTECriteriaBuilder<T>) finalSetOperationBuilder;
+    return (FinalSetOperationCTECriteriaBuilder<T>) (FinalSetOperationCTECriteriaBuilder) finalSetOperationBuilder;
 }


Input:
public V get(long key) {
    if (key == FastByIDMap.NULL) {
        return null;
    }
    int index = find(key);
    if (countingAccesses) {
        recentlyAccessed.set(index);
    }
    return values[index];
}

Output:
 public V get(long key) {
-    if (key == FastByIDMap.NULL) {
+    if (key == NULL) {
         return null;


Input:
private Task createTaskLocked(int taskId, int stackId, int userId, AppWindowToken atoken) {
    if (DEBUG_STACK)
        Slog.i(TAG, "String_Node_Str" + taskId + "String_Node_Str" + stackId + "String_Node_Str" + atoken);
    final TaskStack stack = mStackIdToStack.get(stackId);
    if (stack == null) {
        throw new IllegalArgumentException("String_Node_Str" + stackId);
    }
    EventLog.writeEvent(EventLogTags.WM_TASK_CREATED, taskId, stackId);
    Task task = new Task(taskId, stack, userId, this);
    mTaskIdToTask.put(taskId, task);
    stack.addTask(task, !atoken.mLaunchTaskBehind);
    return task;
}

Output:
     mTaskIdToTask.put(taskId, task);
-    stack.addTask(task, !atoken.mLaunchTaskBehind);
+    stack.addTask(task, !atoken.mLaunchTaskBehind, atoken.showWhenLocked);
     return task;


Input:
public String getHexSignature() {
    return new String(DatatypeConverter.parseHexBinary(new String(signature)));
}

Output:
 public String getHexSignature() {
-    return new String(DatatypeConverter.parseHexBinary(new String(signature)));
+    return Hex.encodeHexString(signature);
 }


Input:
private void completeModule(ModuleSymbol msym) {
    if (inInitModules) {
        msym.completer = sym -> completeModule(msym);
        return;
    }
    if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {
        completeAutomaticModule(msym);
    }
    Assert.checkNonNull(msym.requires);
    initAddReads();
    msym.requires = msym.requires.appendList(List.from(addReads.getOrDefault(msym, Collections.emptySet())));
    List<RequiresDirective> requires = msym.requires;
    List<RequiresDirective> previous = null;
    while (requires.nonEmpty()) {
        if (!allModules().contains(requires.head.module)) {
            Env<AttrContext> env = typeEnvs.get(msym);
            if (env != null) {
                JavaFileObject origSource = log.useSource(env.toplevel.sourcefile);
                try {
                    log.error(env.tree, Errors.ModuleNotFound(requires.head.module));
                } finally {
                    log.useSource(origSource);
                }
            } else {
                Assert.check((msym.flags() & Flags.AUTOMATIC_MODULE) == 0);
            }
            if (previous != null) {
                previous.tail = requires.tail;
            } else {
                msym.requires.tail = requires.tail;
            }
        } else {
            previous = requires;
        }
        requires = requires.tail;
    }
    Set<ModuleSymbol> readable = new LinkedHashSet<>();
    Set<ModuleSymbol> requiresTransitive = new HashSet<>();
    for (RequiresDirective d : msym.requires) {
        d.module.complete();
        readable.add(d.module);
        Set<ModuleSymbol> s = retrieveRequiresTransitive(d.module);
        Assert.checkNonNull(s, () -> "String_Node_Str" + d.module);
        readable.addAll(s);
        if (d.flags.contains(RequiresFlag.TRANSITIVE)) {
            requiresTransitive.add(d.module);
            requiresTransitive.addAll(s);
        }
    }
    requiresTransitiveCache.put(msym, requiresTransitive);
    initVisiblePackages(msym, readable);
    for (ExportsDirective d : msym.exports) {
        if (d.packge != null) {
            d.packge.modle = msym;
        }
    }
}

Output:
             }
-            if (previous != null) {
-                previous.tail = requires.tail;
-            } else {
-                msym.requires.tail = requires.tail;
-            }
-        } else {
-            previous = requires;
+            msym.requires = List.filter(msym.requires, requires.head);
         }


Input:
public JsonType visitPrimitive(PrimitiveType primitiveType, Void o) {
    return newJsonType(primitiveType);
}

Output:
 public JsonType visitPrimitive(PrimitiveType primitiveType, Void o) {
-    return newJsonType(primitiveType);
+    return jsonTypeFromTypeMirror(primitiveType, new HashSet<DeclaredType>(_typeRecursionDetector));
 }


Input:
public boolean playLand(Card card, Game game) {
    ActivatedAbility playLandAbility = null;
    boolean found = false;
    for (Ability ability : card.getAbilities()) {
        if ((ability instanceof AlternativeSourceCosts) || (ability instanceof OptionalAdditionalSourceCosts)) {
            found = true;
        }
        if (ability instanceof PlayLandAbility) {
            playLandAbility = (ActivatedAbility) ability;
        }
    }
    if (found) {
        SpellAbility spellAbility = new SpellAbility(null, "String_Node_Str", game.getState().getZone(card.getId()), SpellAbilityType.FACE_DOWN_CREATURE);
        spellAbility.setControllerId(this.getId());
        spellAbility.setSourceId(card.getId());
        if (cast(spellAbility, game, false)) {
            return true;
        }
    }
    if (playLandAbility == null) {
        return false;
    }
    if (!playLandAbility.canActivate(this.playerId, game)) {
        return false;
    }
    if (!game.replaceEvent(GameEvent.getEvent(GameEvent.EventType.PLAY_LAND, card.getId(), card.getId(), playerId))) {
        if (moveCards(card, Zone.BATTLEFIELD, playLandAbility, game, false, false, false, null)) {
            landsPlayed++;
            game.fireEvent(GameEvent.getEvent(GameEvent.EventType.LAND_PLAYED, card.getId(), card.getId(), playerId));
            game.fireInformEvent(getLogName() + "String_Node_Str" + card.getLogName());
            resetStoredBookmark(game);
            return true;
        }
    }
    return false;
}

Output:
     }
-    return false;
+    return true;
 }


Input:
public String getParameter(String name) {
    if (name == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    bodyAccessed = true;
    Map parameters = this._getHttpServletRequest().getParameterMap();
    String[] values = (String[]) parameters.get(name);
    if (values != null) {
        return values[0];
    }
    return null;
}

Output:
     bodyAccessed = true;
-    Map parameters = this._getHttpServletRequest().getParameterMap();
+    Map parameters = getParameterMap();
     String[] values = (String[]) parameters.get(name);


Input:
private Monitor findGroupMonitor(String id, Map<String, Monitor> monitors) {
    if (monitors.containsKey(id)) {
        return monitors.get(id);
    }
    for (Monitor monitor : monitors.values()) {
        if (monitor instanceof ParentComponentMonitor) {
            Monitor monitor1 = findGroupMonitor(id, ((ParentComponentMonitor) monitor).getAliasToActiveMonitorsMap());
            if (monitor1 != null) {
                return monitor1;
            }
        }
    }
    return null;
}

Output:
         if (monitor instanceof ParentComponentMonitor) {
-            Monitor monitor1 = findGroupMonitor(id, ((ParentComponentMonitor) monitor).getAliasToActiveMonitorsMap());
-            if (monitor1 != null) {
-                return monitor1;
+            Monitor groupMonitor = findGroupMonitor(id, ((ParentComponentMonitor) monitor).getAliasToActiveMonitorsMap());
+            if (groupMonitor != null) {
+                return groupMonitor;
             }


Input:
private void updatePresenceForMatchingEntry(org.eclipse.ecf.presence.roster.RosterEntry entry, XMPPID fromID, IPresence newPresence) {
    final IUser user = entry.getUser();
    if (fromID.equals(user.getID())) {
        entry.setPresence(newPresence);
        rosterManager.notifyRosterUpdate(entry);
    }
}

Output:
     final IUser user = entry.getUser();
-    if (fromID.equals(user.getID())) {
+    ID oldID = user.getID();
+    if (fromID.equals(oldID)) {
+        if (oldID instanceof XMPPID)
+            updateXMPPID(fromID, (XMPPID) oldID);
         entry.setPresence(newPresence);


Input:
public void Setup(net.minecraft.entity.player.EntityPlayer Player, net.minecraft.item.ItemStack Item) {
    super.Setup(Player, Item);
    this.Player = CarriageDriveItem.GetPrivateFlag(Item) ? Player.username : "String_Node_Str";
    Label = CarriageDriveItem.GetLabel(Item);
    if (!worldObj.isRemote) {
        RegisterLabel();
        {
            ClearLabel();
            RegisterLabel();
        }
    }
}

Output:
     super.Setup(Player, Item);
-    this.Player = CarriageDriveItem.GetPrivateFlag(Item) ? Player.username : "String_Node_Str";
+    this.Player = CarriageDriveItem.GetPrivateFlag(Item) ? Player.getDisplayName() : "String_Node_Str";
     Label = CarriageDriveItem.GetLabel(Item);


Input:
private static int getScanId(NBTTagCompound tagCompound) {
    if (tagCompound.hasKey("String_Node_Str")) {
        return tagCompound.getInteger("String_Node_Str");
    }
    Shape shape = getShape(tagCompound);
    if (shape == Shape.SHAPE_COMPOSITION) {
        NBTTagList children = tagCompound.getTagList("String_Node_Str", Constants.NBT.TAG_COMPOUND);
        for (int i = 0; i < children.tagCount(); i++) {
            NBTTagCompound childTag = children.getCompoundTagAt(i);
            int id = getScanId(childTag);
            if (id != 0) {
                return id;
            }
        }
    }
    return 0;
}

Output:
     }
-    Shape shape = getShape(tagCompound);
-    if (shape == Shape.SHAPE_COMPOSITION) {
-        NBTTagList children = tagCompound.getTagList("String_Node_Str", Constants.NBT.TAG_COMPOUND);
-        for (int i = 0; i < children.tagCount(); i++) {
-            NBTTagCompound childTag = children.getCompoundTagAt(i);
-            int id = getScanId(childTag);
-            if (id != 0) {
-                return id;
-            }
-        }
-    }
-    return 0;
+    NBTTagCompound tagCompound = getCompound(stack);
+    return tagCompound.getInteger("String_Node_Str");
 }


Input:
public BigDecimal getPlanningLinesAmount(Task task, LocalDate startDate) throws AxelorException {
    BigDecimal planningLinesAmount = BigDecimal.ZERO;
    if (task.getPlanningLineList() == null)
        return planningLinesAmount;
    for (PlanningLine planningLine : task.getPlanningLineList()) {
        if (startDate == null || planningLine.getFromDateTime().isAfter(startDate)) {
            Employee employee = planningLine.getEmployee();
            Product profil = planningLine.getProduct();
            if (employee != null) {
                planningLinesAmount = planningLinesAmount.add(employee.getDailySalaryCost().multiply(unitConversionService.convert(planningLine.getUnit(), unitRepo.findByCode("String_Node_Str"), planningLine.getDuration())));
            } else if (profil != null) {
                planningLinesAmount = planningLinesAmount.add(profil.getCostPrice().multiply(unitConversionService.convert(planningLine.getUnit(), profil.getUnit(), planningLine.getDuration())));
            }
        }
    }
    return planningLinesAmount;
}

Output:
     for (PlanningLine planningLine : task.getPlanningLineList()) {
-        if (startDate == null || planningLine.getFromDateTime().isAfter(startDate)) {
+        if (startDate == null || planningLine.getFromDateTime().toLocalDate().isAfter(startDate)) {
             Employee employee = planningLine.getEmployee();


Input:
void addExtraBipartitionsByInput(ClusterCollection extraClusters, List<Tree> trees, boolean extraTreeRooted) {
    String[] leaves = stTaxa;
    int n = leaves.length;
    for (Tree tr : trees) {
        Map<TNode, STITreeCluster> nodeToSTCluster = new HashMap<TNode, STITreeCluster>(n);
        for (Iterator<TNode> nodeIt = tr.postTraverse().iterator(); nodeIt.hasNext(); ) {
            TNode node = nodeIt.next();
            if (node.isLeaf()) {
                String treeName = node.getName();
                String nodeName = getSpeciesName(treeName);
                STITreeCluster tb = new STITreeCluster();
                tb.addLeaf(nodeName);
                nodeToSTCluster.put(node, tb);
                if (!extraTreeRooted) {
                    throw new RuntimeException("String_Node_Str");
                }
            } else {
                int childCount = node.getChildCount();
                STITreeCluster[] childbslist = new STITreeCluster[childCount];
                BitSet bs = new BitSet(leaves.length);
                int index = 0;
                for (TNode child : node.getChildren()) {
                    childbslist[index++] = nodeToSTCluster.get(child);
                    bs.or(nodeToSTCluster.get(child).getBitSet());
                }
                STITreeCluster cluster = new STITreeCluster();
                cluster.setCluster((BitSet) bs.clone());
                addToClusters(cluster, cluster.getClusterSize(), false);
                nodeToSTCluster.put(node, cluster);
                if (extraTreeRooted) {
                    if (index > 2) {
                        throw new RuntimeException("String_Node_Str" + tr + "String_Node_Str" + node);
                    }
                    STITreeCluster l_cluster = childbslist[0];
                    STITreeCluster r_cluster = childbslist[1];
                    tryAddingSTB(l_cluster, r_cluster, cluster, node, false);
                } else {
                    throw new RuntimeException("String_Node_Str");
                }
            }
        }
    }
    int s = extraClusters.getClusterCount();
    System.err.println("String_Node_Str" + s);
}

Output:
                 STITreeCluster tb = new STITreeCluster();
-                tb.addLeaf(nodeName);
+                tb.addLeaf(GlobalMaps.taxonIdentifier.taxonId(nodeName));
                 nodeToSTCluster.put(node, tb);


Input:
public void readExternal(DataInputStream in, PrototypeFactory pf) throws IOException, DeserializationException {
    frameId = ExtUtil.readString(in);
    steps = (Vector<StackFrameStep>) ExtUtil.read(in, new ExtWrapList(StackFrameStep.class), pf);
    snapshot = (Vector<StackFrameStep>) ExtUtil.read(in, new ExtWrapList(StackFrameStep.class), pf);
    dead = ExtUtil.readBool(in);
}

Output:
 public void readExternal(DataInputStream in, PrototypeFactory pf) throws IOException, DeserializationException {
-    frameId = ExtUtil.readString(in);
+    frameId = (String) ExtUtil.read(in, new ExtWrapNullable(String.class));
     steps = (Vector<StackFrameStep>) ExtUtil.read(in, new ExtWrapList(StackFrameStep.class), pf);


Input:
private void initComponents(final Rules whiteRules, final Rules blackRules) {
    setLayout(new FlowLayout());
    setBorder(BorderFactory.createLoweredBevelBorder());
    final Board[] boards = b.getBoards();
    final Board bShowPiece = new Board(1, 1, false);
    final JPanel showPiece = new JPanel();
    final Piece p = PieceBuilder.makePiece("String_Node_Str", true, bShowPiece.getSquare(1, 1), bShowPiece);
    showPiece.setLayout(new GridLayout(1, 1));
    showPiece.setPreferredSize(new Dimension(50, 50));
    JButton jb1 = new JButton();
    jb1.addActionListener(new SetUpListener(bShowPiece.getSquare(1, 1), bShowPiece));
    bShowPiece.getSquare(1, 1).setButton(jb1);
    showPiece.add(jb1);
    bShowPiece.getSquare(1, 1).refresh();
    final DefaultListModel list = new DefaultListModel();
    Object[] allPieces = PieceBuilder.getSet().toArray();
    for (int i = 0; i < allPieces.length; i++) {
        list.addElement(allPieces[i]);
    }
    list.addElement("String_Node_Str");
    JList piecesList = new JList(list);
    piecesList.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
    piecesList.setLayoutOrientation(JList.VERTICAL);
    piecesList.setVisibleRowCount(-1);
    ListSelectionModel selectList = piecesList.getSelectionModel();
    final Color original = bShowPiece.getSquare(1, 1).getColor();
    selectList.addListSelectionListener(new ListSelectionListener() {
        public void valueChanged(ListSelectionEvent e) {
            ListSelectionModel lsm = (ListSelectionModel) e.getSource();
            int firstIndex = e.getFirstIndex();
            int lastIndex = e.getLastIndex();
            int selection = lsm.getAnchorSelectionIndex();
            if (!lsm.getValueIsAdjusting()) {
                if (((String) list.elementAt(selection)).equals("String_Node_Str")) {
                    bShowPiece.getSquare(1, 1).setPiece(null);
                    bShowPiece.getSquare(1, 1).setBackgroundColor(original);
                    bShowPiece.getSquare(1, 1).setHabitable(true);
                    bShowPiece.getSquare(1, 1).refresh();
                } else {
                    if (bShowPiece.getSquare(1, 1).isHabitable() == false)
                        bShowPiece.getSquare(1, 1).setHabitable(true);
                    if (bShowPiece.getSquare(1, 1).getColor().equals(original) == false)
                        bShowPiece.getSquare(1, 1).setBackgroundColor(original);
                    Piece toAdd = PieceBuilder.makePiece((String) list.elementAt(selection), true, bShowPiece.getSquare(1, 1), bShowPiece);
                    bShowPiece.getSquare(1, 1).setPiece(toAdd);
                    bShowPiece.getSquare(1, 1).refresh();
                }
            }
        }
    });
    JScrollPane scrollPane = new JScrollPane(piecesList);
    scrollPane.setPreferredSize(new Dimension(200, 200));
    for (int n = 0; n < boards.length; n++) {
        final JPanel grid = new JPanel();
        grid.setLayout(new GridLayout(boards[n].numRows(), boards[n].numCols()));
        grid.setPreferredSize(new Dimension(boards[n].numCols() * 48, boards[n].numRows() * 48));
        int numRows = boards[n].numRows();
        int numCols = boards[n].numCols();
        for (int i = numRows; i > 0; i--) {
            for (int j = 1; j <= numCols; j++) {
                JButton jb = new JButton();
                jb.addMouseListener(new SetUpMouseListener(boards[n].getSquare(i, j), boards[n], bShowPiece.getSquare(1, 1)));
                boards[n].getSquare(i, j).setButton(jb);
                grid.add(jb);
                boards[n].getSquare(i, j).refresh();
            }
        }
        add(grid);
    }
    add(scrollPane);
    add(showPiece);
    backButton = new JButton("String_Node_Str");
    backButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Driver.getInstance().setPanel(new PlayerCustomMenu(b, whiteRules, blackRules));
        }
    });
    submitButton = new JButton("String_Node_Str");
    submitButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            b.whiteTeam = whiteTeam;
            boolean set = false;
            for (Piece p : whiteTeam) {
                if (p.getName().equals("String_Node_Str")) {
                    whiteRules.setObjectivePiece(new ObjectivePiece("String_Node_Str", "String_Node_Str"));
                    set = true;
                    break;
                }
            }
            if (!set) {
                whiteRules.setObjectivePiece(new ObjectivePiece("String_Node_Str", "String_Node_Str"));
            }
            b.blackTeam = blackTeam;
            set = false;
            for (Piece p : blackTeam) {
                if (p.getName().equals("String_Node_Str")) {
                    blackRules.setObjectivePiece(new ObjectivePiece("String_Node_Str", "String_Node_Str"));
                    set = true;
                    break;
                }
            }
            if (!set) {
                blackRules.setObjectivePiece(new ObjectivePiece("String_Node_Str", "String_Node_Str"));
            }
            b.writeFile(whiteRules, blackRules);
            Driver.getInstance().revertPanel();
        }
    });
    JPanel options = new JPanel();
    options.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    options.setLayout(new GridBagLayout());
    GridBagConstraints c = new GridBagConstraints();
    c.fill = GridBagConstraints.HORIZONTAL;
    c.gridx = 0;
    c.gridy = 1;
    options.add(submitButton, c);
    c.fill = GridBagConstraints.HORIZONTAL;
    c.gridx = 0;
    c.gridy = 2;
    options.add(backButton, c);
    add(options);
}

Output:
     JButton jb1 = new JButton();
-    jb1.addActionListener(new SetUpListener(bShowPiece.getSquare(1, 1), bShowPiece));
+    jb1.addActionListener(new SetUpListener(bShowPiece.getSquare(1, 1)));
     bShowPiece.getSquare(1, 1).setButton(jb1);


Input:
public void execute(OperationContext ctx) {
    VariableStack stack = ctx.getStack();
    WideVariable top = stack.popWide();
    WideVariable next = stack.popWide();
    stack.pushWide(top);
    stack.pushWide(next);
    stack.pushWide(top);
}

Output:
     VariableStack stack = ctx.getStack();
-    WideVariable top = stack.popWide();
-    WideVariable next = stack.popWide();
-    stack.pushWide(top);
-    stack.pushWide(next);
-    stack.pushWide(top);
+    if (stack.peekType().isDoubleWidth()) {
+        WideVariable top = stack.popWide();
+        Variable next = popSingleWidth(stack);
+        stack.pushWide(top);
+        stack.push(next);
+        stack.pushWide(top);
+    } else {
+        Variable one = popSingleWidth(stack);
+        Variable two = popSingleWidth(stack);
+        Variable three = popSingleWidth(stack);
+        stack.push(two);
+        stack.push(one);
+        stack.push(three);
+        stack.push(two);
+        stack.push(one);
+    }
 }


Input:
private Object loadObject() throws Exception {
    Object result = null;
    for (Addon addon : registry.getAddons(AddonFilters.allLoaded())) {
        if (ClassLoaders.containsClass(addon.getClassLoader(), serviceType)) {
            Addons.waitUntilStarted(addon);
            ServiceRegistry serviceRegistry = addon.getServiceRegistry();
            if (serviceRegistry.hasService(serviceType)) {
                ExportedInstance<?> instance = serviceRegistry.getExportedInstance(serviceType);
                Assert.notNull(instance, "String_Node_Str" + serviceType.getName() + "String_Node_Str" + addon.getId() + "String_Node_Str");
                if (instance instanceof ExportedInstanceImpl)
                    result = ((ExportedInstanceImpl<?>) instance).get(new LocalServiceInjectionPoint(injectionPoint, serviceType));
                else
                    result = instance.get();
                break;
            }
        }
    }
    if (result == null) {
        throw new IllegalStateException("String_Node_Str" + serviceType.getName() + "String_Node_Str");
    }
    return result;
}

Output:
             Addons.waitUntilStarted(addon);
-            ServiceRegistry serviceRegistry = addon.getServiceRegistry();
-            if (serviceRegistry.hasService(serviceType)) {
-                ExportedInstance<?> instance = serviceRegistry.getExportedInstance(serviceType);
-                Assert.notNull(instance, "String_Node_Str" + serviceType.getName() + "String_Node_Str" + addon.getId() + "String_Node_Str");
-                if (instance instanceof ExportedInstanceImpl)
-                    result = ((ExportedInstanceImpl<?>) instance).get(new LocalServiceInjectionPoint(injectionPoint, serviceType));
-                else
-                    result = instance.get();
-                break;
+            if (!addon.getStatus().isFailed()) {
+                ServiceRegistry serviceRegistry = addon.getServiceRegistry();
+                if (serviceRegistry.hasService(serviceType)) {
+                    ExportedInstance<?> instance = serviceRegistry.getExportedInstance(serviceType);
+                    Assert.notNull(instance, "String_Node_Str" + serviceType.getName() + "String_Node_Str" + addon.getId() + "String_Node_Str");
+                    if (instance instanceof ExportedInstanceImpl)
+                        result = ((ExportedInstanceImpl<?>) instance).get(new LocalServiceInjectionPoint(injectionPoint, serviceType));
+                    else
+                        result = instance.get();
+                    break;
+                }
             }


Input:
public int graphImporterParser(String[] args) throws TaxonNotFoundException, DataFormatException, TreeIngestException {
    boolean readingNewick = false;
    boolean readingNexson = false;
    if (args[0].compareTo("String_Node_Str") == 0) {
        readingNewick = true;
    }
    if (args[0].compareTo("String_Node_Str") == 0) {
        readingNexson = true;
    } else {
        return 2;
    }
    String filename;
    String idfilename = "String_Node_Str";
    String focalgroup;
    String sourcename;
    String graphname;
    if (readingNewick) {
        if (args.length != 6) {
            System.out.println("String_Node_Str");
            return 1;
        }
        filename = args[1];
        idfilename = args[2];
        focalgroup = args[3];
        sourcename = args[4];
        graphname = args[5];
    } else {
        if (args.length != 5) {
            System.out.println("String_Node_Str");
            return 1;
        }
        filename = args[1];
        focalgroup = args[2];
        sourcename = args[3];
        graphname = args[4];
    }
    int treeCounter = 0;
    GraphImporter gi = new GraphImporter(graphname);
    try {
        if (gi.hasSoureTreeName(sourcename)) {
            String emsg = "String_Node_Str" + sourcename + "String_Node_Str";
            throw new TreeIngestException(emsg);
        }
        System.out.println("String_Node_Str" + filename);
        ArrayList<JadeTree> jt = new ArrayList<JadeTree>();
        try {
            if (readingNewick) {
                System.out.println("String_Node_Str");
                TreeReader tr = new TreeReader();
                BufferedReader ibr = new BufferedReader(new FileReader(idfilename));
                String treeID;
                String ts = "String_Node_Str";
                BufferedReader br = new BufferedReader(new FileReader(filename));
                int treeNum = 0;
                while ((ts = br.readLine()) != null) {
                    if (ts.length() > 1) {
                        ++treeNum;
                        treeID = "String_Node_Str";
                        while (treeID.length() == 0) {
                            if (null == (treeID = ibr.readLine())) {
                                String emsg = "String_Node_Str" + filename + "String_Node_Str" + treeNum + "String_Node_Str" + idfilename + "String_Node_Str";
                                throw new TreeIngestException(emsg);
                            }
                        }
                        JadeTree newestTree = tr.readTree(ts);
                        newestTree.assocObject("String_Node_Str", treeID);
                        jt.add(newestTree);
                        treeCounter++;
                    }
                }
                br.close();
            } else {
                System.out.println("String_Node_Str");
                for (JadeTree tree : NexsonReader.readNexson(filename)) {
                    jt.add(tree);
                    treeCounter++;
                }
            }
        } catch (IOException ioe) {
        }
        System.out.println(treeCounter + "String_Node_Str");
        for (int i = 0; i < jt.size(); i++) {
            System.out.println("String_Node_Str" + i);
            gi.setTree(jt.get(i));
            if (jt.get(i).getObject("String_Node_Str") != null) {
                sourcename = (String) jt.get(i).getObject("String_Node_Str");
            }
            if (jt.size() == 1) {
                gi.addSetTreeToGraph(focalgroup, sourcename);
                gi.updateAfterTreeIngest(false);
            } else {
                gi.addSetTreeToGraph(focalgroup, sourcename + "String_Node_Str" + String.valueOf(i));
                gi.deleteTreeBySource(sourcename + "String_Node_Str" + String.valueOf(i));
            }
        }
        if (jt.size() > 1) {
            for (int i = 0; i < jt.size(); i++) {
                if (jt.get(i).getObject("String_Node_Str") != null) {
                    sourcename = (String) jt.get(i).getObject("String_Node_Str");
                }
                System.out.println("String_Node_Str" + i);
                gi.setTree(jt.get(i));
                gi.addSetTreeToGraph(focalgroup, sourcename + "String_Node_Str" + String.valueOf(i));
            }
        }
    } finally {
        gi.shutdownDB();
    }
    return 0;
}

Output:
         readingNewick = true;
-    }
-    if (args[0].compareTo("String_Node_Str") == 0) {
+    } else if (args[0].compareTo("String_Node_Str") == 0) {
         readingNexson = true;


Input:
public String execute() throws Exception {
    HttpServletRequest request = ServletActionContext.getRequest();
    String token = (String) request.getSession().getAttribute("String_Node_Str");
    if (token != null) {
        WebApplicationContext context = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletActionContext.getServletContext());
        CampusConnection campusConnection = (CampusConnection) context.getBean("String_Node_Str");
        campusConnection.setCampusSession(token);
        bUOC.setCampusConnection(campusConnection);
    }
    UserInformation userInfo = bUOC.getUserInformation();
    if (userInfo != null) {
        listSubjects = bUOC.getUserSubjects();
        if (s_assign != null) {
            String[] infoAssing = s_assign.split("String_Node_Str");
            teacher = bUOC.isTeacher(new UOCSubject(infoAssing[0], infoAssing[2]));
            listClassroms = bUOC.getUserClassrooms(new UOCSubject(infoAssing[0], infoAssing[2]));
        }
        if (s_aula != null && s_aula.length() > 0 && s_assign != null) {
            String[] infoAssing = s_assign.split("String_Node_Str");
            listActivity = bUOC.getSubjectActivities(new UOCSubject(infoAssing[0], infoAssing[2]));
        }
        if (s_aula != null && s_aula.length() > 0 && s_assign != null && s_activ != null && s_activ.length() > 0) {
            Activity objActivity = new Activity();
            for (int j = 0; j < listActivity.length; j++) {
                if (listActivity[j].getIndex() == Integer.parseInt(s_activ)) {
                    objActivity = listActivity[j];
                }
            }
            String[] infoAssing = s_assign.split("String_Node_Str");
            if (teacher) {
                UOCClassroom objClassroom = null;
                for (int i = 0; i < listClassroms.length; i++) {
                    if (listClassroms[i].getIndex() == Integer.parseInt(s_aula)) {
                        objClassroom = listClassroms[i];
                    }
                }
                listDeliverDetails = bUOC.getLastClassroomDeliverDetails(objActivity, objClassroom);
                if (listDeliverDetails != null && listDeliverDetails.length > 0)
                    maxDelivers = String.valueOf(listDeliverDetails[0].getMaxDelivers());
            } else {
                listDeliverDetails = bUOC.getUserDeliverDetails(new UOCSubject(infoAssing[0], infoAssing[2]), objActivity.getIndex());
                if (listDeliverDetails.length > 0 && listDeliverDetails != null)
                    maxDelivers = String.valueOf(listDeliverDetails[0].getMaxDelivers());
            }
        }
        imageURL = userInfo.getUserPhoto();
        if (imageURL == null)
            imageURL = "String_Node_Str";
        fullName = userInfo.getUserFullName();
    } else {
        imageURL = null;
        fullName = null;
    }
    String toReturn = SUCCESS;
    if (TAB_PROGRAMMING_ENVIROMENT.equals(activeTab)) {
        toReturn = TAB_PROGRAMMING_ENVIROMENT;
    }
    return toReturn;
}

Output:
                 listDeliverDetails = bUOC.getLastClassroomDeliverDetails(objActivity, objClassroom);
-                if (listDeliverDetails != null && listDeliverDetails.length > 0)
-                    maxDelivers = String.valueOf(listDeliverDetails[0].getMaxDelivers());
+                if (listDeliverDetails != null && listDeliverDetails.length > 0) {
+                    int cont = 0;
+                    Boolean exit = false;
+                    while (!exit) {
+                        if (listDeliverDetails[cont] != null) {
+                            maxDelivers = String.valueOf(listDeliverDetails[cont].getMaxDelivers());
+                            exit = true;
+                        }
+                        cont++;
+                    }
+                }
             } else {


Input:
private String typeForElement(Object o) {
    return o == null ? "String_Node_Str" : fst.getClass().getName();
}

Output:
 private String typeForElement(Object o) {
-    return o == null ? "String_Node_Str" : fst.getClass().getName();
+    return o == null ? "String_Node_Str" : o.getClass().getName();
 }


Input:
public DateFormat get() {
    if (timeZoneHolder != null) {
        TimeZone tz = timeZoneHolder.getTimeZone();
        if (tz != null && !simpleDateFormat.getTimeZone().equals(tz)) {
            simpleDateFormat.setTimeZone(tz);
        }
    }
    return super.get();
}

Output:
     }
-    return super.get();
+    return simpleDateFormat;
 }


Input:
void excise(Enclosure enc, int tabno, String diagfn) {
    clla = new LinkedList<Arrow>();
    Diagram oldDiag = enc.diag;
    driver.curDiag = this;
    maxBlockNo = Math.max(oldDiag.maxBlockNo, enc.id);
    enc.calcEdges();
    findEnclosedBlocksAndArrows(enc);
    for (Block b : enc.llb) {
        blocks.put(new Integer(b.id), b);
        changed = true;
    }
    for (Arrow a : enc.lla) {
        Arrow arr2 = a.makeCopy(this);
        arrows.put(new Integer(arr2.id), arr2);
        changed = true;
    }
    findCrossingArrows(enc);
    if (enc.lla != null) {
        for (Arrow arrow : enc.lla) {
            oldDiag.delArrow(arrow);
        }
        enc.lla = null;
    }
    boolean NOCHOOSE = false;
    if (enc.llb != null) {
        for (Block block : enc.llb) {
            oldDiag.delBlock(block, NOCHOOSE);
        }
        enc.llb = null;
    }
    for (Arrow arrow : arrows.values()) {
        Block from = blocks.get(new Integer(arrow.fromId));
        Block to = blocks.get(new Integer(arrow.toId));
        if (from == null) {
            ExtPortBlock eb = new ExtPortBlock(this);
            eb.cx = arrow.fromX - eb.width / 2;
            eb.cy = arrow.fromY;
            eb.type = Block.Types.EXTPORT_IN_BLOCK;
            maxBlockNo++;
            eb.id = maxBlockNo;
            arrow.fromId = eb.id;
            if (enc.subnetPorts != null) {
                for (SubnetPort snp : enc.subnetPorts) {
                    if (snp.side == Side.LEFT && arrow.toY == snp.y) {
                        eb.substreamSensitive = snp.substreamSensitive;
                        eb.description = snp.name;
                    }
                }
            }
            blocks.put(new Integer(arrow.fromId), eb);
            eb.calcEdges();
        }
        if (to == null) {
            ExtPortBlock eb = new ExtPortBlock(this);
            eb.cx = arrow.toX + eb.width / 2;
            eb.cy = arrow.toY;
            eb.type = Block.Types.EXTPORT_OUT_BLOCK;
            maxBlockNo++;
            eb.id = maxBlockNo;
            arrow.toId = eb.id;
            if (enc.subnetPorts != null) {
                for (SubnetPort snp : enc.subnetPorts) {
                    if (snp.side == Side.RIGHT && arrow.toY == snp.y) {
                        eb.substreamSensitive = snp.substreamSensitive;
                        eb.description = snp.name;
                    }
                }
            }
            blocks.put(new Integer(arrow.toId), eb);
            eb.calcEdges();
        }
    }
    Block block = new ProcessBlock(oldDiag);
    block.cx = oldDiag.xa;
    block.cy = oldDiag.ya;
    block.calcEdges();
    oldDiag.maxBlockNo++;
    block.id = oldDiag.maxBlockNo;
    oldDiag.blocks.put(new Integer(block.id), block);
    oldDiag.changed = true;
    driver.selBlock = block;
    block.diagramFileName = diagfn;
    block.isSubnet = true;
    block.description = enc.description;
    enc.description = "String_Node_Str";
    desc = block.description;
    if (desc != null)
        desc = desc.replace('\n', ' ');
    block.cx = enc.cx;
    block.cy = enc.cy;
    block.calcEdges();
    driver.frame.repaint();
    Integer aid;
    for (Arrow arrow : clla) {
        aid = new Integer(arrow.id);
        oldDiag.arrows.put(aid, arrow);
        Block from = oldDiag.blocks.get(new Integer(arrow.fromId));
        Block to = oldDiag.blocks.get(new Integer(arrow.toId));
        if (to == null) {
            arrow.toId = block.id;
            Side side = findQuadrant(arrow.fromX, arrow.fromY, block);
            if (side != null) {
                if (side == Side.TOP) {
                    arrow.toY = block.cy - block.height / 2;
                    arrow.toX = block.cx;
                } else {
                    arrow.toX = block.cx - block.width / 2;
                    arrow.toY = block.cy;
                }
            }
        }
        if (from == null) {
            arrow.fromId = block.id;
            Side side = findQuadrant(arrow.toX, arrow.toY, block);
            if (side != null) {
                if (side == Side.BOTTOM) {
                    arrow.fromY = block.cy + block.height / 2;
                    arrow.fromX = block.cx;
                } else {
                    arrow.fromX = block.cx + block.width / 2;
                    arrow.fromY = block.cy;
                }
            }
        }
    }
}

Output:
             arrow.fromId = eb.id;
-            if (enc.subnetPorts != null) {
-                for (SubnetPort snp : enc.subnetPorts) {
-                    if (snp.side == Side.LEFT && arrow.toY == snp.y) {
-                        eb.substreamSensitive = snp.substreamSensitive;
-                        eb.description = snp.name;
-                    }
+            eb.description = arrow.downStreamPort;
+            for (SubnetPort snp : enc.subnetPorts) {
+                if (snp.side == Side.LEFT && arrow.toY == snp.y) {
+                    eb.substreamSensitive = snp.substreamSensitive;
+                    eb.description = snp.name;
                 }


Input:
public Date getTime() {
    return new Date(getTimeSeconds());
}

Output:
 public Date getTime() {
-    return new Date(getTimeSeconds());
+    return new Date(getTimeSeconds() * 1000);
 }


Input:
public void setListener(ChannelID mq, MessageListener ml) throws IOFailure {
    ArgumentNotValid.checkNotNull(mq, "String_Node_Str");
    ArgumentNotValid.checkNotNull(ml, "String_Node_Str");
    log.debug("String_Node_Str" + ml.toString() + "String_Node_Str" + mq.toString());
    String errMsg = "String_Node_Str" + mq.getName();
    String key = getConsumerKey(mq, ml);
    int tries = 0;
    boolean operationSuccessful = false;
    JMSException lastException = null;
    while (!operationSuccessful || tries < JMS_MAXTRIES) {
        tries++;
        try {
            if (mq.isTopic()) {
                TopicSubscriber myTopicSubscriber = myTSess.createSubscriber(getTopic(mq.getName()));
                myTopicSubscriber.setMessageListener(ml);
                if (consumers.get(key) == null) {
                    consumers.put(key, myTopicSubscriber);
                }
            } else {
                Queue queue = getQueue(mq.getName());
                QueueReceiver myQueueReceiver = myQSess.createReceiver(queue);
                myQueueReceiver.setMessageListener(ml);
                if (consumers.get(key) == null) {
                    consumers.put(key, myQueueReceiver);
                }
            }
            operationSuccessful = true;
        } catch (JMSException e) {
            lastException = e;
            log.warn(errMsg, e);
        }
    }
    if (!operationSuccessful) {
        throw new IOFailure(errMsg, lastException);
    }
}

Output:
     JMSException lastException = null;
-    while (!operationSuccessful || tries < JMS_MAXTRIES) {
+    while (!operationSuccessful && tries < JMS_MAXTRIES) {
         tries++;


Input:
public RepeatStatus executeStep(ChunkContext chunkContext, JobExecutionStatusHolder jobExecutionStatusHolder) throws Exception {
    String targetName = getJobParameters(chunkContext).getString(JobConstants.TARGET_NAME_JOB_PARAM);
    String clusterName = getJobParameters(chunkContext).getString(JobConstants.CLUSTER_NAME_JOB_PARAM);
    if (targetName == null) {
        targetName = clusterName;
    }
    String jobName = chunkContext.getStepContext().getJobName();
    logger.info("String_Node_Str" + targetName + "String_Node_Str" + managementOperation + "String_Node_Str" + jobName);
    if (!serviceSyncup.isClusterInQueue(clusterName)) {
        serviceSyncup.syncUp(clusterName);
        logger.info("String_Node_Str" + clusterName);
    }
    boolean vmPowerOn = false;
    String vmPowerOnStr = getJobParameters(chunkContext).getString(JobConstants.IS_VM_POWER_ON);
    if (vmPowerOnStr != null) {
        logger.info("String_Node_Str" + vmPowerOnStr);
        vmPowerOn = Boolean.parseBoolean(vmPowerOnStr);
    }
    if (checkVMStatus && targetName.split("String_Node_Str").length == 3 && !vmPowerOn) {
        return RepeatStatus.FINISHED;
    }
    SoftwareManager softwareMgr = softwareMgrs.getSoftwareManagerByClusterName(clusterName);
    if (ManagementOperation.CONFIGURE.equals(managementOperation) || JobConstants.RESUME_CLUSTER_JOB_NAME.equals(jobName)) {
        logger.info("String_Node_Str");
        List<NodeEntity> nodes = lockClusterEntityMgr.getClusterEntityMgr().findAllNodes(clusterName);
        Set<String> hostnames = new HashSet<String>();
        for (NodeEntity node : nodes) {
            hostnames.add(node.getHostName());
        }
        ClusterCreate clusterSpec = clusterManager.getClusterSpec(clusterName);
        SyncHostsUtils.SyncHosts(clusterSpec, hostnames, softwareMgr);
    }
    StatusUpdater statusUpdater = new DefaultStatusUpdater(jobExecutionStatusHolder, getJobExecutionId(chunkContext));
    ISoftwareManagementTask task = null;
    if (!Constants.IRONFAN.equals(softwareMgr.getName())) {
        task = createExternalTask(chunkContext, targetName, clusterName, statusUpdater);
    } else {
        task = createThriftTask(chunkContext, targetName, statusUpdater);
    }
    if (task != null) {
        Map<String, Object> ret = task.call();
        if (!(Boolean) ret.get("String_Node_Str")) {
            String errorMessage = (String) ret.get("String_Node_Str");
            putIntoJobExecutionContext(chunkContext, JobConstants.CURRENT_ERROR_MESSAGE, errorMessage);
            throw TaskException.EXECUTION_FAILED(errorMessage);
        }
    }
    return RepeatStatus.FINISHED;
}

Output:
     logger.info("String_Node_Str" + targetName + "String_Node_Str" + managementOperation + "String_Node_Str" + jobName);
-    if (!serviceSyncup.isClusterInQueue(clusterName)) {
-        serviceSyncup.syncUp(clusterName);
-        logger.info("String_Node_Str" + clusterName);
-    }
+    serviceSyncup.syncUp(clusterName);
+    logger.debug("String_Node_Str" + clusterName);
     boolean vmPowerOn = false;


Input:
public void testGetParamType() {
    SQLExecutor sqlExecutor = SQLExecutor.builder(clusterService).build();
    DependencyCarrier executor = Mockito.mock(DependencyCarrier.class);
    Session session = new Session(sqlExecutor.analyzer, sqlExecutor.planner, new JobsLogs(() -> false), false, executor, SessionContext.create());
    session.parse("String_Node_Str", "String_Node_Str", Collections.emptyList());
    assertThat(session.getParamType("String_Node_Str", 0), is(DataTypes.UNDEFINED));
    assertThat(session.getParamType("String_Node_Str", 2), is(DataTypes.UNDEFINED));
    Session.DescribeResult describe = session.describe('S', "String_Node_Str");
    assertThat(describe.getParameters(), equalTo(new DataType[] { DataTypes.LONG, DataTypes.LONG }));
    assertThat(session.getParamType("String_Node_Str", 0), is(DataTypes.LONG));
    assertThat(session.getParamType("String_Node_Str", 1), is(DataTypes.LONG));
    expectedException.expect(IllegalStateException.class);
    expectedException.expectMessage("String_Node_Str");
    assertThat(session.getParamType("String_Node_Str", 3), is(DataTypes.UNDEFINED));
}

Output:
     SQLExecutor sqlExecutor = SQLExecutor.builder(clusterService).build();
-    DependencyCarrier executor = Mockito.mock(DependencyCarrier.class);
+    DependencyCarrier executor = mock(DependencyCarrier.class);
     Session session = new Session(sqlExecutor.analyzer, sqlExecutor.planner, new JobsLogs(() -> false), false, executor, SessionContext.create());


Input:
private Collection filterModules(Collection mds, ModuleDescriptor rootmd) {
    Map moduleIdMap = new HashMap();
    for (Iterator iter = mds.iterator(); iter.hasNext(); ) {
        ModuleDescriptor md = ((ModuleDescriptor) iter.next());
        moduleIdMap.put(md.getModuleRevisionId().getModuleId(), md);
    }
    Collection toKeep = new ArrayList();
    processFilterNode(rootmd, toKeep, moduleIdMap);
    for (Iterator iter = toKeep.iterator(); iter.hasNext(); ) {
        ModuleDescriptor md = ((ModuleDescriptor) iter.next());
        Message.verbose("String_Node_Str" + md.getModuleRevisionId().getModuleId().getName());
    }
    return toKeep;
}

Output:
     }
-    Collection toKeep = new ArrayList();
+    Set toKeep = new HashSet();
     processFilterNode(rootmd, toKeep, moduleIdMap);


Input:
protected static String buildCacheKey(IContentListBean bean, Collection<String> userGroupCodes) {
    StringBuilder cacheKey = new StringBuilder();
    if (null != bean.getListName()) {
        cacheKey.append("String_Node_Str").append(bean.getListName());
    }
    if (null != bean.getContentType()) {
        cacheKey.append("String_Node_Str").append(bean.getContentType());
    }
    List<String> groupCodes = new ArrayList<String>(userGroupCodes);
    if (!groupCodes.contains(Group.FREE_GROUP_NAME)) {
        groupCodes.add(Group.FREE_GROUP_NAME);
    }
    Collections.sort(groupCodes);
    for (int i = 0; i < groupCodes.size(); i++) {
        if (i == 0) {
            cacheKey.append("String_Node_Str");
        }
        String code = groupCodes.get(i);
        cacheKey.append("String_Node_Str").append(code);
    }
    if (null != bean.getCategories()) {
        List<String> categoryCodes = Arrays.asList(bean.getCategories());
        Collections.sort(categoryCodes);
        for (int j = 0; j < categoryCodes.size(); j++) {
            if (j == 0) {
                cacheKey.append("String_Node_Str");
            }
            String code = categoryCodes.get(j);
            cacheKey.append("String_Node_Str").append(code);
        }
    }
    if (null != bean.getFilters()) {
        for (int k = 0; k < bean.getFilters().length; k++) {
            if (k == 0) {
                cacheKey.append("String_Node_Str");
            }
            EntitySearchFilter filter = bean.getFilters()[k];
            cacheKey.append("String_Node_Str").append(filter.toString());
        }
    }
    return cacheKey.toString();
}

Output:
 protected static String buildCacheKey(IContentListBean bean, Collection<String> userGroupCodes) {
-    StringBuilder cacheKey = new StringBuilder();
-    if (null != bean.getListName()) {
-        cacheKey.append("String_Node_Str").append(bean.getListName());
-    }
-    if (null != bean.getContentType()) {
-        cacheKey.append("String_Node_Str").append(bean.getContentType());
-    }
-    List<String> groupCodes = new ArrayList<String>(userGroupCodes);
-    if (!groupCodes.contains(Group.FREE_GROUP_NAME)) {
-        groupCodes.add(Group.FREE_GROUP_NAME);
-    }
-    Collections.sort(groupCodes);
-    for (int i = 0; i < groupCodes.size(); i++) {
-        if (i == 0) {
-            cacheKey.append("String_Node_Str");
-        }
-        String code = groupCodes.get(i);
-        cacheKey.append("String_Node_Str").append(code);
-    }
-    if (null != bean.getCategories()) {
-        List<String> categoryCodes = Arrays.asList(bean.getCategories());
-        Collections.sort(categoryCodes);
-        for (int j = 0; j < categoryCodes.size(); j++) {
-            if (j == 0) {
-                cacheKey.append("String_Node_Str");
-            }
-            String code = categoryCodes.get(j);
-            cacheKey.append("String_Node_Str").append(code);
-        }
-    }
-    if (null != bean.getFilters()) {
-        for (int k = 0; k < bean.getFilters().length; k++) {
-            if (k == 0) {
-                cacheKey.append("String_Node_Str");
-            }
-            EntitySearchFilter filter = bean.getFilters()[k];
-            cacheKey.append("String_Node_Str").append(filter.toString());
-        }
-    }
-    return cacheKey.toString();
+    return buildStringBuilderCacheKey(bean, userGroupCodes).toString();
 }


Input:
protected JSONObject getExpectedParameters(int sdlVersion) {
    JSONObject result = new JSONObject();
    JSONObject coordJsonObject, eventJsonObject;
    JSONArray eventJsonArray = new JSONArray();
    try {
        coordJsonObject = new JSONObject();
        eventJsonObject = new JSONObject();
        coordJsonObject.put(TouchCoord.KEY_X, X_1);
        coordJsonObject.put(TouchCoord.KEY_Y, Y_1);
        eventJsonObject.put(TouchEvent.KEY_C, coordJsonObject);
        eventJsonObject.put(TouchEvent.KEY_ID, ID_1);
        eventJsonObject.put(TouchEvent.KEY_TS, TIMESTAMP_1);
        eventJsonArray.put(eventJsonObject);
        coordJsonObject = new JSONObject();
        eventJsonObject = new JSONObject();
        coordJsonObject.put(TouchCoord.KEY_X, X_2);
        coordJsonObject.put(TouchCoord.KEY_Y, Y_2);
        eventJsonObject.put(TouchEvent.KEY_C, coordJsonObject);
        eventJsonObject.put(TouchEvent.KEY_ID, ID_2);
        eventJsonObject.put(TouchEvent.KEY_TS, TIMESTAMP_2);
        eventJsonArray.put(eventJsonObject);
        result.put(OnTouchEvent.KEY_TYPE, TOUCH_TYPE);
        result.put(OnTouchEvent.KEY_EVENT, eventJsonArray);
    } catch (JSONException e) {
    }
    return result;
}

Output:
     JSONObject coordJsonObject, eventJsonObject;
-    JSONArray eventJsonArray = new JSONArray();
+    JSONArray eventJsonArray = new JSONArray(), tsArray = new JSONArray();
     try {


Input:
private void matchRecurse(int solve) {
    if (solve == getRule().operands.size()) {
        if (getRule().matches(this)) {
            onMatch();
        }
    } else {
        int operandOrdinal = getOperand0().solveOrder[solve];
        int previousOperandOrdinal = getOperand0().solveOrder[solve - 1];
        boolean ascending = operandOrdinal < previousOperandOrdinal;
        RelOptRuleOperand previousOperand = getRule().operands.get(previousOperandOrdinal);
        RelOptRuleOperand operand = getRule().operands.get(operandOrdinal);
        List<RelNode> successors;
        if (ascending) {
            assert (previousOperand.getParent() == operand);
            final RelNode childRel = rels[previousOperandOrdinal];
            RelSubset subset = volcanoPlanner.getSubset(childRel);
            successors = subset.getParentRels();
        } else {
            int parentOrdinal = operand.getParent().ordinalInRule;
            RelNode parentRel = rels[parentOrdinal];
            List<RelNode> inputs = parentRel.getInputs();
            if (operand.ordinalInParent < inputs.size()) {
                RelSubset subset = (RelSubset) inputs.get(operand.ordinalInParent);
                successors = subset.getRelList();
            } else {
                successors = Collections.emptyList();
            }
        }
        for (RelNode rel : successors) {
            if (!operand.matches(rel)) {
                continue;
            }
            if (ascending) {
                final RelSubset input = (RelSubset) rel.getInput(previousOperand.ordinalInParent);
                List<RelNode> inputRels = input.set.getRelsFromAllSubsets();
                if (!inputRels.contains(rels[previousOperandOrdinal])) {
                    continue;
                }
            }
            rels[operandOrdinal] = rel;
            matchRecurse(solve + 1);
        }
    }
}

Output:
         RelOptRuleOperand operand = getRule().operands.get(operandOrdinal);
-        List<RelNode> successors;
+        Collection<RelNode> successors;
         if (ascending) {


Input:
public static String read(StreamSourceChannel channel) throws IOException {
    StringBuilder content = new StringBuilder();
    ByteBuffer buf = ByteBuffer.allocate(128);
    while (Channels.readBlocking(channel, buf) != -1) {
        buf.flip();
        content.append(charset.decode(buf));
        buf.clear();
    }
    return content.toString();
}

Output:
 public static String read(StreamSourceChannel channel) throws IOException {
-    StringBuilder content = new StringBuilder();
-    ByteBuffer buf = ByteBuffer.allocate(128);
+    final int capacity = 1024;
+    ByteArrayOutputStream os = new ByteArrayOutputStream(capacity);
+    ByteBuffer buf = ByteBuffer.allocate(capacity);
     while (Channels.readBlocking(channel, buf) != -1) {


Input:
protected String generateQueryIfApplicable(SearchRequest searchRequest, String query) throws IndexerSearchAbortedException {
    if (searchRequest.getQuery().isPresent()) {
        return searchRequest.getQuery().get();
    }
    boolean indexerDoesntSupportRequiredSearchType = config.getSupportedSearchTypes().stream().noneMatch(x -> searchRequest.getSearchType().matches(x));
    boolean indexerDoesntSupportAnyOfTheProvidedIds = searchRequest.getIdentifiers().keySet().stream().noneMatch(x -> config.getSupportedSearchIds().contains(x));
    boolean queryGenerationPossible = !searchRequest.getIdentifiers().isEmpty() || searchRequest.getTitle().isPresent();
    boolean queryGenerationEnabled = configProvider.getBaseConfig().getSearching().getGenerateQueries().meets(searchRequest.getSource()) || searchRequest.getInternalData().getFallbackState() == FallbackState.REQUESTED;
    if (!(queryGenerationPossible && queryGenerationEnabled && (indexerDoesntSupportAnyOfTheProvidedIds || indexerDoesntSupportRequiredSearchType))) {
        logger.debug("String_Node_Str");
        return query;
    }
    if (searchRequest.getInternalData().getFallbackState() == FallbackState.REQUESTED) {
        searchRequest.getInternalData().setFallbackState(FallbackState.USED);
    }
    if (searchRequest.getTitle().isPresent()) {
        query = sanitizeTitleForQuery(searchRequest.getTitle().get());
        logger.debug("String_Node_Str", query);
    } else if (searchRequest.getInternalData().getTitle().isPresent()) {
        query = searchRequest.getInternalData().getTitle().get();
    } else {
        Entry<IdType, String> firstIdentifierEntry = searchRequest.getIdentifiers().entrySet().iterator().next();
        try {
            MediaInfo mediaInfo = infoProvider.convert(firstIdentifierEntry.getValue(), firstIdentifierEntry.getKey());
            if (!mediaInfo.getTitle().isPresent()) {
                throw new IndexerSearchAbortedException("String_Node_Str");
            }
            query = sanitizeTitleForQuery(mediaInfo.getTitle().get());
            logger.debug("String_Node_Str", query);
        } catch (InfoProviderException e) {
            throw new IndexerSearchAbortedException("String_Node_Str");
        }
    }
    if (searchRequest.getSeason().isPresent()) {
        if (searchRequest.getEpisode().isPresent()) {
            logger.debug("String_Node_Str", searchRequest.getSeason().get(), searchRequest.getEpisode().get());
            try {
                int episodeInt = Integer.parseInt(searchRequest.getEpisode().get());
                query += String.format("String_Node_Str", searchRequest.getSeason().get(), episodeInt);
            } catch (NumberFormatException e) {
                String extendWith = String.format("String_Node_Str", searchRequest.getSeason().get()) + searchRequest.getEpisode().get();
                query += extendWith;
                logger.debug("String_Node_Str", searchRequest.getEpisode().get(), extendWith);
            }
        } else {
            logger.debug("String_Node_Str", searchRequest.getSeason().get());
            query += String.format("String_Node_Str", searchRequest.getSeason().get());
        }
    }
    if (searchRequest.getSearchType() == SearchType.BOOK && !config.getSupportedSearchTypes().contains(ActionAttribute.BOOK)) {
        if (searchRequest.getAuthor().isPresent()) {
            query += "String_Node_Str" + searchRequest.getAuthor().get();
            logger.debug("String_Node_Str", searchRequest.getAuthor().get());
        }
    }
    info("String_Node_Str" + query);
    return query;
}

Output:
     if (!(queryGenerationPossible && queryGenerationEnabled && (indexerDoesntSupportAnyOfTheProvidedIds || indexerDoesntSupportRequiredSearchType))) {
-        logger.debug("String_Node_Str");
+        debug("String_Node_Str");
         return query;


Input:
public void copyToBuffer(final Buffer destinationBuffer) throws IOException {
    if (destinationBuffer.isBackedByMemory()) {
        final long tbr = this.totalBytesRead;
        if (this.fileChannel != null) {
            this.fileBufferManager.releaseFileChannelForReading(this.gateID, this.fileID, false);
        }
        this.totalBytesRead = 0;
        destinationBuffer.write(this);
        destinationBuffer.finishWritePhase();
        this.fileBufferManager.releaseFileChannelForReading(this.gateID, this.fileID, false);
        this.fileChannel = null;
        this.totalBytesRead = tbr;
        return;
    }
    throw new UnsupportedOperationException("String_Node_Str");
}

Output:
         if (this.fileChannel != null) {
-            this.fileBufferManager.releaseFileChannelForReading(this.gateID, this.fileID, false);
+            this.fileBufferManager.releaseFileChannelForReading(this.gateID, this.fileID);
         }


Input:
public static void fillElement(Element e, JSONObject elementInfo, Stereotype view, Stereotype viewpoint) {
    if (e instanceof Package) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
    } else if (e instanceof Property) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
        elementInfo.put("String_Node_Str", ((Property) e).isDerived());
        elementInfo.put("String_Node_Str", false);
        ValueSpecification vs = ((Property) e).getDefaultValue();
        if (vs != null) {
            elementInfo.put("String_Node_Str", makeJsonArrayOfIDs(Collections.singletonList(vs)));
        }
        Type type = ((Property) e).getType();
        if (type != null) {
            elementInfo.put("String_Node_Str", "String_Node_Str" + type.getID());
        } else
            elementInfo.put("String_Node_Str", "String_Node_Str");
    } else if (e instanceof Slot) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
        elementInfo.put("String_Node_Str", false);
        elementInfo.put("String_Node_Str", true);
        if (((Slot) e).getDefiningFeature().getID().equals("String_Node_Str"))
            elementInfo.put("String_Node_Str", true);
        List<ValueSpecification> vsl = ((Slot) e).getValue();
        if (vsl != null && vsl.size() > 0) {
            elementInfo.put("String_Node_Str", makeJsonArrayOfIDs(vsl));
        }
        Element type = ((Slot) e).getDefiningFeature();
        if (type != null) {
            elementInfo.put("String_Node_Str", "String_Node_Str" + type.getID());
        }
    } else if (e instanceof Dependency) {
        if (StereotypesHelper.hasStereotypeOrDerived(e, Utils.getConformsStereotype()))
            elementInfo.put("String_Node_Str", "String_Node_Str");
        else if (StereotypesHelper.hasStereotypeOrDerived(e, DocGen3Profile.queriesStereotype))
            elementInfo.put("String_Node_Str", "String_Node_Str");
        else
            elementInfo.put("String_Node_Str", "String_Node_Str");
    } else if (e instanceof Generalization) {
        if (StereotypesHelper.hasStereotypeOrDerived(e, Utils.getConformsStereotype()))
            elementInfo.put("String_Node_Str", "String_Node_Str");
        else if (StereotypesHelper.hasStereotypeOrDerived(e, DocGen3Profile.queriesStereotype))
            elementInfo.put("String_Node_Str", "String_Node_Str");
        else
            elementInfo.put("String_Node_Str", "String_Node_Str");
    } else if (e instanceof DirectedRelationship) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
    } else if (e instanceof Comment) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
        elementInfo.put("String_Node_Str", Utils.stripHtmlWrapper(((Comment) e).getBody()));
        elementInfo.put("String_Node_Str", makeJsonArrayOfIDs(((Comment) e).getAnnotatedElement()));
    } else if (e instanceof Operation) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
        List<Parameter> vsl = ((Operation) e).getOwnedParameter();
        if (vsl != null && vsl.size() > 0) {
            elementInfo.put("String_Node_Str", makeJsonArrayOfIDs(vsl));
        }
    } else if (e instanceof ValueSpecification) {
        fillValueSpecification((ValueSpecification) e, elementInfo, view, viewpoint);
    } else if (e instanceof Constraint) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
        ValueSpecification spec = ((Constraint) e).getSpecification();
        if (spec != null)
            elementInfo.put("String_Node_Str", spec.getID());
    } else if (e instanceof InstanceSpecification) {
        elementInfo.put("String_Node_Str", "String_Node_Str");
        ValueSpecification spec = ((InstanceSpecification) e).getSpecification();
        if (spec != null)
            elementInfo.put("String_Node_Str", spec.getID());
    } else if (e instanceof Parameter) {
        Parameter p = (Parameter) e;
        elementInfo.put("String_Node_Str", "String_Node_Str");
        if (p.getDirection() != null)
            elementInfo.put("String_Node_Str", p.getDirection());
        if (p.getType() != null)
            elementInfo.put("String_Node_Str", p.getType().getID());
        ValueSpecification defaultValue = p.getDefaultValue();
        if (defaultValue != null) {
            elementInfo.put("String_Node_Str", defaultValue.getID());
        }
    } else {
        elementInfo.put("String_Node_Str", "String_Node_Str");
    }
    if (e instanceof DirectedRelationship) {
        Element client = ModelHelper.getClientElement(e);
        Element supplier = ModelHelper.getSupplierElement(e);
        elementInfo.put("String_Node_Str", client.getID());
        elementInfo.put("String_Node_Str", supplier.getID());
    }
    if (viewpoint != null && StereotypesHelper.hasStereotypeOrDerived(e, viewpoint))
        elementInfo.put("String_Node_Str", "String_Node_Str");
    if (e instanceof NamedElement) {
        elementInfo.put("String_Node_Str", ((NamedElement) e).getName());
    } else
        elementInfo.put("String_Node_Str", "String_Node_Str");
    elementInfo.put("String_Node_Str", Utils.stripHtmlWrapper(ModelHelper.getComment(e)));
    if (e.getOwner() == null || e.getOwner() == Application.getInstance().getProject().getModel())
        elementInfo.put("String_Node_Str", "String_Node_Str");
    else
        elementInfo.put("String_Node_Str", "String_Node_Str" + e.getOwner().getID());
    elementInfo.put("String_Node_Str", getElementID(e));
}

Output:
     } else if (e instanceof Dependency) {
-        if (StereotypesHelper.hasStereotypeOrDerived(e, Utils.getConformsStereotype()))
+        if (StereotypesHelper.hasStereotypeOrDerived(e, DocGen3Profile.conformStereotype))
             elementInfo.put("String_Node_Str", "String_Node_Str");


Input:
protected void initPropDescriptor() {
    clearPropertyDescriptors();
    PropertyDescriptor propDes = null;
    propDes = new PropertyDescriptor(new ComponentNameController(), P_ELEMENT_DISPLAY_COMPNAME);
    propDes.setCategory(P_COMPONENT_CAT);
    propDes.setLabelProvider(new PropertyControllerLabelProvider());
    addPropertyDescriptor(propDes);
    propDes = new PropertyDescriptor(new ComponentTypeController(), P_ELEMENT_DISPLAY_COMPTYPE);
    propDes.setCategory(P_COMPONENT_CAT);
    propDes.setLabelProvider(new PropertyControllerLabelProvider());
    addPropertyDescriptor(propDes);
    propDes = new PropertyDescriptor(new ParentProjectController(), P_ELEMENT_DISPLAY_PARENTPROJECT);
    propDes.setCategory(P_COMPONENT_CAT);
    propDes.setLabelProvider(new PropertyControllerLabelProvider());
    addPropertyDescriptor(propDes);
}

Output:
     clearPropertyDescriptors();
-    PropertyDescriptor propDes = null;
-    propDes = new PropertyDescriptor(new ComponentNameController(), P_ELEMENT_DISPLAY_COMPNAME);
+    JBPropertyDescriptor propDes = null;
+    propDes = new JBPropertyDescriptor(new ComponentNameController(), P_ELEMENT_DISPLAY_COMPNAME);
     propDes.setCategory(P_COMPONENT_CAT);


Input:
private void createDelimitedColumnInfoGroup(Composite parent) {
    Group theGroup = WidgetFactory.createGroup(parent, getString("String_Node_Str"), SWT.NONE, 2, 4);
    GridData groupGD = new GridData(GridData.FILL_BOTH);
    groupGD.heightHint = 140;
    theGroup.setLayoutData(groupGD);
    Table table = new Table(theGroup, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
    table.setHeaderVisible(true);
    table.setLinesVisible(true);
    table.setLayout(new TableLayout());
    table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
    this.delimitedColumnsViewer = new TableViewer(table);
    GridData data = new GridData(GridData.FILL_BOTH);
    data.horizontalSpan = 4;
    this.delimitedColumnsViewer.getControl().setLayoutData(data);
    TableViewerColumn column = new TableViewerColumn(this.delimitedColumnsViewer, SWT.LEFT);
    column.getColumn().setText(getString("String_Node_Str") + getSpaces(36));
    column.setEditingSupport(new ColumnNameEditingSupport(this.delimitedColumnsViewer));
    column.setLabelProvider(new ColumnDataLabelProvider(0));
    column.getColumn().pack();
    column = new TableViewerColumn(this.delimitedColumnsViewer, SWT.LEFT);
    column.getColumn().setText(getString("String_Node_Str") + getSpaces(12));
    column.setLabelProvider(new ColumnDataLabelProvider(1));
    column.setEditingSupport(new DatatypeEditingSupport(this.delimitedColumnsViewer));
    column.getColumn().pack();
    if (this.dataFileInfo != null) {
        for (ITeiidColumnInfo row : this.dataFileInfo.getColumnInfoList()) {
            this.delimitedColumnsViewer.add(row);
        }
    }
    addColumnDelimitedButton = new Button(theGroup, SWT.PUSH);
    addColumnDelimitedButton.setText(getString("String_Node_Str"));
    addColumnDelimitedButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    addColumnDelimitedButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            createColumn();
        }
    });
    deleteColumnDelimitedButton = new Button(theGroup, SWT.PUSH);
    deleteColumnDelimitedButton.setText(getString("String_Node_Str"));
    deleteColumnDelimitedButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    deleteColumnDelimitedButton.setEnabled(false);
    deleteColumnDelimitedButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            ITeiidColumnInfo info = null;
            IStructuredSelection selection = (IStructuredSelection) delimitedColumnsViewer.getSelection();
            for (Object obj : selection.toArray()) {
                if (obj instanceof ITeiidColumnInfo) {
                    info = (ITeiidColumnInfo) obj;
                    break;
                }
            }
            if (info != null) {
                dataFileInfo.removeColumn(info);
                handleInfoChanged(false);
                deleteColumnDelimitedButton.setEnabled(false);
            }
        }
    });
    upColumnDelimitedButton = new Button(theGroup, SWT.PUSH);
    upColumnDelimitedButton.setText(getString("String_Node_Str"));
    upColumnDelimitedButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    upColumnDelimitedButton.setEnabled(false);
    upColumnDelimitedButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            TeiidColumnInfo info = null;
            IStructuredSelection selection = (IStructuredSelection) delimitedColumnsViewer.getSelection();
            for (Object obj : selection.toArray()) {
                if (obj instanceof ITeiidColumnInfo) {
                    info = (TeiidColumnInfo) obj;
                    break;
                }
            }
            if (info != null) {
                int selectedIndex = delimitedColumnsViewer.getTable().getSelectionIndex();
                dataFileInfo.moveColumnUp(info);
                handleInfoChanged(false);
                delimitedColumnsViewer.getTable().select(selectedIndex - 1);
                downColumnDelimitedButton.setEnabled(dataFileInfo.canMoveDown(info));
                upColumnDelimitedButton.setEnabled(dataFileInfo.canMoveUp(info));
            }
        }
    });
    downColumnDelimitedButton = new Button(theGroup, SWT.PUSH);
    downColumnDelimitedButton.setText(getString("String_Node_Str"));
    downColumnDelimitedButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    downColumnDelimitedButton.setEnabled(false);
    downColumnDelimitedButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            TeiidColumnInfo info = null;
            IStructuredSelection selection = (IStructuredSelection) delimitedColumnsViewer.getSelection();
            for (Object obj : selection.toArray()) {
                if (obj instanceof ITeiidColumnInfo) {
                    info = (TeiidColumnInfo) obj;
                    break;
                }
            }
            if (info != null) {
                int selectedIndex = delimitedColumnsViewer.getTable().getSelectionIndex();
                dataFileInfo.moveColumnDown(info);
                handleInfoChanged(false);
                delimitedColumnsViewer.getTable().select(selectedIndex + 1);
                downColumnDelimitedButton.setEnabled(dataFileInfo.canMoveDown(info));
                upColumnDelimitedButton.setEnabled(dataFileInfo.canMoveUp(info));
            }
        }
    });
    this.delimitedColumnsViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            IStructuredSelection sel = (IStructuredSelection) event.getSelection();
            if (sel.isEmpty()) {
                deleteColumnDelimitedButton.setEnabled(false);
                upColumnDelimitedButton.setEnabled(false);
                downColumnDelimitedButton.setEnabled(false);
            } else {
                boolean enable = true;
                Object[] objs = sel.toArray();
                ITeiidColumnInfo columnInfo = null;
                for (Object obj : objs) {
                    if (!(obj instanceof ITeiidColumnInfo)) {
                        enable = false;
                        break;
                    } else {
                        columnInfo = (ITeiidColumnInfo) obj;
                    }
                }
                if (objs.length == 0) {
                    enable = false;
                }
                deleteColumnDelimitedButton.setEnabled(enable);
                if (enable) {
                    upColumnDelimitedButton.setEnabled(dataFileInfo.canMoveUp(columnInfo));
                    downColumnDelimitedButton.setEnabled(dataFileInfo.canMoveDown(columnInfo));
                }
            }
        }
    });
}

Output:
     theGroup.setLayoutData(groupGD);
-    Table table = new Table(theGroup, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
+    this.delimitedColumnsViewer = new TableViewer(theGroup, SWT.SINGLE | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
+    Table table = this.delimitedColumnsViewer.getTable();
     table.setHeaderVisible(true);