Input:
private void checkForUpdate() {
    if (verbose) {
        logger.log(Level.INFO, "String_Node_Str");
    }
    URL url = null;
    URLConnection urlConn = null;
    InputStreamReader inStream = null;
    BufferedReader buff = null;
    String v = "String_Node_Str";
    try {
        url = new URL("String_Node_Str");
        urlConn = url.openConnection();
        inStream = new InputStreamReader(urlConn.getInputStream());
    } catch (Exception ex) {
    }
    buff = new BufferedReader(inStream);
    try {
        v = buff.readLine();
        urlConn = null;
        inStream = null;
        buff.close();
        buff = null;
    } catch (Exception ex) {
    }
    if (!this.getDescription().getVersion().equalsIgnoreCase(v)) {
        String version = this.getDescription().getVersion();
        if (version.endsWith("String_Node_Str") || version.endsWith("String_Node_Str")) {
            if (version.replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str").equalsIgnoreCase(v)) {
                update = true;
                if (verbose) {
                    logger.log(Level.INFO, "String_Node_Str");
                }
            } else {
                update = false;
                if (verbose) {
                    logger.log(Level.INFO, "String_Node_Str");
                }
            }
        } else {
            update = true;
            if (verbose) {
                logger.log(Level.INFO, "String_Node_Str");
            }
        }
    } else {
        if (verbose) {
            logger.log(Level.INFO, "String_Node_Str");
        }
        update = false;
    }
}

Output:
     }
-    URL url = null;
-    URLConnection urlConn = null;
+    URL url;
+    URLConnection urlConn;
     InputStreamReader inStream = null;


Input:
private static void insertEdges(final double hyperplaneThickness, final BSPTree<Sphere2D> node, final List<Edge> edges) {
    int index = 0;
    Edge inserted = null;
    while (inserted == null && index < edges.size()) {
        inserted = edges.get(index++);
        if (inserted.getNode() == null) {
            if (node.insertCut(inserted.getCircle())) {
                inserted.setNode(node);
            } else {
                inserted = null;
            }
        } else {
            inserted = null;
        }
    }
    if (inserted == null) {
        final BSPTree<Sphere2D> parent = node.getParent();
        if (parent == null || node == parent.getMinus()) {
            node.setAttribute(Boolean.TRUE);
        } else {
            node.setAttribute(Boolean.FALSE);
        }
        return;
    }
    final List<Edge> outsideList = new ArrayList<Edge>();
    final List<Edge> insideList = new ArrayList<Edge>();
    for (final Edge edge : edges) {
        if (edge != inserted) {
            edge.split(inserted.getCircle(), outsideList, insideList);
        }
    }
    if (!outsideList.isEmpty()) {
        insertEdges(hyperplaneThickness, node.getPlus(), outsideList);
    } else {
        node.getMinus().setAttribute(Boolean.FALSE);
    }
    if (!insideList.isEmpty()) {
        insertEdges(hyperplaneThickness, node.getMinus(), insideList);
    } else {
        node.getPlus().setAttribute(Boolean.TRUE);
    }
}

Output:
     } else {
-        node.getMinus().setAttribute(Boolean.FALSE);
+        node.getPlus().setAttribute(Boolean.FALSE);
     }


Input:
public void serviceReady() {
    scanner.stopFullScan();
    scanner.startRanging();
    scanner.startMonitoring();
}

Output:
 public void serviceReady() {
-    scanner.stopFullScan();
-    scanner.startRanging();
-    scanner.startMonitoring();
+    scanner.startRanging(event.getRegion());
+    scanner.startMonitoring(event.getRegion());
 }


Input:
public SearchResults search(String namespaceId, String searchQuery, Set<EntityTypeSimpleName> types, SortInfo sortInfo, int offset, int limit, int numCursors, String cursor, boolean showHidden, Set<EntityScope> entityScope) {
    if (!SortInfo.DEFAULT.equals(sortInfo)) {
        if (!"String_Node_Str".equals(searchQuery)) {
            throw new IllegalArgumentException("String_Node_Str");
        }
        return searchByCustomIndex(namespaceId, types, sortInfo, offset, limit, numCursors, cursor, showHidden, entityScope);
    }
    return searchByDefaultIndex(namespaceId, searchQuery, types, showHidden, entityScope);
}

Output:
         if (!"String_Node_Str".equals(searchQuery)) {
-            throw new IllegalArgumentException("String_Node_Str");
+            throw new BadRequestException("String_Node_Str");
         }


Input:
public IndicatorParameters getParameters() {
    if (parameters != null) {
        TextParameters textParameters = parameters.getTextParameter();
        if (textParameters == null) {
            textParameters = IndicatorsFactory.eINSTANCE.createTextParameters();
        }
        textParameters.setUseNulls(true);
        textParameters.setUseBlank(false);
        parameters.setTextParameter(textParameters);
    }
    return parameters;
}

Output:
 public IndicatorParameters getParameters() {
-    if (parameters != null) {
-        TextParameters textParameters = parameters.getTextParameter();
-        if (textParameters == null) {
-            textParameters = IndicatorsFactory.eINSTANCE.createTextParameters();
-        }
-        textParameters.setUseNulls(true);
-        textParameters.setUseBlank(false);
-        parameters.setTextParameter(textParameters);
-    }
+    parameters = super.getParameters();
+    parameters.getTextParameter().setUseNulls(true);
+    parameters.getTextParameter().setUseBlank(false);
     return parameters;


Input:
private void _startSimulation() throws IllegalActionException {
    final String worDir = cutQuotationMarks(workingDirectory.getExpression());
    File commandFile = programName.asFile();
    final String comArg;
    if (commandFile.exists()) {
        comArg = commandFile.toString();
    } else {
        commandFile = new File(commandFile.toString() + "String_Node_Str");
        if (commandFile.exists()) {
            comArg = commandFile.toString();
        } else {
            comArg = programName.getExpression();
        }
    }
    final String argLin = cutQuotationMarks(programArguments.getExpression());
    List<String> com = new ArrayList<String>();
    com.add(comArg);
    StringTokenizer st = new StringTokenizer(argLin);
    while (st.hasMoreTokens()) {
        com.add(st.nextToken());
    }
    cliPro = new ClientProcess();
    cliPro.redirectErrorStream(true);
    cliPro.setProcessArguments(com, worDir);
    File slf = simulationLogFile.asFile();
    try {
        if (slf.exists()) {
            if (slf.delete()) {
                if (slf.exists()) {
                    throw new Exception("String_Node_Str");
                }
            }
        }
        if (!slf.createNewFile()) {
            throw new Exception("String_Node_Str");
        }
        if (!slf.canWrite()) {
            throw new Exception("String_Node_Str");
        }
    } catch (Exception e) {
        String em = "String_Node_Str" + LS + "String_Node_Str" + slf.getAbsolutePath() + "String_Node_Str" + LS + "String_Node_Str" + this.getFullName() + "String_Node_Str";
        throw new IllegalActionException(this, e, em);
    }
    cliPro.setSimulationLogFile(slf);
    cliPro.run();
    if (!cliPro.processStarted()) {
        String em = "String_Node_Str" + LS + cliPro.getErrorMessage() + LS + "String_Node_Str" + this.getFullName() + "String_Node_Str";
        throw new IllegalActionException(this, em);
    }
}

Output:
     List<String> com = new ArrayList<String>();
-    com.add(comArg);
+    com.add(Simulator.resolveCommandName(programName.asFile()));
+    final String argLin = cutQuotationMarks(programArguments.getExpression());
     StringTokenizer st = new StringTokenizer(argLin);


Input:
public Object readList(AbstractHessianInput in, int length) throws IOException {
    Collection list = createList();
    in.addRef(list);
    while (!in.isEnd()) list.add(in.readObject());
    in.readEnd();
    return list;
}

Output:
     in.addRef(list);
-    while (!in.isEnd()) list.add(in.readObject());
+    Deserializer deserializer = null;
+    SerializerFactory factory = findSerializerFactory(in);
+    if (expectType != null) {
+        deserializer = factory.getDeserializer(expectType.getName());
+    }
+    while (!in.isEnd()) list.add(deserializer != null ? deserializer.readObject(in) : in.readObject());
     in.readEnd();


Input:
public static String buildMessage(String localizationClassName, String key, Object[] arguments, boolean translate) {
    String message = key;
    ResourceBundle bundle = null;
    String append = "String_Node_Str";
    if (arguments != null) {
        for (int i = 0; i < arguments.length; i++) {
            if (arguments[i] == null) {
                arguments[i] = "String_Node_Str";
            }
        }
    }
    bundle = ResourceBundle.getBundle("String_Node_Str" + localizationClassName + "String_Node_Str", Locale.getDefault());
    try {
        message = bundle.getString(key);
    } catch (java.util.MissingResourceException mre) {
        bundle = ResourceBundle.getBundle("String_Node_Str", Locale.getDefault());
        if (translate && !Locale.getDefault().getLanguage().equals(Locale.ENGLISH.getLanguage())) {
            append = bundle.getString("String_Node_Str");
        }
    }
    return MessageFormat.format(message, arguments) + append;
}

Output:
         bundle = ResourceBundle.getBundle("String_Node_Str", Locale.getDefault());
-        if (translate && !Locale.getDefault().getLanguage().equals(Locale.ENGLISH.getLanguage())) {
-            append = bundle.getString("String_Node_Str");
+        String noTranslationMessage = bundle.getString("String_Node_Str");
+        if (translate) {
+            return MessageFormat.format(message, arguments) + noTranslationMessage;
+        } else {
+            return MessageFormat.format(message, arguments);
         }


Input:
public ValueAndError toObject(final FieldDefinition fieldDefinition, final Object value) {
    if (value instanceof Date) {
        return ValueAndError.withoutError(value);
    }
    try {
        DateTimeFormatter fmt = DateTimeFormat.forPattern(DateUtils.L_DATE_FORMAT);
        DateTime dt = fmt.parseDateTime(String.valueOf(value));
        int year = dt.getYear();
        if (year < 1500 || year > 2500) {
            return ValueAndError.withoutError("String_Node_Str");
        }
        Date date = dt.toDate();
        if (year < 2000) {
            Calendar c = Calendar.getInstance();
            c.set(Calendar.YEAR, dt.getYear());
            c.set(Calendar.MONTH, dt.getMonthOfYear() - 1);
            c.set(Calendar.DAY_OF_MONTH, dt.getDayOfMonth());
            c.set(Calendar.HOUR_OF_DAY, dt.hourOfDay().get());
            c.set(Calendar.MINUTE, dt.getMinuteOfHour());
            c.set(Calendar.SECOND, dt.getSecondOfMinute());
            c.set(Calendar.MILLISECOND, dt.getMillisOfSecond());
            date = c.getTime();
        }
        return ValueAndError.withoutError(date);
    } catch (IllegalArgumentException e) {
        return ValueAndError.withError("String_Node_Str");
    }
}

Output:
         if (year < 1500 || year > 2500) {
-            return ValueAndError.withoutError("String_Node_Str");
+            return ValueAndError.withError("String_Node_Str");
         }


Input:
public void set(Map<String, String> value) {
    pointTo(new ByteArray(encode(value)));
}

Output:
 public void set(Map<String, String> value) {
-    pointTo(new ByteArray(encode(value)));
+    if (value.isEmpty()) {
+        pointTo(NULL);
+    } else {
+        pointTo(new ByteArray(encode(value)));
+    }
 }


Input:
public List<String> getVideoBitrateOptions(DLNAResource dlna, DLNAMediaInfo media, OutputParams params) {
    List<String> videoBitrateOptions = new ArrayList<>();
    int[] defaultMaxBitrates = getVideoBitrateConfig(configuration.getMaximumBitrate());
    int[] rendererMaxBitrates = new int[2];
    if (StringUtils.isNotEmpty(params.mediaRenderer.getMaxVideoBitrate())) {
        rendererMaxBitrates = getVideoBitrateConfig(params.mediaRenderer.getMaxVideoBitrate());
    }
    if (rendererMaxBitrates[0] > 0 && rendererMaxBitrates[0] < defaultMaxBitrates[0]) {
        defaultMaxBitrates = rendererMaxBitrates;
        LOGGER.trace("String_Node_Str" + rendererMaxBitrates[0] + "String_Node_Str" + defaultMaxBitrates[0] + "String_Node_Str");
    } else {
        LOGGER.trace("String_Node_Str" + defaultMaxBitrates[0] + "String_Node_Str");
    }
    if (params.mediaRenderer.getCBRVideoBitrate() == 0 && params.timeend == 0) {
        if (rendererMaxBitrates[0] < 0) {
            defaultMaxBitrates[0] = 300;
        } else {
            defaultMaxBitrates[0] = 1000 * defaultMaxBitrates[0];
        }
        defaultMaxBitrates[0] /= 2;
        LOGGER.trace("String_Node_Str" + defaultMaxBitrates[0]);
        int bufSize = 1835;
        boolean bitrateLevel41Limited = false;
        if (params.mediaRenderer.isTranscodeToMPEGTSH264AC3() || params.mediaRenderer.isTranscodeToMPEGTSH264AAC()) {
            if (params.mediaRenderer.isH264Level41Limited() && defaultMaxBitrates[0] > 31250) {
                defaultMaxBitrates[0] = 31250;
                bitrateLevel41Limited = true;
                LOGGER.trace("String_Node_Str");
            }
            bufSize = defaultMaxBitrates[0];
        } else {
            if (media.isHDVideo()) {
                bufSize = defaultMaxBitrates[0] / 3;
            }
            if (bufSize > 7000) {
                bufSize = 7000;
            }
            if (defaultMaxBitrates[1] > 0) {
                bufSize = defaultMaxBitrates[1];
            }
            if (params.mediaRenderer.isDefaultVBVSize() && rendererMaxBitrates[1] == 0) {
                bufSize = 1835;
            }
        }
        if (!bitrateLevel41Limited) {
            if (dtsRemux) {
                defaultMaxBitrates[0] -= 1510;
            } else {
                defaultMaxBitrates[0] -= configuration.getAudioBitrate();
            }
            defaultMaxBitrates[0] = defaultMaxBitrates[0] / 1000 * 1000;
            LOGGER.trace("String_Node_Str" + defaultMaxBitrates[0] + "String_Node_Str");
        }
        bufSize *= 1000;
        defaultMaxBitrates[0] *= 1000;
        videoBitrateOptions.add("String_Node_Str");
        videoBitrateOptions.add(String.valueOf(bufSize));
        videoBitrateOptions.add("String_Node_Str");
        videoBitrateOptions.add(String.valueOf(defaultMaxBitrates[0]));
    }
    if (!params.mediaRenderer.isTranscodeToMPEGTSH264AC3() && !params.mediaRenderer.isTranscodeToMPEGTSH264AAC()) {
        String mpeg2Options = configuration.getMPEG2MainSettingsFFmpeg();
        String mpeg2OptionsRenderer = params.mediaRenderer.getCustomFFmpegMPEG2Options();
        if (isNotBlank(mpeg2OptionsRenderer)) {
            mpeg2Options = mpeg2OptionsRenderer;
        } else if (mpeg2Options.contains("String_Node_Str")) {
            mpeg2Options = "String_Node_Str";
            if (params.mediaRenderer.isPS3()) {
                mpeg2Options = "String_Node_Str";
            }
            if (mpeg2Options.contains("String_Node_Str") || defaultMaxBitrates[0] < 70) {
                if (media.getWidth() > 1280) {
                    mpeg2Options = "String_Node_Str";
                } else if (media.getWidth() > 720) {
                    mpeg2Options = "String_Node_Str";
                }
            }
        }
        String[] customOptions = StringUtils.split(mpeg2Options);
        videoBitrateOptions.addAll(new ArrayList<>(Arrays.asList(customOptions)));
    } else {
        String x264CRF = configuration.getx264ConstantRateFactor();
        if (x264CRF.contains("String_Node_Str")) {
            x264CRF = x264CRF.substring(x264CRF.indexOf("String_Node_Str"));
        }
        if (x264CRF.contains("String_Node_Str")) {
            x264CRF = "String_Node_Str";
            if (media.getWidth() > 720) {
                x264CRF = "String_Node_Str";
            }
        }
        videoBitrateOptions.add("String_Node_Str");
        videoBitrateOptions.add(x264CRF);
    }
    return videoBitrateOptions;
}

Output:
     if (!params.mediaRenderer.isTranscodeToMPEGTSH264AC3() && !params.mediaRenderer.isTranscodeToMPEGTSH264AAC()) {
-        String mpeg2Options = configuration.getMPEG2MainSettingsFFmpeg();
+        String mpeg2OptionsMainSetting = configuration.getMPEG2MainSettingsFFmpeg();
         String mpeg2OptionsRenderer = params.mediaRenderer.getCustomFFmpegMPEG2Options();


Input:
public void run() {
    try {
        for (Resource resource : template.getResourceList()) {
            new TemplateParser().reevaluateResources(template);
            StackEvent stackEvent = new StackEvent();
            stackEvent.setStackId(stack.getStackId());
            stackEvent.setStackName(stack.getStackName());
            stackEvent.setLogicalResourceId(resource.getLogicalResourceId());
            stackEvent.setPhysicalResourceId(resource.getPhysicalResourceId());
            stackEvent.setEventId(UUID.randomUUID().toString());
            stackEvent.setResourceProperties(resource.getPropertiesJSON().toString());
            stackEvent.setResourceType(resource.getType());
            stackEvent.setResourceStatus(StackResourceEntity.Status.CREATE_IN_PROGRESS.toString());
            stackEvent.setResourceStatusReason("String_Node_Str");
            stackEvent.setTimestamp(new Date());
            StackEventEntityManager.addStackEvent(stackEvent);
            StackResource stackResource = new StackResource();
            stackResource.setResourceStatus(StackResourceEntity.Status.CREATE_IN_PROGRESS.toString());
            stackResource.setPhysicalResourceId(resource.getPhysicalResourceId());
            stackResource.setLogicalResourceId(resource.getLogicalResourceId());
            stackResource.setDescription("String_Node_Str");
            stackResource.setResourceStatusReason("String_Node_Str");
            stackResource.setResourceType(resource.getType());
            stackResource.setStackName(stack.getStackName());
            stackResource.setStackId(stack.getStackId());
            StackResourceEntityManager.addStackResource(stackResource, resource.getMetadataJSON());
            try {
                resource.create();
                StackResourceEntityManager.updatePhysicalResourceId(stack.getStackName(), resource.getLogicalResourceId(), resource.getPhysicalResourceId());
                StackResourceEntityManager.updateStatus(stack.getStackName(), resource.getLogicalResourceId(), StackResourceEntity.Status.CREATE_COMPLETE, "String_Node_Str");
                stackEvent.setEventId(UUID.randomUUID().toString());
                stackEvent.setResourceStatus(StackResourceEntity.Status.CREATE_COMPLETE.toString());
                stackEvent.setResourceStatusReason("String_Node_Str");
                stackEvent.setPhysicalResourceId(resource.getPhysicalResourceId());
                stackEvent.setTimestamp(new Date());
                StackEventEntityManager.addStackEvent(stackEvent);
                template.getReferenceMap().get(resource.getPhysicalResourceId()).setReady(true);
                template.getReferenceMap().get(resource.getPhysicalResourceId()).setReferenceValue(resource.referenceValue());
            } catch (Exception ex) {
                LOG.error(ex, ex);
                StackResourceEntityManager.updateStatus(stack.getStackName(), resource.getLogicalResourceId(), StackResourceEntity.Status.CREATE_FAILED, "String_Node_Str" + ex.getMessage());
                stackEvent.setEventId(UUID.randomUUID().toString());
                stackEvent.setResourceStatus(StackResourceEntity.Status.CREATE_FAILED.toString());
                stackEvent.setTimestamp(new Date());
                stackEvent.setResourceStatusReason("String_Node_Str" + ex.getMessage());
                stackEvent.setPhysicalResourceId(resource.getPhysicalResourceId());
                StackEventEntityManager.addStackEvent(stackEvent);
                throw ex;
            }
        }
        StackEntityManager.updateStatus(stack.getStackName(), StackEntity.Status.CREATE_COMPLETE, "String_Node_Str");
    } catch (Exception ex2) {
        LOG.error(ex2, ex2);
        StackEntityManager.updateStatus(stack.getStackName(), StackEntity.Status.CREATE_FAILED, ex2.getMessage());
    }
}

Output:
                 StackEventEntityManager.addStackEvent(stackEvent);
-                template.getReferenceMap().get(resource.getPhysicalResourceId()).setReady(true);
-                template.getReferenceMap().get(resource.getPhysicalResourceId()).setReferenceValue(resource.referenceValue());
+                template.getReferenceMap().get(resource.getLogicalResourceId()).setReady(true);
+                template.getReferenceMap().get(resource.getLogicalResourceId()).setReferenceValue(resource.referenceValue());
             } catch (Exception ex) {


Input:
private HTMLRenderContext createHTMLrenderContext(boolean svgFlag) {
    HTMLRenderContext renderContext = new HTMLRenderContext();
    renderContext.setImageDirectory(imageDirectory);
    renderContext.setBaseImageURL(contextPath + imageBaseUrl);
    renderContext.setBaseURL(this.contextPath + "String_Node_Str");
    renderContext.setSupportedImageFormats(svgFlag ? "String_Node_Str" : "String_Node_Str");
    return renderContext;
}

Output:
     renderContext.setBaseImageURL(contextPath + imageBaseUrl);
-    renderContext.setBaseURL(this.contextPath + "String_Node_Str");
+    if (servletPath != null && servletPath.length() > 0 && !servletPath.equalsIgnoreCase(IBirtConstants.SERVLET_PATH_PREVIEW)) {
+        renderContext.setBaseURL(this.contextPath + servletPath);
+    } else {
+        renderContext.setBaseURL(this.contextPath + IBirtConstants.SERVLET_PATH_FRAMESET);
+    }
     renderContext.setSupportedImageFormats(svgFlag ? "String_Node_Str" : "String_Node_Str");


Input:
private Iterator supportedJ2CAdapters() {
    return EisPlatformManager.instance().platformShortNames();
}

Output:
 private Iterator supportedJ2CAdapters() {
-    return EisPlatformManager.instance().platformShortNames();
+    Collection platforms = CollectionTools.sortedSet(EisPlatformManager.instance().platformDisplayNames());
+    return platforms.iterator();
 }


Input:
private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
    DubboClassPathBeanDefinitionScanner scanner = new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
    BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    scanner.setBeanNameGenerator(beanNameGenerator);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
    for (String packageToScan : packagesToScan) {
        Set<BeanDefinitionHolder> beanDefinitionHolders = scanner.doScan(packageToScan);
        if (CollectionUtils.isEmpty(beanDefinitionHolders)) {
            if (logger.isInfoEnabled()) {
                logger.info("String_Node_Str" + "String_Node_Str");
                logger.info("String_Node_Str");
            }
            beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
        }
        if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
            for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                registerServiceBean(beanDefinitionHolder, registry);
            }
            if (logger.isInfoEnabled()) {
                logger.info(beanDefinitionHolders.size() + "String_Node_Str" + beanDefinitionHolders + "String_Node_Str" + packageToScan + "String_Node_Str");
            }
        } else {
            if (logger.isWarnEnabled()) {
                logger.warn("String_Node_Str");
            }
        }
    }
}

Output:
     for (String packageToScan : packagesToScan) {
-        Set<BeanDefinitionHolder> beanDefinitionHolders = scanner.doScan(packageToScan);
-        if (CollectionUtils.isEmpty(beanDefinitionHolders)) {
-            if (logger.isInfoEnabled()) {
-                logger.info("String_Node_Str" + "String_Node_Str");
-                logger.info("String_Node_Str");
-            }
-            beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
-        }
+        scanner.scan(packageToScan);
+        Set<BeanDefinitionHolder> beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
         if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {


Input:
public void array_of_elements_should_be_inserted_into_given_implementation_collection() {
    KeyValueObjectMapper keyValueObjectMapper = new KeyValueObjectMapper();
    Map<String, Object> elements = keyValueObjectMapper.readValues(new ByteArrayInputStream(SET_DATA.getBytes()));
    Set<String> readElements = (Set<String>) elements.get("String_Node_Str");
    assertThat(readElements, instanceOf(HashSet.class));
    assertThat(readElements, containsInAnyOrder("String_Node_Str", "String_Node_Str"));
}

Output:
     KeyValueObjectMapper keyValueObjectMapper = new KeyValueObjectMapper();
-    Map<String, Object> elements = keyValueObjectMapper.readValues(new ByteArrayInputStream(SET_DATA.getBytes()));
+    Map<Object, Object> elements = keyValueObjectMapper.readValues(new ByteArrayInputStream(SET_DATA.getBytes()));
     Set<String> readElements = (Set<String>) elements.get("String_Node_Str");


Input:
public void testConstructor() {
    byte testSessionId = (byte) 0x0A;
    SessionType testSessionType = SessionType.RPC;
    InputStream testInputStream = null;
    byte testWiproVersion = (byte) 0x0B;
    IStreamListener testListener = new MockStreamListener();
    MockInterfaceBroker _interfaceBroker = new MockInterfaceBroker();
    BaseTransportConfig _transportConfig = new BTTransportConfig(true);
    SdlSession testSdlSession = SdlSession.createSession(testWiproVersion, _interfaceBroker, _transportConfig);
    try {
        URL url = new URL("String_Node_Str");
        URLConnection urlConnection = url.openConnection();
        testInputStream = new BufferedInputStream(urlConnection.getInputStream());
        StreamPacketizer testStreamPacketizer = new StreamPacketizer(testListener, testInputStream, testSessionType, testSessionId, testSdlSession);
        assertNotNull(Test.NOT_NULL, testStreamPacketizer);
    } catch (IOException e) {
        fail("String_Node_Str");
    }
}

Output:
     try {
-        URL url = new URL("String_Node_Str");
-        URLConnection urlConnection = url.openConnection();
-        testInputStream = new BufferedInputStream(urlConnection.getInputStream());
+        testInputStream = new BufferedInputStream(new ByteArrayInputStream("String_Node_Str".getBytes()));
         StreamPacketizer testStreamPacketizer = new StreamPacketizer(testListener, testInputStream, testSessionType, testSessionId, testSdlSession);


Input:
public String toString() {
    return Arrays.toString(this.value);
}

Output:
 public String toString() {
-    return Arrays.toString(this.value);
+    return string;
 }


Input:
protected void addMavenBuildScripts(ExportFileResource[] processes, List<URL> scriptsUrls, Map<String, String> mavenPropertiesMap) {
    if (!PluginChecker.isPluginLoaded(PluginChecker.EXPORT_ROUTE_PLUGIN_ID)) {
        return;
    }
    Item item = processes[0].getItem();
    File templatePomFile = null, templateBundleFile = null, templateFeatureFile = null, templateParentFile = null;
    if (item != null) {
        IPath itemLocationPath = ItemResourceUtil.getItemLocationPath(item.getProperty());
        IFolder objectTypeFolder = ItemResourceUtil.getObjectTypeFolder(item.getProperty());
        if (itemLocationPath != null && objectTypeFolder != null) {
            IPath itemRelativePath = itemLocationPath.removeLastSegments(1).makeRelativeTo(objectTypeFolder.getLocation());
            templatePomFile = PomUtil.getTemplateFile(objectTypeFolder, itemRelativePath, TalendMavenConstants.POM_FILE_NAME);
            if (FilesUtils.allInSameFolder(templatePomFile, IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_BUNDLE_FILE_NAME, IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_FEATURE_FILE_NAME, IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_PARENT_FILE_NAME)) {
                templateBundleFile = new File(templatePomFile.getParentFile(), IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_BUNDLE_FILE_NAME);
                templateFeatureFile = new File(templatePomFile.getParentFile(), IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_FEATURE_FILE_NAME);
                templateParentFile = new File(templatePomFile.getParentFile(), IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_PARENT_FILE_NAME);
            } else {
                templatePomFile = null;
            }
        }
    }
    File mavenBuildFile = new File(getTmpFolder() + PATH_SEPARATOR + IProjectSettingTemplateConstants.POM_FILE_NAME);
    File mavenBuildBundleFile = new File(getTmpFolder() + PATH_SEPARATOR + IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_BUNDLE_FILE_NAME);
    File mavenBuildFeatureFile = new File(getTmpFolder() + PATH_SEPARATOR + IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_FEATURE_FILE_NAME);
    File mavenBuildParentFile = new File(getTmpFolder() + PATH_SEPARATOR + IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_PARENT_FILE_NAME);
    try {
        String mavenScript = MavenTemplateManager.getTemplateContent(templatePomFile, IProjectSettingPreferenceConstants.TEMPLATE_ROUTES_KARAF_POM, PluginChecker.EXPORT_ROUTE_PLUGIN_ID, IProjectSettingTemplateConstants.PATH_ROUTE + '/' + TalendMavenConstants.POM_FILE_NAME);
        if (mavenScript != null) {
            createMavenBuildFileFromTemplate(mavenBuildFile, mavenScript);
            updateMavenBuildFileContent(mavenBuildFile, mavenPropertiesMap, false, true);
            scriptsUrls.add(mavenBuildFile.toURI().toURL());
        }
        mavenScript = MavenTemplateManager.getTemplateContent(templateBundleFile, IProjectSettingPreferenceConstants.TEMPLATE_ROUTES_KARAF_BUNDLE, PluginChecker.EXPORT_ROUTE_PLUGIN_ID, IProjectSettingTemplateConstants.PATH_ROUTE + '/' + IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_BUNDLE_FILE_NAME);
        if (mavenScript != null) {
            createMavenBuildFileFromTemplate(mavenBuildBundleFile, mavenScript);
            updateMavenBuildFileContent(mavenBuildBundleFile, mavenPropertiesMap, true, false);
            scriptsUrls.add(mavenBuildBundleFile.toURI().toURL());
        }
        mavenScript = MavenTemplateManager.getTemplateContent(templateFeatureFile, IProjectSettingPreferenceConstants.TEMPLATE_ROUTES_KARAF_FEATURE, PluginChecker.EXPORT_ROUTE_PLUGIN_ID, IProjectSettingTemplateConstants.PATH_ROUTE + '/' + IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_FEATURE_FILE_NAME);
        if (mavenScript != null) {
            createMavenBuildFileFromTemplate(mavenBuildFeatureFile, mavenScript);
            updateMavenBuildFileContent(mavenBuildFeatureFile, mavenPropertiesMap);
            scriptsUrls.add(mavenBuildFeatureFile.toURI().toURL());
        }
        mavenScript = MavenTemplateManager.getTemplateContent(templateParentFile, IProjectSettingPreferenceConstants.TEMPLATE_ROUTES_KARAF_PARENT, PluginChecker.EXPORT_ROUTE_PLUGIN_ID, IProjectSettingTemplateConstants.PATH_ROUTE + '/' + IProjectSettingTemplateConstants.MAVEN_KARAF_BUILD_PARENT_FILE_NAME);
        if (mavenScript != null) {
            createMavenBuildFileFromTemplate(mavenBuildParentFile, mavenScript);
            updateMavenBuildFileContent(mavenBuildParentFile, mavenPropertiesMap);
            scriptsUrls.add(mavenBuildParentFile.toURI().toURL());
        }
    } catch (Exception e) {
        ExceptionHandler.process(e);
    }
}

Output:
     try {
-        String mavenScript = MavenTemplateManager.getTemplateContent(templatePomFile, IProjectSettingPreferenceConstants.TEMPLATE_ROUTES_KARAF_POM, PluginChecker.EXPORT_ROUTE_PLUGIN_ID, IProjectSettingTemplateConstants.PATH_ROUTE + '/' + TalendMavenConstants.POM_FILE_NAME);
+        final Map<String, Object> templateParameters = PomUtil.getTemplateParameters(item.getProperty());
+        String mavenScript = MavenTemplateManager.getTemplateContent(templatePomFile, IProjectSettingPreferenceConstants.TEMPLATE_ROUTES_KARAF_POM, PluginChecker.EXPORT_ROUTE_PLUGIN_ID, IProjectSettingTemplateConstants.PATH_ROUTE + '/' + TalendMavenConstants.POM_FILE_NAME, templateParameters);
         if (mavenScript != null) {


Input:
public void should_UpdateProduct_WhenPutRequestMadeWithWrongPostOverSsl() throws Exception {
    final String requestUrl = String.format("String_Node_Str", STUBS_SSL_URL, "String_Node_Str");
    final String content = "String_Node_Str";
    final HttpRequest request = HttpUtils.constructHttpRequest(HttpMethods.PUT, requestUrl, content);
    final HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.setContentType(Common.HEADER_APPLICATION_JSON);
    request.setHeaders(httpHeaders);
    final HttpResponse response = request.execute();
    final String responseContentAsString = response.parseAsString().trim();
    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND_404);
    assertThat(responseContentAsString).contains("String_Node_Str");
}

Output:
     final HttpHeaders httpHeaders = new HttpHeaders();
-    httpHeaders.setContentType(Common.HEADER_APPLICATION_JSON);
+    httpHeaders.setContentType(HEADER_APPLICATION_JSON);
     request.setHeaders(httpHeaders);


Input:
protected boolean removeEldestEntry(Entry<String, ProductReference> eldest) {
    return this.size() > max;
}

Output:
 protected boolean removeEldestEntry(Entry<String, ProductReference> eldest) {
-    return this.size() > max;
+    return super.size() > max;
 }


Input:
public String getUnlocaizedName() {
    return "String_Node_Str" + ICBM.PREFIX + name + "String_Node_Str";
}

Output:
 public String getUnlocaizedName() {
-    return "String_Node_Str" + ICBM.PREFIX + name + "String_Node_Str";
+    return "String_Node_Str" + ICBM.PREFIX + name;
 }


Input:
public Document createDocumentWithSystemIdentifier(String name, String systemIdentifier) throws XMLPlatformException {
    try {
        Document document = null;
        if (null == systemIdentifier) {
            document = createDocument();
            Element rootElement = document.createElement(name);
            document.appendChild(rootElement);
            return document;
        }
        DocumentBuilder documentBuilder = DocumentBuilderFactoryHelper.getDocumentBuilderFactory().newDocumentBuilder();
        DOMImplementation domImpl = documentBuilder.getDOMImplementation();
        DocumentType docType = domImpl.createDocumentType(name, null, systemIdentifier);
        document = domImpl.createDocument(null, name, docType);
        return document;
    } catch (Exception e) {
        throw XMLPlatformException.xmlPlatformCouldNotCreateDocument(e);
    }
}

Output:
         }
-        DocumentBuilder documentBuilder = DocumentBuilderFactoryHelper.getDocumentBuilderFactory().newDocumentBuilder();
+        DocumentBuilder documentBuilder = getDocumentBuilderFactory().newDocumentBuilder();
         DOMImplementation domImpl = documentBuilder.getDOMImplementation();


Input:
public void delete(long id) {
    for (RelationCheck rel : relations.values()) {
        rel.deleteFrom(id);
        rel.deleteTo(id);
    }
}

Output:
 public void delete(long id) {
-    for (RelationCheck rel : relations.values()) {
-        rel.deleteFrom(id);
-        rel.deleteTo(id);
+    synchronized (relations) {
+        for (RelationCheck rel : relations.values()) {
+            rel.deleteFrom(id);
+            rel.deleteTo(id);
+        }
     }


Input:
public boolean needClip() {
    return isClippingContainer && needClip;
}

Output:
 public boolean needClip() {
-    return isClippingContainer && needClip;
+    return needClip;
 }


Input:
public void drawPlayerBorderObject(int x, int y, byte player) {
    forceSetup();
    byte fogstatus = context.getVisibleStatus(x, y);
    if (fogstatus == 0) {
        return;
    }
    float base = getColor(fogstatus);
    Color color = context.getPlayerColor(player);
    draw(imageProvider.getSettlerSequence(FILE_BORDERPOST, 65).getImageSafe(0), x, y, color, base);
}

Output:
     byte fogstatus = context.getVisibleStatus(x, y);
-    if (fogstatus == 0) {
+    if (fogstatus <= CommonConstants.FOG_OF_WAR_EXPLORED) {
         return;


Input:
public void run() {
    try {
        IFile duplicateObject = null;
        for (final IRepositoryNode node : nodeArray) {
            if (node != null) {
                IRepositoryViewObject viewObject = node.getObject();
                ModelElement modelElement = null;
                if (viewObject != null) {
                    modelElement = PropertyHelper.getModelElement(viewObject.getProperty());
                }
                if (modelElement == null || modelElement.eResource() == null || modelElement instanceof UDIndicatorDefinition && UDIHelper.getUDICategory(modelElement) == null) {
                    BusinessException createBusinessException = ExceptionFactory.getInstance().createBusinessException(viewObject);
                    throw createBusinessException;
                }
                final IDuplicateHandle handle = ActionHandleFactory.createDuplicateHandle(node);
                if (handle != null) {
                    String initLabel = generateInitialLabel(node);
                    InputDialog dialog = new InputDialog(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"), initLabel, new IInputValidator() {
                        public String isValid(String newText) {
                            if (PropertyHelper.existDuplicateName(newText, null, node.getContentType())) {
                                return DefaultMessagesImpl.getString("String_Node_Str");
                            }
                            return null;
                        }
                    });
                    if (dialog.open() == Window.OK) {
                        String newLabel = dialog.getValue();
                        if (ERepositoryObjectType.TDQ_USERDEFINE_INDICATORS.equals(node.getProperties(IRepositoryNode.EProperties.LABEL))) {
                            duplicateObject = handle.duplicate(newLabel);
                        } else {
                            ReturnCode rc = handle.validDuplicated();
                            if (rc.isOk()) {
                                duplicateObject = handle.duplicate(newLabel);
                            } else {
                                MessageDialog.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), rc.getMessage());
                            }
                        }
                    }
                }
            }
        }
        CorePlugin.getDefault().refreshWorkSpace();
        if (duplicateObject != null) {
            selectAndReveal(duplicateObject);
        }
    } catch (BusinessException e) {
        ExceptionHandler.process(e, Level.FATAL);
    }
}

Output:
                 }
-                if (modelElement == null || modelElement.eResource() == null || modelElement instanceof UDIndicatorDefinition && UDIHelper.getUDICategory(modelElement) == null) {
+                if (viewObject == null || viewObject.getProperty() == null || viewObject.getProperty().getItem() == null) {
+                    BusinessException createBusinessException = ExceptionFactory.getInstance().createBusinessException("String_Node_Str");
+                    throw createBusinessException;
+                }
+                Item item = viewObject.getProperty().getItem();
+                if ((modelElement == null || modelElement.eResource() == null || modelElement.getName() == null || modelElement instanceof UDIndicatorDefinition && UDIHelper.getUDICategory(modelElement) == null) && !(item instanceof TDQFileItem)) {
                     BusinessException createBusinessException = ExceptionFactory.getInstance().createBusinessException(viewObject);


Input:
public static UUID getUUID(String name) {
    if (Bukkit.getServer().getOnlineMode()) {
        OfflinePlayer op = Bukkit.getOfflinePlayer(name);
        if (op.hasPlayedBefore() || op.isOnline()) {
            return op.getUniqueId();
        }
    }
    try {
        return UUIDFetcher.getUUIDOf(name);
    } catch (IOException | ParseException | InterruptedException ex) {
        throw new IllegalArgumentException("String_Node_Str", ex);
    }
}

Output:
     } catch (IOException | ParseException | InterruptedException ex) {
-        throw new IllegalArgumentException("String_Node_Str", ex);
+        throw new IllegalArgumentException("String_Node_Str" + name + "String_Node_Str", ex);
     }


Input:
void resume() {
    Activity activity = (Activity) mActivity;
    ActionBar actionBar = activity.getActionBar();
    if (actionBar != null) {
        if ((mFlags & FLAG_HIDE_ACTION_BAR) != 0) {
            actionBar.hide();
        } else {
            actionBar.show();
        }
        int stateCount = mActivity.getStateManager().getStateCount();
        actionBar.setDisplayOptions(stateCount == 1 ? 0 : ActionBar.DISPLAY_HOME_AS_UP, ActionBar.DISPLAY_HOME_AS_UP);
        actionBar.setHomeButtonEnabled(true);
    }
    activity.invalidateOptionsMenu();
    final Window win = activity.getWindow();
    final WindowManager.LayoutParams params = win.getAttributes();
    if ((mFlags & FLAG_HIDE_STATUS_BAR) != 0) {
        params.systemUiVisibility = View.SYSTEM_UI_FLAG_LOW_PROFILE;
    } else {
        params.systemUiVisibility = View.SYSTEM_UI_FLAG_VISIBLE;
    }
    setScreenOnFlags(params);
    win.setAttributes(params);
    ResultEntry entry = mReceivedResults;
    if (entry != null) {
        mReceivedResults = null;
        onStateResult(entry.requestCode, entry.resultCode, entry.resultData);
    }
    if (0 != (mFlags & FLAG_SCREEN_ON)) {
        final IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_BATTERY_CHANGED);
        activity.registerReceiver(mPowerIntentReceiver, filter);
    }
    onResume();
}

Output:
         actionBar.setDisplayOptions(stateCount == 1 ? 0 : ActionBar.DISPLAY_HOME_AS_UP, ActionBar.DISPLAY_HOME_AS_UP);
-        actionBar.setHomeButtonEnabled(true);
+        actionBar.setHomeButtonEnabled((actionBar.getDisplayOptions() & ActionBar.DISPLAY_HOME_AS_UP) != 0);
     }


Input:
ClassDefinition create(byte[] compressedBinary) throws IOException {
    if (compressedBinary == null || compressedBinary.length == 0) {
        throw new IOException("String_Node_Str");
    }
    final BufferObjectDataOutput out = serializationService.pop();
    final byte[] binary;
    try {
        decompress(compressedBinary, out);
        binary = out.toByteArray();
    } finally {
        serializationService.push(out);
    }
    final ClassDefinitionImpl cd = new ClassDefinitionImpl();
    cd.readData(serializationService.createObjectDataInput(binary));
    if (cd.getVersion() < 0) {
        throw new IOException("String_Node_Str" + cd);
    }
    cd.setBinary(compressedBinary);
    return register(cd);
}

Output:
     }
-    final BufferObjectDataOutput out = serializationService.pop();
-    final byte[] binary;
-    try {
-        decompress(compressedBinary, out);
-        binary = out.toByteArray();
-    } finally {
-        serializationService.push(out);
-    }
+    final byte[] binary = getClassDefBinary(compressedBinary);
     final ClassDefinitionImpl cd = new ClassDefinitionImpl();


Input:
private IUIMatchingMode[] getMatchModel() {
    IUIMatchingMode[] allMatchingModel = TMAP_MATCHING_MODE.values();
    List<IUIMatchingMode> avilable = new ArrayList<IUIMatchingMode>();
    for (IUIMatchingMode matchingMode : allMatchingModel) {
        final String text = matchingMode.getLabel();
        if (matchingMode == TMAP_MATCHING_MODE.LAST_MATCH) {
            continue;
        }
        if (getMapperManager().isBigDataProcess() && matchingMode == TMAP_MATCHING_MODE.FIRST_MATCH) {
            continue;
        }
        if (text.length() != 0) {
            if (matchingMode == TMAP_MATCHING_MODE.ALL_ROWS && getInputTable().getMatchingMode() != TMAP_MATCHING_MODE.ALL_ROWS || matchingMode != TMAP_MATCHING_MODE.ALL_ROWS && getInputTable().getMatchingMode() == TMAP_MATCHING_MODE.ALL_ROWS) {
            } else {
                if (getMapperManager().isMRProcess() && matchingMode == TMAP_MATCHING_MODE.ALL_MATCHES) {
                    avilable.add(0, matchingMode);
                } else {
                    avilable.add(matchingMode);
                }
            }
        }
    }
    return avilable.toArray(new IUIMatchingMode[avilable.size()]);
}

Output:
         if (text.length() != 0) {
-            if (matchingMode == TMAP_MATCHING_MODE.ALL_ROWS && getInputTable().getMatchingMode() != TMAP_MATCHING_MODE.ALL_ROWS || matchingMode != TMAP_MATCHING_MODE.ALL_ROWS && getInputTable().getMatchingMode() == TMAP_MATCHING_MODE.ALL_ROWS) {
+            if (getMapperManager().isMRProcess() && matchingMode == TMAP_MATCHING_MODE.ALL_MATCHES) {
+                avilable.add(0, matchingMode);
             } else {


Input:
private synchronized int _releaseAllReadPermissions() {
    Thread current = Thread.currentThread();
    AccessRecord record = null;
    if (current == _lastReader) {
        record = _lastReaderRecord;
    } else {
        record = _getAccessRecord(current, false);
    }
    if (record == null || record.readDepth == 0) {
        return 0;
    } else {
        _numReaders--;
        if (_numReaders == 0) {
            notifyAll();
        }
        int result = record.readDepth;
        record.failedReadAttempts += result;
        record.readDepth = 0;
        return result;
    }
}

Output:
         _numReaders--;
-        if (_numReaders == 0) {
-            notifyAll();
-        }
+        notifyAll();
         int result = record.readDepth;


Input:
public void tracef(String fmt, Object... args) {
    trace(String.format(fmt, args));
}

Output:
 public void tracef(String fmt, Object... args) {
-    trace(String.format(fmt, args));
+    if (isTraceEnabled())
+        log(LEVEL_TRACE, String.format(fmt, args), null);
 }


Input:
public ArrayList<int[]> placeBlockCircleLine(int[] ai, int[] ai1, double distance, double distance2, IBlockState state) {
    ArrayList<int[]> places = new ArrayList<int[]>();
    int[] ai2 = { 0, 0, 0 };
    byte byte0 = 0;
    int j = 0;
    for (; byte0 < 3; byte0++) {
        ai2[byte0] = ai1[byte0] - ai[byte0];
        if (Math.abs(ai2[byte0]) > Math.abs(ai2[j])) {
            j = byte0;
        }
    }
    if (ai2[j] == 0) {
        return null;
    }
    byte byte1 = otherCoordPairs[j];
    byte byte2 = otherCoordPairs[j + 3];
    byte byte3;
    if (ai2[j] > 0) {
        byte3 = 1;
    } else {
        byte3 = -1;
    }
    double d = (double) ai2[byte1] / (double) ai2[j];
    double d1 = (double) ai2[byte2] / (double) ai2[j];
    int[] ai3 = { 0, 0, 0 };
    int k = 0;
    for (int l = ai2[j] + byte3; k != l; k += byte3) {
        ai3[j] = MathHelper.floor((double) (ai[j] + k) + 0.5D);
        ai3[byte1] = MathHelper.floor((double) ai[byte1] + (double) k * d + 0.5D);
        ai3[byte2] = MathHelper.floor((double) ai[byte2] + (double) k * d1 + 0.5D);
        genCircle(getBlockPos(ai3), distance, distance2, state, true);
        places.add(new int[] { ai3[0], ai3[1], ai3[2] });
    }
    return places;
}

Output:
         ai3[byte2] = MathHelper.floor((double) ai[byte2] + (double) k * d1 + 0.5D);
-        genCircle(getBlockPos(ai3), distance, distance2, state, true);
+        genCircle(TCGenUtils.getBlockPos(ai3), distance, distance2, state, true);
         places.add(new int[] { ai3[0], ai3[1], ai3[2] });


Input:
private void loadAndRegisterDriver(String className) throws OdaException {
    if (className == null || className.length() == 0)
        return;
    Class driverClass = null;
    if (registeredDrivers.contains(className))
        return;
    if (logger.isLoggable(Level.INFO)) {
        logger.info("String_Node_Str" + className);
    }
    boolean driverInClassPath = false;
    try {
        Class.forName(className);
        logger.info("String_Node_Str" + className);
        driverInClassPath = true;
    } catch (ClassNotFoundException e) {
        if (logger.isLoggable(Level.FINE)) {
            logger.info("String_Node_Str" + className + "String_Node_Str");
        }
        driverClass = loadExtraDriver(className, true);
        if (driverClass == null) {
            logger.warning("String_Node_Str" + className);
            throw new JDBCException(ResourceConstants.CANNOT_LOAD_DRIVER, null, className);
        }
    }
    if (!driverInClassPath) {
        Driver driver = null;
        try {
            driver = (Driver) driverClass.newInstance();
        } catch (Exception e) {
            logger.log(Level.WARNING, "String_Node_Str" + className, e);
            throw new JDBCException(ResourceConstants.CANNOT_INSTANTIATE_DRIVER, null, className);
        }
        try {
            if (logger.isLoggable(Level.FINER))
                logger.finer("String_Node_Str" + className);
            DriverManager.registerDriver(new WrappedDriver(driver, className));
        } catch (SQLException e) {
            logger.log(Level.WARNING, "String_Node_Str", e);
        }
    }
    registeredDrivers.add(className);
}

Output:
         return;
-    Class driverClass = null;
-    if (registeredDrivers.contains(className))
+    if (isDeregistered(className)) {
+        throw new JDBCException(ResourceConstants.CANNOT_LOAD_DRIVER, null, className);
+    } else if (this.registeredDrivers.containsKey(className)) {
         return;


Input:
public void drawString(String str, float x, float y, FontInfo fontInfo, float letterSpacing, float wordSpacing, Color color, boolean linethrough, boolean overline, boolean underline, CSSValue align) {
    y = transformY(y);
    gSave();
    String text = str;
    if (fontInfo != null) {
        BaseFont baseFont = fontInfo.getBaseFont();
        String fontName = getFontName(baseFont);
        text = applyFont(fontName, fontInfo.getFontStyle(), fontInfo.getFontSize(), text);
    }
    color = color == null ? Color.black : color;
    setColor(color);
    out.print(x);
    out.print("String_Node_Str");
    out.print(y);
    out.print("String_Node_Str");
    out.print(overline ? "String_Node_Str" : "String_Node_Str");
    out.print(linethrough ? "String_Node_Str" : "String_Node_Str");
    out.print(underline ? "String_Node_Str" : "String_Node_Str");
    out.print(wordSpacing);
    out.print("String_Node_Str");
    out.print(letterSpacing);
    out.print("String_Node_Str");
    out.print(text);
    out.println("String_Node_Str");
    gRestore();
}

Output:
         BaseFont baseFont = fontInfo.getBaseFont();
-        String fontName = getFontName(baseFont);
+        String fontName = baseFont.getPostscriptFontName();
         text = applyFont(fontName, fontInfo.getFontStyle(), fontInfo.getFontSize(), text);


Input:
public boolean putOntoBattlefield(int amount, Game game, UUID sourceId, UUID controllerId) {
    Card source = game.getCard(sourceId);
    String setCode = source != null ? source.getExpansionSetCode() : null;
    GameEvent event = GameEvent.getEvent(EventType.CREATE_TOKEN, null, sourceId, controllerId, amount);
    if (!game.replaceEvent(event)) {
        amount = event.getAmount();
        for (int i = 0; i < amount; i++) {
            PermanentToken permanent = new PermanentToken(this, controllerId, setCode, game);
            game.getState().addCard(permanent);
            game.getBattlefield().addPermanent(permanent);
            this.lastAddedTokenId = permanent.getId();
            permanent.entersBattlefield(sourceId, game);
            game.applyEffects();
            game.fireEvent(new ZoneChangeEvent(permanent, controllerId, Zone.OUTSIDE, Zone.BATTLEFIELD));
        }
        return true;
    }
    return false;
}

Output:
             game.getState().addCard(permanent);
-            game.getBattlefield().addPermanent(permanent);
+            game.addPermanent(permanent);
             this.lastAddedTokenId = permanent.getId();


Input:
public static ModelResourceLocation getItemResourceLocation(Item item, String suffix) {
    return new ModelResourceLocation(Utils.getNameForItem(item) + suffix, "String_Node_Str");
}

Output:
 public static ModelResourceLocation getItemResourceLocation(Item item, String suffix) {
-    return new ModelResourceLocation(Utils.getNameForItem(item) + suffix, "String_Node_Str");
+    return new ModelResourceLocation(Utils.getNameForItem(item).replace("String_Node_Str", "String_Node_Str") + suffix, "String_Node_Str");
 }


Input:
public void mouseClicked(MouseEvent e) {
    if (mainFrame.getNoEventsMode())
        return;
    Object source = e.getSource();
    if ((System.currentTimeMillis() - doubleClickTime) < DOUBLE_CLICK_INTERVAL) {
        if (doubleClickCounter == 1) {
            doubleClickCounter = 2;
            e.consume();
        }
    } else {
        doubleClickTime = System.currentTimeMillis();
        doubleClickCounter = 1;
    }
    if (source == this && DesktopManager.isLeftMouseButton(e)) {
        if ((doubleClickCounter == 1) && (System.currentTimeMillis() - selectionChangedTimestamp) > EDIT_NAME_CLICK_DELAY) {
            int clickX = e.getX();
            Point p = new Point(clickX, e.getY());
            final int row = rowAtPoint(p);
            final int viewColumn = columnAtPoint(p);
            final int column = convertColumnIndexToModel(viewColumn);
            if (row == currentRow && !isParentFolderSelected() && (column == Columns.NAME || column == Columns.DATE || column == Columns.PERMISSIONS)) {
                FontMetrics fm = getFontMetrics(FileTableCellRenderer.getCellFont());
                int labelWidth = fm.stringWidth((String) tableModel.getValueAt(row, column));
                int columnX = (int) getTableHeader().getHeaderRect(viewColumn).getX();
                if (clickX < columnX + CellLabel.CELL_BORDER_WIDTH || clickX > columnX + labelWidth + CellLabel.CELL_BORDER_WIDTH)
                    return;
                if (hasFocus() && System.currentTimeMillis() - focusGainedTime > 100) {
                    new Thread() {
                        public void run() {
                            try {
                                sleep(800);
                            } catch (InterruptedException e) {
                            }
                            if ((System.currentTimeMillis() - lastDoubleClickTimestamp) > 1000 && row == currentRow) {
                                if (column == Columns.NAME) {
                                    if (!isEditing())
                                        editCurrentFilename();
                                } else if (column == Columns.DATE) {
                                    ActionManager.performAction(com.mucommander.ui.action.impl.ChangeDateAction.Descriptor.ACTION_ID, mainFrame);
                                } else if (column == Columns.PERMISSIONS) {
                                    if (getSelectedFile().getChangeablePermissions().getIntValue() != 0)
                                        ActionManager.performAction(com.mucommander.ui.action.impl.ChangePermissionsAction.Descriptor.ACTION_ID, mainFrame);
                                }
                            }
                        }
                    }.start();
                }
            }
        } else if (doubleClickCounter == 2) {
            this.lastDoubleClickTimestamp = System.currentTimeMillis();
            ActionManager.performAction(e.isShiftDown() ? com.mucommander.ui.action.impl.OpenNativelyAction.Descriptor.ACTION_ID : com.mucommander.ui.action.impl.OpenAction.Descriptor.ACTION_ID, mainFrame);
        }
    }
}

Output:
     Object source = e.getSource();
-    if ((System.currentTimeMillis() - doubleClickTime) < DOUBLE_CLICK_INTERVAL) {
+    if ((System.currentTimeMillis() - doubleClickTime) < DOUBLE_CLICK_INTERVAL && selectionChangedTimestamp < doubleClickTime) {
         if (doubleClickCounter == 1) {


Input:
private File jar(final Class<?> resource) {
    final String name = resource.getName().replace("String_Node_Str", System.getProperty("String_Node_Str"));
    final URL res = this.getClass().getResource(String.format("String_Node_Str", name));
    if (res == null) {
        throw new IllegalStateException(String.format("String_Node_Str", name));
    }
    final String path = res.getFile().replaceAll("String_Node_Str", "String_Node_Str");
    File file;
    if ("String_Node_Str".equals(FilenameUtils.getExtension(path))) {
        file = new File(URI.create(path).getPath());
    } else {
        file = new File(path).getParentFile().getParentFile().getParentFile().getParentFile();
    }
    Logger.debug(this, "String_Node_Str", resource.getName(), file);
    return file;
}

Output:
 private File jar(final Class<?> resource) {
-    final String name = resource.getName().replace("String_Node_Str", System.getProperty("String_Node_Str"));
+    final String name = resource.getName().replace("String_Node_Str", "String_Node_Str");
     final URL res = this.getClass().getResource(String.format("String_Node_Str", name));


Input:
public void testSingleTopicTwoNodeMultipleMessagesTestCase(QualityOfService qualityOfService) throws MqttException, XPathExpressionException {
    String topic = "String_Node_Str";
    int noOfSubscribers = 1;
    int noOfPublishers = 1;
    int noOfMessages = 100;
    boolean saveMessages = false;
    MQTTClientEngine mqttClientEngine = new MQTTClientEngine();
    MQTTClientConnectionConfiguration clientConnectionConfiguration = buildConfiguration(automationContextForMB2);
    mqttClientEngine.createSubscriberConnection(topic, qualityOfService, noOfSubscribers, saveMessages, ClientMode.BLOCKING, clientConnectionConfiguration);
    mqttClientEngine.createPublisherConnection(topic, qualityOfService, MQTTConstants.TEMPLATE_PAYLOAD, noOfPublishers, noOfMessages, ClientMode.BLOCKING, clientConnectionConfiguration);
    mqttClientEngine.waitUntilAllMessageReceivedAndShutdownClients();
    Assert.assertEquals(mqttClientEngine.getReceivedMessageCount(), noOfMessages, "String_Node_Str");
}

Output:
     int noOfMessages = 100;
-    boolean saveMessages = false;
+    boolean saveMessages = true;
     MQTTClientEngine mqttClientEngine = new MQTTClientEngine();


Input:
public static ItemStack simulateAddToOccupiedInventorySlot(IInventory inventory, int slot, ItemStack stack, ItemStack existingStack) {
    int stackLimit = Math.min(inventory.getInventoryStackLimit(), stack.getMaxStackSize());
    if (stack.stackSize + existingStack.stackSize > stackLimit) {
        stack.stackSize -= stackLimit - existingStack.stackSize;
        return stack;
    }
    return stackLimit >= stack.stackSize ? null : stack.splitStack(stack.stackSize - stackLimit);
}

Output:
     int stackLimit = Math.min(inventory.getInventoryStackLimit(), stack.getMaxStackSize());
-    if (stack.stackSize + existingStack.stackSize > stackLimit) {
+    if (stack.stackSize + existingStack.stackSize > stackLimit && stackLimit > existingStack.stackSize) {
         stack.stackSize -= stackLimit - existingStack.stackSize;


Input:
protected boolean reportPackageIsNotExpectedPackage(CompilationUnitDeclaration compUnitDecl) {
    if (!isScript && compUnitDecl != null && compUnitDecl.compilationResult != null && compUnitDecl.compilationResult.compilationUnit != null) {
        char[][] packageName = compUnitDecl.compilationResult.compilationUnit.getPackageName();
        String shouldBe = packageName == null ? "String_Node_Str" : CharOperation.toString(packageName);
        String actuallyIs = compUnitDecl.currentPackage == null ? "String_Node_Str" : CharOperation.toString(compUnitDecl.currentPackage.tokens);
        if (actuallyIs.length() > 0 && !shouldBe.equals(actuallyIs)) {
            problemReporter().packageIsNotExpectedPackage(compUnitDecl);
            return true;
        }
    }
    return false;
}

Output:
 protected boolean reportPackageIsNotExpectedPackage(CompilationUnitDeclaration compUnitDecl) {
-    if (!isScript && compUnitDecl != null && compUnitDecl.compilationResult != null && compUnitDecl.compilationResult.compilationUnit != null) {
-        char[][] packageName = compUnitDecl.compilationResult.compilationUnit.getPackageName();
-        String shouldBe = packageName == null ? "String_Node_Str" : CharOperation.toString(packageName);
-        String actuallyIs = compUnitDecl.currentPackage == null ? "String_Node_Str" : CharOperation.toString(compUnitDecl.currentPackage.tokens);
-        if (actuallyIs.length() > 0 && !shouldBe.equals(actuallyIs)) {
+    if (compUnitDecl != null && compUnitDecl.compilationResult != null && compUnitDecl.compilationResult.compilationUnit != null) {
+        char[][] expectedPackage = compUnitDecl.compilationResult.compilationUnit.getPackageName();
+        if (expectedPackage != null && !CharOperation.equals(expectedPackage, compUnitDecl.currentPackage != null ? compUnitDecl.currentPackage.tokens : CharOperation.NO_CHAR_CHAR)) {
             problemReporter().packageIsNotExpectedPackage(compUnitDecl);


Input:
protected void encode(ChannelHandlerContext ctx, WeixinResponse response, List<Object> out) throws WeixinException {
    MessageTransfer messageTransfer = ctx.channel().attr(Consts.MESSAGE_TRANSFER_KEY).get();
    AesToken aesToken = messageTransfer.getAesToken();
    EncryptType encryptType = messageTransfer.getEncryptType();
    StringBuilder content = new StringBuilder();
    if (response instanceof BlankResponse) {
        content.append(response.toContent());
    } else {
        content.append("String_Node_Str");
        content.append(String.format("String_Node_Str", messageTransfer.getFromUserName()));
        content.append(String.format("String_Node_Str", StringUtil.isBlank(aesToken.getWeixinId()) ? messageTransfer.getToUserName() : aesToken.getWeixinId()));
        content.append(String.format("String_Node_Str", System.currentTimeMillis() / 1000l));
        content.append(String.format("String_Node_Str", response.getMsgType()));
        content.append(response.toContent());
        content.append("String_Node_Str");
        if (encryptType == EncryptType.AES) {
            String nonce = RandomUtil.generateString(32);
            String timestamp = String.valueOf(System.currentTimeMillis() / 1000l);
            String encrtypt = MessageUtil.aesEncrypt(aesToken.getWeixinId(), aesToken.getAesKey(), content.toString());
            String msgSignature = MessageUtil.signature(aesToken.getToken(), nonce, timestamp, encrtypt);
            content.delete(0, content.length());
            content.append("String_Node_Str");
            content.append(String.format("String_Node_Str", nonce));
            content.append(String.format("String_Node_Str", timestamp));
            content.append(String.format("String_Node_Str", msgSignature));
            content.append(String.format("String_Node_Str", encrtypt));
            content.append("String_Node_Str");
        }
    }
    ctx.writeAndFlush(HttpUtil.createHttpResponse(content.toString(), OK, Consts.CONTENTTYPE$APPLICATION_XML));
    logger.info("String_Node_Str", encryptType, content);
}

Output:
         content.append(String.format("String_Node_Str", messageTransfer.getFromUserName()));
-        content.append(String.format("String_Node_Str", StringUtil.isBlank(aesToken.getWeixinId()) ? messageTransfer.getToUserName() : aesToken.getWeixinId()));
+        content.append(String.format("String_Node_Str", messageTransfer.getToUserName()));
         content.append(String.format("String_Node_Str", System.currentTimeMillis() / 1000l));


Input:
public void disambiguate(List<Token> sentence) throws Exception {
    execStats = new ExecuteStatistics();
    System.out.println();
    for (int i = 0; i < sentence.size(); i++) {
        System.out.print("String_Node_Str");
        Token token = sentence.get(i);
        if (token.isToDisambiguate() && token.getSynsetList().isEmpty()) {
            Map<String, Float> contextBag = buildContext(sentence, i);
            if (token.getPos() != POSenum.OTHER) {
                List<BabelSense> senses = null;
                if (token.getPos() == POSenum.NOUN) {
                    senses = lookupSense(language, token.getLemma(), POS.NOUN);
                } else if (token.getPos() == POSenum.VERB) {
                    senses = lookupSense(language, token.getLemma(), POS.VERB);
                } else if (token.getPos() == POSenum.ADJ) {
                    senses = lookupSense(language, token.getLemma(), POS.ADJECTIVE);
                } else if (token.getPos() == POSenum.ADV) {
                    senses = lookupSense(language, token.getLemma(), POS.ADVERB);
                }
                if (senses != null) {
                    List<Map<String, Float>> buildGlossBag = buildGlossBag(senses);
                    for (int j = 0; j < senses.size(); j++) {
                        double sim = 0;
                        Map<String, Float> bag = buildGlossBag.get(j);
                        sim = sim(contextBag, bag);
                        if (senseFreq != null) {
                            if (language.equals(Language.EN)) {
                                String lemmakey = token.getLemma() + "String_Node_Str" + convertPosEnum(token.getPos());
                                float freq = senseFreq.getFreq(lemmakey, senses.get(j).getWordNetOffset());
                                sim = 0.5 * sim + 0.5 * freq;
                            } else {
                                String mainSense = senses.get(j).getSynset().getMainSense();
                                if (mainSense != null && !mainSense.startsWith("String_Node_Str") && mainSense.length() > 0) {
                                    int si = mainSense.lastIndexOf("String_Node_Str");
                                    if (si >= 0) {
                                        String lemmakey = mainSense.substring(0, si);
                                        float maxFreq = 0;
                                        for (int l = 0; l < senses.get(j).getSynset().getWordNetOffsets().size(); l++) {
                                            float freq = senseFreq.getFreq(lemmakey, senses.get(j).getSynset().getWordNetOffsets().get(l));
                                            if (freq > maxFreq) {
                                                maxFreq = freq;
                                            }
                                        }
                                        sim = 0.5 * sim + 0.5 * maxFreq;
                                    }
                                }
                            }
                        }
                        if (outType == OUT_BABELNET) {
                            token.getSynsetList().add(new SynsetOut(senses.get(j).getSynset().getId(), sim));
                        } else if (outType == OUT_WORDNET) {
                            token.getSynsetList().add(new SynsetOut(senses.get(j).getSensekey(), sim));
                        } else {
                            throw new Exception("String_Node_Str" + outType);
                        }
                    }
                    Collections.sort(token.getSynsetList());
                }
            }
        }
    }
}

Output:
                                         String lemmakey = mainSense.substring(0, si);
-                                        float maxFreq = 0;
+                                        float maxFreq = 1 / (float) senses.size();
                                         for (int l = 0; l < senses.get(j).getSynset().getWordNetOffsets().size(); l++) {


Input:
protected int[] getConstantKeySet(int input) {
    int[] keyColumns = null;
    Contract contract = getPactContract();
    if (contract instanceof AbstractPact<?>) {
        AbstractPact<?> abstractPact = (AbstractPact<?>) contract;
        keyColumns = abstractPact.getKeyColumnNumbers(input);
        if (keyColumns != null) {
            for (int keyColumn : keyColumns) {
                if (isFieldKept(input, keyColumn) == false) {
                    keyColumns = null;
                    break;
                }
            }
        }
    }
    return keyColumns;
}

Output:
                 if (isFieldKept(input, keyColumn) == false) {
-                    keyColumns = null;
-                    break;
+                    return null;
                 }


Input:
protected Set<QName> processAspects(Set<QName> aspects) {
    Set<QName> result = new HashSet<QName>(aspects);
    result.remove(ASPECT_VERSION);
    result.remove(ASPECT_RECORDED_VERSION);
    for (QName aspect : aspects) {
        if (!ASPECT_VERSIONABLE.equals(aspect) && (recordService.isRecordMetadataAspect(aspect) || ArrayUtils.contains(RecordServiceImpl.RECORD_MODEL_URIS, aspect.getNamespaceURI()))) {
            result.remove(aspect);
        }
    }
    return result;
}

Output:
     for (QName aspect : aspects) {
-        if (!ASPECT_VERSIONABLE.equals(aspect) && (recordService.isRecordMetadataAspect(aspect) || ArrayUtils.contains(RecordServiceImpl.RECORD_MODEL_URIS, aspect.getNamespaceURI()))) {
+        if (!ASPECT_VERSIONABLE.equals(aspect) && (recordService.isRecordMetadataAspect(aspect) || RECORD_MODEL_URIS.contains(aspect.getNamespaceURI()))) {
             result.remove(aspect);


Input:
public void getJoinCond(ASTNode node) {
    if (node == null) {
        return;
    }
    try {
        int rootType = node.getToken().getType();
        if (rootType == TOK_JOIN || rootType == TOK_LEFTOUTERJOIN || rootType == TOK_RIGHTOUTERJOIN || rootType == TOK_FULLOUTERJOIN || rootType == TOK_LEFTSEMIJOIN || rootType == TOK_UNIQUEJOIN) {
            ASTNode left = (ASTNode) node.getChild(0);
            ASTNode right = (ASTNode) node.getChild(1);
            String joinType = "String_Node_Str";
            String JoinToken = node.getToken().getText();
            if (JoinToken.equals("String_Node_Str")) {
                joinType = "String_Node_Str";
            } else if (JoinToken.equals("String_Node_Str")) {
                joinType = "String_Node_Str";
            } else if (JoinToken.equals("String_Node_Str")) {
                joinType = "String_Node_Str";
            } else if (JoinToken.equals("String_Node_Str")) {
                joinType = "String_Node_Str";
            } else if (JoinToken.equals("String_Node_Str")) {
                joinType = "String_Node_Str";
            } else if (JoinToken.equals("String_Node_Str")) {
                joinType = "String_Node_Str";
            } else {
                LOG.info("String_Node_Str" + JoinToken);
            }
            String joinCond = "String_Node_Str";
            if (node.getChildCount() > 2) {
                joinCond = HQLParser.getString((ASTNode) node.getChild(2));
            }
            String joinClause = joinType.concat(HQLParser.getString(right)).concat("String_Node_Str").concat(joinCond);
            joinCondition.append("String_Node_Str").append(joinClause);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    for (int i = 0; i < node.getChildCount(); i++) {
        ASTNode child = (ASTNode) node.getChild(i);
        getJoinCond(child);
    }
}

Output:
             if (node.getChildCount() > 2) {
-                joinCond = HQLParser.getString((ASTNode) node.getChild(2));
+                joinFilter = HQLParser.getString((ASTNode) node.getChild(2));
             }


Input:
public void addInfo(String key, String value) {
    if (info == null) {
        info = new HashMap<String, String>();
    }
    info.put(key, value);
}

Output:
     if (info == null) {
-        info = new HashMap<String, String>();
+        info = new HashMap<>();
     }


Input:
public ResultSet selectQuery(String sql, Object... params) throws SQLException {
    this.checkConnection();
    PreparedStatement stmt = this.db.prepareStatement(this.prepareQuery(sql));
    if (params != null) {
        this.bindParams(stmt, params);
    }
    return stmt.executeQuery();
}

Output:
     PreparedStatement stmt = this.db.prepareStatement(this.prepareQuery(sql));
-    if (params != null) {
-        this.bindParams(stmt, params);
+    try {
+        if (params != null) {
+            this.bindParams(stmt, params);
+        }
+        return stmt.executeQuery();
+    } finally {
+        stmt.close();
     }


Input:
public void updateCurrencyConversion(ActionRequest request, ActionResponse response) {
    General general = request.getContext().asType(General.class);
    LocalDate today = gs.getTodayDate();
    for (CurrencyConversionLine ccl : general.getCurrencyConversionLineList()) {
        CurrencyConversionLine cclCoverd = CurrencyConversionLine.all().filter("String_Node_Str", ccl.getStartCurrency(), ccl.getEndCurrency(), today).fetchOne();
        LOG.info("String_Node_Str", today, ccl);
        if (ccl.isSelected() && ccl.getToDate() == null & cclCoverd == null) {
            BigDecimal currentRate = ccs.convert(ccl.getStartCurrency(), ccl.getEndCurrency());
            if (currentRate.compareTo(new BigDecimal(-1)) == 0) {
                response.setFlash("String_Node_Str");
                break;
            }
            ccl = CurrencyConversionLine.find(ccl.getId());
            ccl.setToDate(today.minusDays(1));
            ccs.saveCurrencyConversionLine(ccl);
            BigDecimal previousRate = ccl.getExchangeRate();
            String variations = ccs.getVariations(currentRate, previousRate);
            ccs.createCurrencyConversionLine(ccl.getStartCurrency(), ccl.getEndCurrency(), today, currentRate, General.find(general.getId()), variations);
        }
    }
    response.setReload(true);
}

Output:
     General general = request.getContext().asType(General.class);
-    LocalDate today = gs.getTodayDate();
+    LocalDate today = GeneralService.getTodayDate();
     for (CurrencyConversionLine ccl : general.getCurrencyConversionLineList()) {


Input:
public static DataEngineContext newInstance(int mode, Scriptable scope, IDocArchiveReader reader, IDocArchiveWriter writer) throws BirtException {
    return new DataEngineContextImpl(mode, scope, reader, writer);
}

Output:
 public static DataEngineContext newInstance(int mode, Scriptable scope, IDocArchiveReader reader, IDocArchiveWriter writer) throws BirtException {
-    return new DataEngineContextImpl(mode, scope, reader, writer);
+    return new DataEngineContext(mode, scope, reader, writer);
 }


Input:
private void createMetadataEditorTab() {
    CTabItem item = new CTabItem(tabFolderEditors, SWT.BORDER);
    item.setText(Messages.getString("String_Node_Str"));
    SashForm inOutMetaEditorContainer = new SashForm(tabFolderEditors, SWT.SMOOTH | SWT.HORIZONTAL | SWT.SHADOW_OUT);
    inOutMetaEditorContainer.setLayout(new RowLayout(SWT.HORIZONTAL));
    item.setControl(inOutMetaEditorContainer);
    CommandStack commandStack = mapperManager.getCommandStack();
    inputMetaEditor = new MetadataTableEditorView(inOutMetaEditorContainer, SWT.BORDER);
    inputMetaEditor.setShowDbTypeColumn(true, false, false);
    inputMetaEditor.setShowDbColumnName(false, false);
    inputMetaEditor.setShowPatternColumn(false);
    inputMetaEditor.setShowTalendTypeColumn(false);
    inputMetaEditor.initGraphicComponents();
    inputMetaEditor.getExtendedTableViewer().setCommandStack(commandStack);
    outputMetaEditor = new MetadataTableEditorView(inOutMetaEditorContainer, SWT.BORDER);
    outputMetaEditor.setShowDbTypeColumn(true, false, false);
    outputMetaEditor.setShowDbColumnName(false, false);
    outputMetaEditor.setShowTalendTypeColumn(false);
    outputMetaEditor.setShowPatternColumn(false);
    outputMetaEditor.initGraphicComponents();
    outputMetaEditor.getExtendedTableViewer().setCommandStack(commandStack);
}

Output:
     inputMetaEditor.setShowDbTypeColumn(true, false, false);
-    inputMetaEditor.setShowDbColumnName(false, false);
+    inputMetaEditor.setShowDbColumnName(true, false);
     inputMetaEditor.setShowPatternColumn(false);


Input:
public void mouseEntered(MouseEvent e) {
    headerPanel.setBorder(border);
}

Output:
 public void mouseEntered(MouseEvent e) {
-    headerPanel.setBorder(border);
+    hideTimer.stop();
 }


Input:
public JsonResult<RoleBo> saveForUpdated(RoleBo roleBo, HttpSession session) {
    UserResource resource = (UserResource) session.getAttribute(WebConst.SESSION_RESOURCE);
    if (roleService.findExistRole(roleBo.getName())) {
        RoleBo role = roleService.getRoleBo(roleBo.getId());
        role.setIsactive(roleBo.getIsactive());
        role.setRoleOrgAccessBoList(roleBo.getRoleOrgAccessBoList());
        role.setModuleRoleBoList(roleBo.getModuleRoleBoList());
        role.setRemark(roleBo.getRemark());
        roleService.save(role);
        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
    }
    roleService.save(roleBo);
    return get(roleBo.getId(), session);
}

Output:
     if (roleService.findExistRole(roleBo.getName())) {
-        RoleBo role = roleService.getRoleBo(roleBo.getId());
-        role.setIsactive(roleBo.getIsactive());
-        role.setRoleOrgAccessBoList(roleBo.getRoleOrgAccessBoList());
-        role.setModuleRoleBoList(roleBo.getModuleRoleBoList());
-        role.setRemark(roleBo.getRemark());
-        roleService.save(role);
-        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
+        if (roleService.findExistRoleByName(roleBo.getName()).getId() == roleBo.getId()) {
+            roleService.save(roleBo);
+        } else {
+            return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
+        }
+    } else {
+        roleService.save(roleBo);
     }


Input:
public synchronized void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    manager = new ProcessorManager(processingEnv);
    manager.addHandlers(new MigrationHandler(), new TypeConverterHandler(), new DatabaseHandler(), new TableHandler(), new ModelContainerHandler(), new ModelViewHandler(), new ContentProviderHandler(), new TableEndpointHandler());
}

Output:
     manager = new ProcessorManager(processingEnv);
-    manager.addHandlers(new MigrationHandler(), new TypeConverterHandler(), new DatabaseHandler(), new TableHandler(), new ModelContainerHandler(), new ModelViewHandler(), new ContentProviderHandler(), new TableEndpointHandler());
+    manager.addHandlers(new MigrationHandler(), new TypeConverterHandler(), new DatabaseHandler(), new TableHandler(), new QueryModelHandler(), new ModelContainerHandler(), new ModelViewHandler(), new ContentProviderHandler(), new TableEndpointHandler());
 }


Input:
public static String convertShape(HashMap<Integer, CharacterTag> characters, MATRIX mat, int shapeNum, List<SHAPERECORD> shapeRecords, FILLSTYLEARRAY fillStyles, LINESTYLEARRAY lineStyles, boolean morphshape) {
    String ret = "String_Node_Str";
    if (mat == null) {
        mat = new MATRIX();
    }
    List<SHAPERECORD> edges = new ArrayList<>();
    int lineStyleCount = 0;
    int fillStyle0 = -1;
    int fillStyle1 = -1;
    int strokeStyle = -1;
    String fillsStr = "String_Node_Str";
    String strokesStr = "String_Node_Str";
    fillsStr += "String_Node_Str";
    strokesStr += "String_Node_Str";
    List<String> layers = new ArrayList<>();
    String currentLayer = "String_Node_Str";
    int fillStyleCount = 0;
    if (fillStyles != null) {
        for (FILLSTYLE fs : fillStyles.fillStyles) {
            fillsStr += "String_Node_Str" + (fillStyleCount + 1) + "String_Node_Str";
            fillsStr += convertFillStyle(mat, characters, fs, shapeNum);
            fillsStr += "String_Node_Str";
            fillStyleCount++;
        }
    }
    if (lineStyles != null) {
        if ((shapeNum == 4) && (lineStyles.lineStyles2 != null)) {
            for (int l = 0; l < lineStyles.lineStyles2.length; l++) {
                strokesStr += "String_Node_Str" + (lineStyleCount + 1) + "String_Node_Str";
                strokesStr += convertLineStyle(characters, lineStyles.lineStyles2[l], shapeNum);
                strokesStr += "String_Node_Str";
                lineStyleCount++;
            }
        } else if (lineStyles.lineStyles != null) {
            for (int l = 0; l < lineStyles.lineStyles.length; l++) {
                strokesStr += "String_Node_Str" + (lineStyleCount + 1) + "String_Node_Str";
                strokesStr += convertLineStyle(lineStyles.lineStyles[l], shapeNum);
                strokesStr += "String_Node_Str";
                lineStyleCount++;
            }
        }
    }
    fillsStr += "String_Node_Str";
    strokesStr += "String_Node_Str";
    int layer = 1;
    if ((fillStyleCount > 0) || (lineStyleCount > 0)) {
        currentLayer += "String_Node_Str" + (layer++) + "String_Node_Str";
        currentLayer += "String_Node_Str";
        currentLayer += "String_Node_Str" + KEY_MODE_SHAPE_LAYERS + "String_Node_Str";
        currentLayer += "String_Node_Str";
        currentLayer += "String_Node_Str";
        currentLayer += fillsStr;
        currentLayer += strokesStr;
        currentLayer += "String_Node_Str";
    }
    int x = 0;
    int y = 0;
    int startEdgeX = 0;
    int startEdgeY = 0;
    LINESTYLEARRAY actualLinestyles = lineStyles;
    int strokeStyleOrig = 0;
    fillStyleCount = fillStyles.fillStyles.length;
    for (SHAPERECORD edge : shapeRecords) {
        if (edge instanceof StyleChangeRecord) {
            StyleChangeRecord scr = (StyleChangeRecord) edge;
            boolean styleChange = false;
            int lastFillStyle1 = fillStyle1;
            int lastFillStyle0 = fillStyle0;
            int lastStrokeStyle = strokeStyle;
            if (scr.stateNewStyles) {
                fillsStr = "String_Node_Str";
                strokesStr = "String_Node_Str";
                if (fillStyleCount > 0 || lineStyleCount > 0) {
                    if ((fillStyle0 > 0) || (fillStyle1 > 0) || (strokeStyle > 0)) {
                        boolean empty = false;
                        if ((fillStyle0 <= 0) && (fillStyle1 <= 0) && (strokeStyle > 0) && morphshape) {
                            if (shapeNum == 4) {
                                if (strokeStyleOrig > 0) {
                                    if (!actualLinestyles.lineStyles2[strokeStyleOrig].hasFillFlag) {
                                        if (actualLinestyles.lineStyles2[strokeStyleOrig].color.alpha == 0) {
                                            if (actualLinestyles.lineStyles2[strokeStyleOrig].color.red == 0) {
                                                if (actualLinestyles.lineStyles2[strokeStyleOrig].color.green == 0) {
                                                    if (actualLinestyles.lineStyles2[strokeStyleOrig].color.blue == 0) {
                                                        empty = true;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (!empty) {
                            currentLayer += "String_Node_Str";
                            if (fillStyle0 > -1) {
                                currentLayer += "String_Node_Str" + fillStyle0 + "String_Node_Str";
                            }
                            if (fillStyle1 > -1) {
                                currentLayer += "String_Node_Str" + fillStyle1 + "String_Node_Str";
                            }
                            if (strokeStyle > -1) {
                                currentLayer += "String_Node_Str" + strokeStyle + "String_Node_Str";
                            }
                            currentLayer += "String_Node_Str" + convertShapeEdges(startEdgeX, startEdgeY, mat, edges) + "String_Node_Str";
                        }
                    }
                    currentLayer += "String_Node_Str";
                    currentLayer += "String_Node_Str";
                    currentLayer += "String_Node_Str";
                    currentLayer += "String_Node_Str";
                    currentLayer += "String_Node_Str";
                    currentLayer += "String_Node_Str";
                    layers.add(currentLayer);
                    currentLayer = "String_Node_Str";
                }
                currentLayer += "String_Node_Str" + (layer++) + "String_Node_Str";
                currentLayer += "String_Node_Str";
                currentLayer += "String_Node_Str" + KEY_MODE_SHAPE_LAYERS + "String_Node_Str";
                currentLayer += "String_Node_Str";
                currentLayer += "String_Node_Str";
                for (int f = 0; f < scr.fillStyles.fillStyles.length; f++) {
                    fillsStr += "String_Node_Str" + (f + 1) + "String_Node_Str";
                    fillsStr += convertFillStyle(mat, characters, scr.fillStyles.fillStyles[f], shapeNum);
                    fillsStr += "String_Node_Str";
                    fillStyleCount++;
                }
                if (shapeNum == 4) {
                    for (int l = 0; l < scr.lineStyles.lineStyles2.length; l++) {
                        strokesStr += "String_Node_Str" + (lineStyleCount + 1) + "String_Node_Str";
                        strokesStr += convertLineStyle(characters, scr.lineStyles.lineStyles2[l], shapeNum);
                        strokesStr += "String_Node_Str";
                        lineStyleCount++;
                    }
                } else {
                    for (int l = 0; l < scr.lineStyles.lineStyles.length; l++) {
                        strokesStr += "String_Node_Str" + (lineStyleCount + 1) + "String_Node_Str";
                        strokesStr += convertLineStyle(scr.lineStyles.lineStyles[l], shapeNum);
                        strokesStr += "String_Node_Str";
                        lineStyleCount++;
                    }
                }
                fillsStr += "String_Node_Str";
                strokesStr += "String_Node_Str";
                currentLayer += fillsStr;
                currentLayer += strokesStr;
                currentLayer += "String_Node_Str";
                actualLinestyles = scr.lineStyles;
            }
            if (scr.stateFillStyle0) {
                int fillStyle0_new = scr.fillStyle0;
                if (morphshape) {
                    fillStyle1 = fillStyle0_new;
                } else {
                    fillStyle0 = fillStyle0_new;
                }
                styleChange = true;
            }
            if (scr.stateFillStyle1) {
                int fillStyle1_new = scr.fillStyle1;
                if (morphshape) {
                    fillStyle0 = fillStyle1_new;
                } else {
                    fillStyle1 = fillStyle1_new;
                }
                styleChange = true;
            }
            if (scr.stateLineStyle) {
                strokeStyle = scr.lineStyle;
                strokeStyleOrig = scr.lineStyle - 1;
                styleChange = true;
            }
            if (!edges.isEmpty()) {
                if ((fillStyle0 > 0) || (fillStyle1 > 0) || (strokeStyle > 0)) {
                    boolean empty = false;
                    if ((fillStyle0 <= 0) && (fillStyle1 <= 0) && (strokeStyle > 0) && morphshape) {
                        if (shapeNum == 4) {
                            if (strokeStyleOrig > 0) {
                                if (!actualLinestyles.lineStyles2[strokeStyleOrig].hasFillFlag) {
                                    if (actualLinestyles.lineStyles2[strokeStyleOrig].color.alpha == 0) {
                                        if (actualLinestyles.lineStyles2[strokeStyleOrig].color.red == 0) {
                                            if (actualLinestyles.lineStyles2[strokeStyleOrig].color.green == 0) {
                                                if (actualLinestyles.lineStyles2[strokeStyleOrig].color.blue == 0) {
                                                    empty = true;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (!empty) {
                        currentLayer += "String_Node_Str";
                        if (fillStyle0 > -1) {
                            currentLayer += "String_Node_Str" + lastFillStyle0 + "String_Node_Str";
                        }
                        if (fillStyle1 > -1) {
                            currentLayer += "String_Node_Str" + lastFillStyle1 + "String_Node_Str";
                        }
                        if (strokeStyle > -1) {
                            currentLayer += "String_Node_Str" + lastStrokeStyle + "String_Node_Str";
                        }
                        currentLayer += "String_Node_Str" + convertShapeEdges(startEdgeX, startEdgeY, mat, edges) + "String_Node_Str";
                    }
                    startEdgeX = x;
                    startEdgeY = y;
                }
                edges.clear();
            }
        }
        edges.add(edge);
        x = edge.changeX(x);
        y = edge.changeY(y);
    }
    if (!edges.isEmpty()) {
        if ((fillStyle0 > 0) || (fillStyle1 > 0) || (strokeStyle > 0)) {
            boolean empty = false;
            if ((fillStyle0 <= 0) && (fillStyle1 <= 0) && (strokeStyle > 0) && morphshape) {
                if (shapeNum == 4) {
                    if (strokeStyleOrig > 0) {
                        if (!actualLinestyles.lineStyles2[strokeStyleOrig].hasFillFlag) {
                            if (actualLinestyles.lineStyles2[strokeStyleOrig].color.alpha == 0) {
                                if (actualLinestyles.lineStyles2[strokeStyleOrig].color.red == 0) {
                                    if (actualLinestyles.lineStyles2[strokeStyleOrig].color.green == 0) {
                                        if (actualLinestyles.lineStyles2[strokeStyleOrig].color.blue == 0) {
                                            empty = true;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (!empty) {
                currentLayer += "String_Node_Str";
                if (fillStyle0 > -1) {
                    currentLayer += "String_Node_Str" + fillStyle0 + "String_Node_Str";
                }
                if (fillStyle1 > -1) {
                    currentLayer += "String_Node_Str" + fillStyle1 + "String_Node_Str";
                }
                if (strokeStyle > -1) {
                    currentLayer += "String_Node_Str" + strokeStyle + "String_Node_Str";
                }
                currentLayer += "String_Node_Str" + convertShapeEdges(startEdgeX, startEdgeY, mat, edges) + "String_Node_Str";
            }
        }
    }
    edges.clear();
    fillsStr += "String_Node_Str";
    strokesStr += "String_Node_Str";
    currentLayer += "String_Node_Str";
    currentLayer += "String_Node_Str";
    currentLayer += "String_Node_Str";
    currentLayer += "String_Node_Str";
    currentLayer += "String_Node_Str";
    currentLayer += "String_Node_Str";
    layers.add(currentLayer);
    for (int l = layers.size() - 1; l >= 0; l--) {
        ret += layers.get(l);
    }
    return ret;
}

Output:
     strokesStr += "String_Node_Str";
-    currentLayer += "String_Node_Str";
-    currentLayer += "String_Node_Str";
-    currentLayer += "String_Node_Str";
-    currentLayer += "String_Node_Str";
-    currentLayer += "String_Node_Str";
-    currentLayer += "String_Node_Str";
-    layers.add(currentLayer);
+    if (!currentLayer.equals("String_Node_Str")) {
+        currentLayer += "String_Node_Str";
+        currentLayer += "String_Node_Str";
+        currentLayer += "String_Node_Str";
+        currentLayer += "String_Node_Str";
+        currentLayer += "String_Node_Str";
+        currentLayer += "String_Node_Str";
+        layers.add(currentLayer);
+    }
     for (int l = layers.size() - 1; l >= 0; l--) {


Input:
public void should_ReturnExpectedRecordedResponse_FromAnotherValidUrl() throws Exception {
    final String requestUrl = String.format("String_Node_Str", STUBS_URL, "String_Node_Str");
    final HttpRequest request = HttpUtils.constructHttpRequest(HttpMethods.GET, requestUrl);
    final HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setContentType(Common.HEADER_APPLICATION_JSON);
    request.setHeaders(requestHeaders);
    final HttpResponse response = request.execute();
    final HttpHeaders headers = response.getHeaders();
    assertThat(headers.getContentType().contains("String_Node_Str")).isTrue();
    String responseContent = response.parseAsString().trim();
    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK_200);
    assertThat(responseContent).contains("String_Node_Str");
}

Output:
     final HttpHeaders requestHeaders = new HttpHeaders();
-    requestHeaders.setContentType(Common.HEADER_APPLICATION_JSON);
+    requestHeaders.setContentType(HEADER_APPLICATION_JSON);
     request.setHeaders(requestHeaders);


Input:
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
    Throwable cause = e.getCause();
    switch(exceptionsHandled.incrementAndGet()) {
        case 1:
            break;
        case 2:
            LOG.error("String_Node_Str", ctx.getChannel(), cause);
        default:
            return;
    }
    LOG.error("String_Node_Str", ctx.getChannel(), cause);
    if (ctx.getChannel().isConnected() && !channelClosed) {
        HttpResponse response = (cause instanceof HandlerException) ? ((HandlerException) cause).createFailureResponse() : new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR);
        Channels.write(ctx, e.getFuture(), response);
        e.getFuture().addListener(ChannelFutureListener.CLOSE);
    }
}

Output:
     }
-    LOG.error("String_Node_Str", ctx.getChannel(), cause);
+    if (cause instanceof HandlerException && ((HandlerException) cause).getFailureStatus() != HttpResponseStatus.INTERNAL_SERVER_ERROR) {
+        LOG.debug("String_Node_Str", ctx.getChannel(), cause);
+    } else {
+        LOG.error("String_Node_Str", ctx.getChannel(), cause);
+    }
     if (ctx.getChannel().isConnected() && !channelClosed) {


Input:
public synchronized void load() {
    try {
        this.properties.load(new FileInputStream(this.fileName));
    } catch (Exception ex) {
        Messaging.log("String_Node_Str" + this.fileName, Level.SEVERE);
    }
}

Output:
     try {
-        this.properties.load(new FileInputStream(this.fileName));
+        stream = new FileInputStream(this.fileName);
+        this.properties.load(stream);
     } catch (Exception ex) {


Input:
private void prepareLevels(QueryDefinition query, List resultMetaList, Map levelNameColumnNamePair, TabularHierarchyHandle hierHandle) {
    List levels = hierHandle.getContents(TabularHierarchyHandle.LEVELS_PROP);
    for (int j = 0; j < levels.size(); j++) {
        TabularLevelHandle level = (TabularLevelHandle) levels.get(j);
        ColumnMeta temp = new ColumnMeta(level.getName());
        resultMetaList.add(temp);
        levelNameColumnNamePair.put(level.getColumnName(), temp);
        Iterator it = level.attributesIterator();
        while (it.hasNext()) {
            LevelAttributeHandle levelAttr = (LevelAttributeHandle) it.next();
            ColumnMeta meta = new ColumnMeta(level.getName() + "String_Node_Str" + levelAttr.getName());
            meta.setDataType(ModelAdapter.adaptModelDataType(levelAttr.getDataType()));
            query.addResultSetExpression(meta.getName(), new ScriptExpression(ExpressionUtil.createJSDataSetRowExpression(levelAttr.getName())));
            resultMetaList.add(meta);
        }
        GroupDefinition gd = new GroupDefinition();
        gd.setKeyExpression(ExpressionUtil.createJSRowExpression(level.getName()));
        query.addResultSetExpression(level.getName(), new ScriptExpression(ExpressionUtil.createJSDataSetRowExpression(level.getColumnName())));
        query.addGroup(gd);
    }
}

Output:
         TabularLevelHandle level = (TabularLevelHandle) levels.get(j);
-        ColumnMeta temp = new ColumnMeta(level.getName());
+        ColumnMeta temp = new ColumnMeta(level.getColumnName());
         resultMetaList.add(temp);


Input:
public IResultSet<Value, URI, Literal> selectQuery(String query, String graph) {
    connect();
    final SPARQLParser parser = new SPARQLParser();
    CloseableIteration<? extends BindingSet, QueryEvaluationException> sparqlResults = null;
    ParsedQuery parsedQuery = null;
    try {
        parsedQuery = parser.parseQuery(query, null);
    } catch (MalformedQueryException e) {
        e.printStackTrace();
    }
    try {
        sparqlResults = sail.getConnection().evaluate(parsedQuery.getTupleExpr(), parsedQuery.getDataset(), new EmptyBindingSet(), false);
    } catch (SailException e) {
        e.printStackTrace();
    }
    return new SailResultSet(sparqlResults);
}

Output:
     try {
-        sparqlResults = sail.getConnection().evaluate(parsedQuery.getTupleExpr(), parsedQuery.getDataset(), new EmptyBindingSet(), false);
+        sparqlResults = connection.evaluate(parsedQuery.getTupleExpr(), parsedQuery.getDataset(), new EmptyBindingSet(), false);
     } catch (SailException e) {


Input:
private AdHocChatRoomMsnImpl createLocalAdHocChatRoomInstance(MsnSwitchboard switchboard) {
    AdHocChatRoomMsnImpl adHocChatRoom = (AdHocChatRoomMsnImpl) this.adHocChatRoomCache.get(String.valueOf(switchboard.hashCode()));
    if (adHocChatRoom == null) {
        String name = String.valueOf(switchboard.hashCode());
        adHocChatRoom = new AdHocChatRoomMsnImpl(name, provider, switchboard);
        this.adHocChatRoomCache.put(switchboard, adHocChatRoom);
        Object attachment = switchboard.getAttachment();
        if (attachment != null && pendingAdHocChatRoomList.containsKey(attachment)) {
            pendingAdHocChatRoomList.remove(attachment);
        }
    }
    adHocChatRoom.join();
    return adHocChatRoom;
}

Output:
 private AdHocChatRoomMsnImpl createLocalAdHocChatRoomInstance(MsnSwitchboard switchboard) {
-    AdHocChatRoomMsnImpl adHocChatRoom = (AdHocChatRoomMsnImpl) this.adHocChatRoomCache.get(String.valueOf(switchboard.hashCode()));
+    AdHocChatRoomMsnImpl adHocChatRoom = (AdHocChatRoomMsnImpl) this.adHocChatRoomCache.get(switchboard);
     if (adHocChatRoom == null) {