Input:
public static double[] DBA_update(double[] C, double[][] sequences, int w) {
    final ArrayList<Double>[] tupleAssociation = new ArrayList[C.length];
    for (int i = 0; i < tupleAssociation.length; i++) {
        tupleAssociation[i] = new ArrayList<Double>(sequences.length);
    }
    int nbTuplesAverageSeq, i, j, indiceRes;
    double res = 0.0;
    int centerLength = C.length;
    int seqLength, jStart, jStop;
    ;
    for (double[] T : sequences) {
        seqLength = T.length;
        costMatrix[0][0] = distanceTo(C[0], T[0]);
        pathMatrix[0][0] = NIL;
        optimalPathLength[0][0] = 0;
        for (i = 1; i < Math.min(centerLength, 1 + w); i++) {
            costMatrix[i][0] = costMatrix[i - 1][0] + distanceTo(C[i], T[0]);
            pathMatrix[i][0] = UP;
            optimalPathLength[i][0] = i;
        }
        for (j = 1; j < Math.min(seqLength, 1 + w); j++) {
            costMatrix[0][j] = costMatrix[0][j - 1] + distanceTo(T[j], C[0]);
            pathMatrix[0][j] = LEFT;
            optimalPathLength[0][j] = j;
        }
        if (j < seqLength)
            costMatrix[0][j] = Double.POSITIVE_INFINITY;
        for (i = 1; i < centerLength; i++) {
            jStart = Math.max(1, i - w);
            jStop = Math.min(seqLength, i + w + 1);
            costMatrix[i][jStart - 1] = Double.POSITIVE_INFINITY;
            for (j = jStart; j < jStop; j++) {
                indiceRes = ArgMin3(costMatrix[i - 1][j - 1], costMatrix[i][j - 1], costMatrix[i - 1][j]);
                pathMatrix[i][j] = indiceRes;
                switch(indiceRes) {
                    case DIAGONAL:
                        res = costMatrix[i - 1][j - 1];
                        optimalPathLength[i][j] = optimalPathLength[i - 1][j - 1] + 1;
                        break;
                    case LEFT:
                        res = costMatrix[i][j - 1];
                        optimalPathLength[i][j] = optimalPathLength[i][j - 1] + 1;
                        break;
                    case UP:
                        res = costMatrix[i - 1][j];
                        optimalPathLength[i][j] = optimalPathLength[i - 1][j] + 1;
                        break;
                }
                costMatrix[i][j] = res + distanceTo(C[i], T[j]);
            }
            if (jStop < seqLength)
                costMatrix[i][jStop] = Double.POSITIVE_INFINITY;
        }
        nbTuplesAverageSeq = optimalPathLength[centerLength - 1][seqLength - 1] + 1;
        i = centerLength - 1;
        j = seqLength - 1;
        for (int t = nbTuplesAverageSeq - 1; t >= 0; t--) {
            tupleAssociation[i].add(T[j]);
            switch(pathMatrix[i][j]) {
                case DIAGONAL:
                    i = i - 1;
                    j = j - 1;
                    break;
                case LEFT:
                    j = j - 1;
                    break;
                case UP:
                    i = i - 1;
                    break;
            }
        }
    }
    for (int t = 0; t < centerLength; t++) {
        C[t] = barycenter((tupleAssociation[t].toArray()));
    }
    return C;
}

Output:
             jStop = Math.min(seqLength, i + w + 1);
-            costMatrix[i][jStart - 1] = Double.POSITIVE_INFINITY;
+            if (jStart != 1)
+                costMatrix[i][jStart - 1] = Double.POSITIVE_INFINITY;
             for (j = jStart; j < jStop; j++) {


Input:
private void joinViaPossibleMembers() {
    try {
        failedConnections.clear();
        final Collection<Address> colPossibleAddresses = getPossibleMembers();
        colPossibleAddresses.remove(address);
        for (final Address possibleAddress : colPossibleAddresses) {
            logger.log(Level.FINEST, "String_Node_Str" + possibleAddress);
            connectionManager.getOrConnect(possibleAddress);
        }
        boolean found = false;
        int numberOfSeconds = 0;
        final int connectionTimeoutSeconds = config.getNetworkConfig().getJoin().getTcpIpConfig().getConnectionTimeoutSeconds();
        while (!found && numberOfSeconds < connectionTimeoutSeconds) {
            colPossibleAddresses.removeAll(failedConnections);
            if (colPossibleAddresses.size() == 0) {
                break;
            }
            Thread.sleep(1000L);
            numberOfSeconds++;
            int numberOfJoinReq = 0;
            logger.log(Level.FINE, "String_Node_Str");
            for (Address possibleAddress : colPossibleAddresses) {
                logger.log(Level.FINEST, "String_Node_Str" + numberOfJoinReq + "String_Node_Str" + possibleAddress);
                final Connection conn = connectionManager.getOrConnect(possibleAddress);
                if (conn != null && numberOfJoinReq < 5) {
                    found = true;
                    logger.log(Level.FINEST, "String_Node_Str" + possibleAddress);
                    clusterManager.sendJoinRequest(possibleAddress);
                    numberOfJoinReq++;
                } else {
                    logger.log(Level.FINEST, "String_Node_Str" + possibleAddress);
                }
            }
        }
        logger.log(Level.FINEST, "String_Node_Str" + found);
        if (!found) {
            logger.log(Level.FINEST, "String_Node_Str");
            setAsMaster();
        } else {
            while (!joined) {
                int numberOfJoinReq = 0;
                colPossibleAddresses.removeAll(failedConnections);
                for (Address possibleAddress : colPossibleAddresses) {
                    final Connection conn = connectionManager.getOrConnect(possibleAddress);
                    if (conn != null && numberOfJoinReq < 5) {
                        logger.log(Level.FINEST, "String_Node_Str" + possibleAddress);
                        clusterManager.sendJoinRequest(possibleAddress);
                        numberOfJoinReq++;
                    } else {
                        logger.log(Level.FINEST, "String_Node_Str" + possibleAddress + "String_Node_Str");
                    }
                }
                int maxTryCount = 3;
                for (Address possibleAddress : colPossibleAddresses) {
                    if (address.hashCode() > possibleAddress.hashCode()) {
                        maxTryCount = 6;
                        break;
                    } else if (address.hashCode() == possibleAddress.hashCode()) {
                        maxTryCount = 3 + ((int) (Math.random() * 10));
                        break;
                    }
                }
                int tryCount = 0;
                while (tryCount++ < maxTryCount && (masterAddress == null)) {
                    Thread.sleep(1000L);
                }
                if (masterAddress == null) {
                    boolean masterCandidate = true;
                    for (Address address : colPossibleAddresses) {
                        if (this.address.hashCode() > address.hashCode()) {
                            masterCandidate = false;
                        }
                    }
                    if (masterCandidate) {
                        logger.log(Level.FINEST, "String_Node_Str");
                        setAsMaster();
                    }
                }
            }
        }
        colPossibleAddresses.clear();
        failedConnections.clear();
    } catch (Exception e) {
        e.printStackTrace();
        logger.log(Level.SEVERE, e.getMessage(), e);
    }
}

Output:
             int numberOfJoinReq = 0;
-            logger.log(Level.FINE, "String_Node_Str");
+            logger.log(Level.FINEST, "String_Node_Str");
             for (Address possibleAddress : colPossibleAddresses) {


Input:
public static void main(String[] args) {
    System.out.println("String_Node_Str");
    Pair<List<Trade>, Results> results = calculate();
    System.out.println("String_Node_Str");
    for (int i = 0; i < results.getFirst().size(); i++) {
        Trade trade = results.getFirst().get(i);
        Result<?> pv = results.getSecond().getCells().get(i);
        String output = "String_Node_Str" + trade.getClass().getSimpleName() + "String_Node_Str" + pv.isSuccess();
        Object pvValue = pv.getValue();
        ArgChecker.isTrue(pvValue instanceof CurrencyAmount, "String_Node_Str");
        CurrencyAmount ca = (CurrencyAmount) pvValue;
        output += "String_Node_Str" + ca;
        System.out.println(output);
        ArgChecker.isTrue(Math.abs(ca.getAmount()) < TOLERANCE_PV, "String_Node_Str");
    }
    if (args.length > 0) {
        if (args[0].equals("String_Node_Str")) {
            performance_calibration_pricing();
        }
    }
    System.out.println("String_Node_Str");
}

Output:
         if (args[0].equals("String_Node_Str")) {
-            performance_calibration_pricing();
+            performanceCalibrationPricing();
         }


Input:
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    try {
        FLog.d("String_Node_Str" + requestCode);
        if (requestCode == TO_IMAGECATALOG) {
            String imgURL = (String) intent.getSerializableExtra("String_Node_Str");
            for (int i = 0; i < statuses.size(); ++i) {
                if (imgURL.equals(statuses.get(i).bigImgURL)) {
                    listView.setSelection(Math.min(i, listView.getCount()));
                    break;
                }
            }
        } else if (requestCode == TO_POST) {
            String posted = "String_Node_Str";
            try {
                posted = (String) intent.getSerializableExtra("String_Node_Str");
            } catch (Exception e) {
            }
            this.onClickReloadBtn(null);
        } else {
            FLog.d("String_Node_Str");
        }
    } catch (Exception e) {
        FLog.d("String_Node_Str", e);
    }
}

Output:
             }
-            this.onClickReloadBtn(null);
+            if (!posted.equals("String_Node_Str")) {
+                this.onClickReloadBtn(null);
+            }
         } else {


Input:
public boolean prepare(Network network, NicProfile nic, VirtualMachineProfile<? extends VirtualMachine> vm, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException {
    if (canHandle(network.getGuestType(), dest.getDataCenter())) {
        boolean isRedundant = _configDao.getValue("String_Node_Str").equals("String_Node_Str");
        if (vm.getType() != VirtualMachine.Type.User) {
            return false;
        }
        VirtualMachineProfile<UserVm> uservm = (VirtualMachineProfile<UserVm>) vm;
        List<DomainRouterVO> routers = _routerMgr.deployVirtualRouter(network, dest, uservm.getOwner(), uservm.getParameters(), isRedundant);
        List<VirtualRouter> rets = _routerMgr.addVirtualMachineIntoNetwork(network, nic, uservm, dest, context, routers);
        return (rets != null) && (!rets.isEmpty());
    } else {
        return false;
    }
}

Output:
         VirtualMachineProfile<UserVm> uservm = (VirtualMachineProfile<UserVm>) vm;
-        List<DomainRouterVO> routers = _routerMgr.deployVirtualRouter(network, dest, uservm.getOwner(), uservm.getParameters(), isRedundant);
+        List<DomainRouterVO> routers = _routerMgr.deployVirtualRouter(network, dest, _accountMgr.getAccount(network.getAccountId()), uservm.getParameters(), isRedundant);
         List<VirtualRouter> rets = _routerMgr.addVirtualMachineIntoNetwork(network, nic, uservm, dest, context, routers);


Input:
protected TemplateModel createModel(ObjectWrapper objectWrapper, ServletContext servletContext, final HttpServletRequest request, final HttpServletResponse response) throws TemplateModelException {
    try {
        AllHttpScopesHashModel params = new AllHttpScopesHashModel(objectWrapper, servletContext, request);
        ServletContextHashModel servletContextModel = (ServletContextHashModel) servletContext.getAttribute(ATTR_APPLICATION_MODEL);
        if (servletContextModel == null) {
            servletContextModel = new ServletContextHashModel(this, objectWrapper);
            servletContext.setAttribute(ATTR_APPLICATION_MODEL, servletContextModel);
            TaglibFactory taglibFactory = createTaglibFactory(objectWrapper, servletContext);
            servletContext.setAttribute(ATTR_JSP_TAGLIBS_MODEL, taglibFactory);
            initializeServletContext(request, response);
        }
        params.putUnlistedModel(KEY_APPLICATION, servletContextModel);
        params.putUnlistedModel(KEY_APPLICATION_PRIVATE, servletContextModel);
        params.putUnlistedModel(KEY_JSP_TAGLIBS, (TemplateModel) servletContext.getAttribute(ATTR_JSP_TAGLIBS_MODEL));
        HttpSessionHashModel sessionModel;
        HttpSession session = request.getSession(false);
        if (session != null) {
            sessionModel = (HttpSessionHashModel) session.getAttribute(ATTR_SESSION_MODEL);
            if (sessionModel == null || sessionModel.isOrphaned(session)) {
                sessionModel = new HttpSessionHashModel(session, objectWrapper);
                initializeSessionAndInstallModel(request, response, sessionModel, session);
            }
        } else {
            sessionModel = new HttpSessionHashModel(this, request, response, objectWrapper);
        }
        params.putUnlistedModel(KEY_SESSION, sessionModel);
        HttpRequestHashModel requestModel = (HttpRequestHashModel) request.getAttribute(ATTR_REQUEST_MODEL);
        if (requestModel == null || requestModel.getRequest() != request) {
            requestModel = new HttpRequestHashModel(request, response, objectWrapper);
            request.setAttribute(ATTR_REQUEST_MODEL, requestModel);
            request.setAttribute(ATTR_REQUEST_PARAMETERS_MODEL, createRequestParametersHashModel(request));
        }
        params.putUnlistedModel(KEY_REQUEST, requestModel);
        params.putUnlistedModel(KEY_INCLUDE, new IncludePage(request, response));
        params.putUnlistedModel(KEY_REQUEST_PRIVATE, requestModel);
        HttpRequestParametersHashModel requestParametersModel = (HttpRequestParametersHashModel) request.getAttribute(ATTR_REQUEST_PARAMETERS_MODEL);
        params.putUnlistedModel(KEY_REQUEST_PARAMETERS, requestParametersModel);
        return params;
    } catch (ServletException e) {
        throw new TemplateModelException(e);
    } catch (IOException e) {
        throw new TemplateModelException(e);
    }
}

Output:
         AllHttpScopesHashModel params = new AllHttpScopesHashModel(objectWrapper, servletContext, request);
-        ServletContextHashModel servletContextModel = (ServletContextHashModel) servletContext.getAttribute(ATTR_APPLICATION_MODEL);
-        if (servletContextModel == null) {
-            servletContextModel = new ServletContextHashModel(this, objectWrapper);
-            servletContext.setAttribute(ATTR_APPLICATION_MODEL, servletContextModel);
-            TaglibFactory taglibFactory = createTaglibFactory(objectWrapper, servletContext);
-            servletContext.setAttribute(ATTR_JSP_TAGLIBS_MODEL, taglibFactory);
-            initializeServletContext(request, response);
+        final ServletContextHashModel servletContextModel;
+        final TaglibFactory taglibFactory;
+        synchronized (lazyInitFieldsLock) {
+            if (this.servletContextModel == null) {
+                servletContextModel = new ServletContextHashModel(this, objectWrapper);
+                taglibFactory = createTaglibFactory(objectWrapper, servletContext);
+                servletContext.setAttribute(ATTR_APPLICATION_MODEL, servletContextModel);
+                servletContext.setAttribute(ATTR_JSP_TAGLIBS_MODEL, taglibFactory);
+                initializeServletContext(request, response);
+                this.taglibFactory = taglibFactory;
+                this.servletContextModel = servletContextModel;
+            } else {
+                servletContextModel = this.servletContextModel;
+                taglibFactory = this.taglibFactory;
+            }
         }


Input:
private void distributedSEWrapper() throws Exception {
    TrainModelProcessor trainModelProcessor = new TrainModelProcessor();
    trainModelProcessor.setForVarSelect(true);
    trainModelProcessor.run();
    SourceType source = this.modelConfig.getDataSet().getSource();
    Configuration conf = new Configuration();
    new GenericOptionsParser(conf, new String[] { "String_Node_Str", addRuntimeJars() });
    conf.setBoolean(GuaguaMapReduceConstants.MAPRED_MAP_TASKS_SPECULATIVE_EXECUTION, true);
    conf.setBoolean(GuaguaMapReduceConstants.MAPRED_REDUCE_TASKS_SPECULATIVE_EXECUTION, true);
    conf.set(Constants.SHIFU_MODEL_CONFIG, ShifuFileUtils.getFileSystemBySourceType(source).makeQualified(new Path(super.getPathFinder().getModelConfigPath(source))).toString());
    conf.set(Constants.SHIFU_COLUMN_CONFIG, ShifuFileUtils.getFileSystemBySourceType(source).makeQualified(new Path(super.getPathFinder().getColumnConfigPath(source))).toString());
    conf.set(NNConstants.MAPRED_JOB_QUEUE_NAME, Environment.getProperty(Environment.HADOOP_JOB_QUEUE, "String_Node_Str"));
    conf.set(Constants.SHIFU_MODELSET_SOURCE_TYPE, source.toString());
    Float wrapperRatio = this.modelConfig.getVarSelect().getWrapperRatio();
    if (wrapperRatio == null) {
        log.warn("String_Node_Str");
        wrapperRatio = 0.05f;
    }
    if (wrapperRatio.compareTo(Float.valueOf(1.0f)) >= 0) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    conf.setFloat(Constants.SHIFU_VARSELECT_WRAPPER_RATIO, wrapperRatio);
    Job job = new Job(conf, "String_Node_Str" + this.modelConfig.getModelSetName());
    job.setJarByClass(getClass());
    boolean isSEVarSelMulti = Boolean.TRUE.toString().equalsIgnoreCase(Environment.getProperty(Constants.SHIFU_VARSEL_SE_MULTI, Constants.SHIFU_DEFAULT_VARSEL_SE_MULTI));
    if (isSEVarSelMulti) {
        job.setMapperClass(MultithreadedMapper.class);
        MultithreadedMapper.setMapperClass(job, VarSelectMapper.class);
        MultithreadedMapper.setNumberOfThreads(job, 6);
    } else {
        job.setMapperClass(VarSelectMapper.class);
    }
    job.setMapOutputKeyClass(LongWritable.class);
    job.setMapOutputValueClass(DoubleWritable.class);
    job.setInputFormatClass(TextInputFormat.class);
    FileInputFormat.setInputPaths(job, ShifuFileUtils.getFileSystemBySourceType(source).makeQualified(new Path(super.getPathFinder().getNormalizedDataPath())));
    job.setReducerClass(VarSelectReducer.class);
    job.setNumReduceTasks(1);
    job.setOutputKeyClass(LongWritable.class);
    job.setOutputValueClass(NullWritable.class);
    job.setOutputFormatClass(TextOutputFormat.class);
    String varSelectMSEOutputPath = super.getPathFinder().getVarSelectMSEOutputPath(source);
    FileOutputFormat.setOutputPath(job, new Path(varSelectMSEOutputPath));
    ShifuFileUtils.deleteFile(varSelectMSEOutputPath, source);
    if (job.waitForCompletion(true)) {
        if (!ShifuFileUtils.isFileExists(varSelectMSEOutputPath + Path.SEPARATOR + "String_Node_Str", source)) {
            throw new RuntimeException("String_Node_Str");
        }
        for (ColumnConfig config : super.columnConfigList) {
            if (config.isFinalSelect()) {
                config.setFinalSelect(false);
            }
        }
        List<Scanner> scanners = null;
        try {
            FileStatus[] globStatus = ShifuFileUtils.getFileSystemBySourceType(source).globStatus(new Path(varSelectMSEOutputPath + Path.SEPARATOR + "String_Node_Str"));
            if (globStatus == null || globStatus.length == 0) {
                throw new RuntimeException("String_Node_Str");
            }
            scanners = ShifuFileUtils.getDataScanners(globStatus[0].getPath().toString(), source);
            String str = null;
            int count = 0;
            while (scanners.get(0).hasNext()) {
                ++count;
                str = scanners.get(0).nextLine();
                ColumnConfig columnConfig = this.columnConfigList.get(Integer.parseInt(str));
                columnConfig.setFinalSelect(true);
                log.info("String_Node_Str", columnConfig.getColumnName());
            }
            log.info("String_Node_Str", count);
        } finally {
            for (Scanner scanner : scanners) {
                scanner.close();
            }
        }
        this.saveColumnConfigList();
        this.syncDataToHdfs(this.modelConfig.getDataSet().getSource());
    }
}

Output:
         } finally {
-            for (Scanner scanner : scanners) {
-                scanner.close();
+            if (scanners != null) {
+                for (Scanner scanner : scanners) {
+                    if (scanner != null) {
+                        scanner.close();
+                    }
+                }
             }


Input:
public ImportedModel importModel(ImportSettings settings) throws IOException {
    ImportedModel importedModel;
    URL modelURL = settings.getModelURL();
    if (!modelURL.getProtocol().equalsIgnoreCase("String_Node_Str")) {
        final String modelURLStr = modelURL.toExternalForm();
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JOptionPane.showConfirmDialog(null, "String_Node_Str" + modelURLStr + "String_Node_Str", "String_Node_Str", JOptionPane.OK_OPTION);
            }
        });
        return null;
    }
    try {
        logger.warning("String_Node_Str" + modelURL.toExternalForm());
        File f = new File(modelURL.getFile());
        if (f == null) {
            logger.warning("String_Node_Str" + modelURL.toExternalForm());
            JOptionPane.showMessageDialog(null, "String_Node_Str" + modelURL.toExternalForm(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
            return null;
        } else if (!f.canRead()) {
            logger.warning("String_Node_Str" + f.getAbsolutePath());
            JOptionPane.showMessageDialog(null, "String_Node_Str" + f.getAbsolutePath() + "String_Node_Str", "String_Node_Str", JOptionPane.ERROR_MESSAGE);
            return null;
        }
        ZipFile zipFile = null;
        ZipEntry docKmlEntry = null;
        try {
            zipFile = new ZipFile(f);
            docKmlEntry = zipFile.getEntry("String_Node_Str");
        } catch (ZipException ze) {
            logger.log(Level.WARNING, "String_Node_Str" + f.getAbsolutePath(), ze);
            return null;
        }
        KmlParser parser = new KmlParser();
        InputStream in = zipFile.getInputStream(docKmlEntry);
        try {
            parser.decodeKML(in);
        } catch (Exception ex) {
            Logger.getLogger(KmzLoader.class.getName()).log(Level.SEVERE, null, ex);
        }
        List<KmlParser.KmlModel> models = parser.getModels();
        HashMap<URL, String> textureFilesMapping = new HashMap();
        importedModel = new KmzImportedModel(modelURL, models.get(0).getHref(), textureFilesMapping);
        String zipHost = WlzipManager.getWlzipManager().addZip(zipFile);
        ZipResourceLocator zipResource = new ZipResourceLocator(zipHost, zipFile, textureFilesMapping);
        ResourceLocatorTool.addThreadResourceLocator(ResourceLocatorTool.TYPE_TEXTURE, zipResource);
        if (models.size() == 1) {
            importedModel.setModelBG(load(zipFile, models.get(0)));
        } else {
            Node modelBG = new Node();
            for (KmlParser.KmlModel model : models) {
                modelBG.attachChild(load(zipFile, model));
            }
            importedModel.setModelBG(modelBG);
        }
        ResourceLocatorTool.removeThreadResourceLocator(ResourceLocatorTool.TYPE_TEXTURE, zipResource);
        WlzipManager.getWlzipManager().removeZip(zipHost, zipFile);
    } catch (ZipException ex) {
        logger.log(Level.SEVERE, null, ex);
        throw new IOException("String_Node_Str");
    } catch (IOException ex) {
        logger.log(Level.SEVERE, null, ex);
        throw ex;
    }
    importedModel.setModelLoader(this);
    importedModel.setImportSettings(settings);
    return importedModel;
}

Output:
     try {
-        logger.warning("String_Node_Str" + modelURL.toExternalForm());
-        File f = new File(modelURL.getFile());
+        File f = null;
+        try {
+            URI uri = modelURL.toURI();
+            String path = uri.getPath();
+            f = new File(path);
+        } catch (URISyntaxException ex) {
+            Logger.getLogger(KmzLoader.class.getName()).log(Level.SEVERE, "String_Node_Str" + modelURL.toExternalForm(), ex);
+            return null;
+        }
         if (f == null) {


Input:
public String createVolume(int sizeGB, String snapshotId) {
    IaasProvider iaasInfo = getIaasProvider();
    String region = ComputeServiceBuilderUtil.extractRegion(iaasInfo);
    String zone = ComputeServiceBuilderUtil.extractZone(iaasInfo);
    if (region == null || iaasInfo == null) {
        log.fatal(String.format("String_Node_Str", region, iaasInfo));
        return null;
    }
    ComputeServiceContext context = iaasInfo.getComputeService().getContext();
    NovaApi novaApi = context.unwrapApi(NovaApi.class);
    VolumeApi volumeApi = novaApi.getVolumeExtensionForZone(region).get();
    Volume volume;
    if (StringUtils.isEmpty(snapshotId)) {
        if (log.isDebugEnabled()) {
            log.info("String_Node_Str" + zone);
        }
        volume = volumeApi.create(sizeGB, CreateVolumeOptions.Builder.availabilityZone(zone));
    } else {
        if (log.isDebugEnabled()) {
            log.info("String_Node_Str" + zone + "String_Node_Str" + snapshotId);
        }
        volume = volumeApi.create(sizeGB, CreateVolumeOptions.Builder.availabilityZone(zone).snapshotId(snapshotId));
    }
    if (volume == null) {
        log.fatal(String.format("String_Node_Str", region, zone, iaasInfo));
        return null;
    }
    String volumeId = volume.getId();
    log.info(String.format("String_Node_Str", volume.getId(), region, zone, iaasInfo, volume.getId()));
    return volumeId;
}

Output:
     String zone = ComputeServiceBuilderUtil.extractZone(iaasInfo);
-    if (region == null || iaasInfo == null) {
-        log.fatal(String.format("String_Node_Str", region, iaasInfo));
+    if (region == null) {
+        log.fatal(String.format("String_Node_Str", iaasInfo));
         return null;


Input:
public void post() throws Exception {
    ClientDispatcher myClient = new ClientDispatcher();
    TransportImpl myTransport = new TransportImpl(null);
    myClient.init(myTransport);
    FDUtil.ensureFD(_tport1.getFD());
    FDUtil.ensureFD(_tport2.getFD());
    System.err.println("String_Node_Str");
    for (int i = 0; i < 5; i++) {
        ByteBuffer myBuffer = ByteBuffer.allocate(4);
        myBuffer.putInt(i);
        Proposal myProp = new Proposal("String_Node_Str", myBuffer.array());
        myClient.send(new Envelope(myProp), _tport2.getLocalAddress());
        VoteOutcome myEv = myClient.getNext(10000);
        Assert.assertFalse((myEv == null));
        Assert.assertTrue(myEv.getResult() == VoteOutcome.Reason.VALUE);
        Assert.assertTrue(myEv.getSeqNum() == i);
    }
    Thread.sleep(5000);
    System.err.println("String_Node_Str");
    _node3 = new ServerDispatcher(new HowlLogger(_node3Log));
    _tport3 = new TransportImpl(new FailureDetectorImpl(5000, FailureDetectorImpl.OPEN_PIN));
    _node3.init(_tport3);
    _node3.getAcceptorLearner().setRecoveryGracePeriod(1000);
    FDUtil.ensureFD(_tport3.getFD());
    System.err.println("String_Node_Str");
    ByteBuffer myBuffer = ByteBuffer.allocate(4);
    myBuffer.putInt(67);
    Proposal myProp = new Proposal("String_Node_Str", myBuffer.array());
    myClient.send(new Envelope(myProp), _tport2.getLocalAddress());
    VoteOutcome myMsg = myClient.getNext(10000);
    myBuffer = ByteBuffer.allocate(4);
    myBuffer.putInt(69);
    Proposal myProp2 = new Proposal("String_Node_Str", myBuffer.array());
    System.err.println("String_Node_Str");
    myClient.send(new Envelope(myProp2), _tport2.getLocalAddress());
    myClient.getNext(10000);
    System.err.println("String_Node_Str");
    Thread.sleep(5000);
    Assert.assertTrue(_node2.getAcceptorLearner().getLowWatermark().getSeqNum() == _node3.getAcceptorLearner().getLowWatermark().getSeqNum());
    Thread.sleep(5000);
    System.err.println("String_Node_Str");
    myTransport.terminate();
}

Output:
     System.err.println("String_Node_Str");
-    _node3 = new ServerDispatcher(new HowlLogger(_node3Log));
+    _node3 = new ServerDispatcher(new HowlLogger(_node3Log), Listener.NULL_LISTENER);
     _tport3 = new TransportImpl(new FailureDetectorImpl(5000, FailureDetectorImpl.OPEN_PIN));


Input:
private synchronized boolean addWorld(final ACWorld world) {
    final String name = world.getName();
    if (name == null) {
        throw new NullPointerException();
    }
    final ACWorld ref = worlds.get(name);
    if (ref != null) {
        return false;
    }
    worlds.put(name, world);
    return true;
}

Output:
     }
-    worlds.put(name, world);
+    worlds.put(name.toUpperCase(), world);
     return true;


Input:
public void drawNode(Graphics g, ZMapWidget map, Node node) {
    User user = map.dc.users.get(map.dc.changesets.get(map.dc.changesetsIndex.get(node.changesetId)).userId);
    Profile p = Configuration.instance.getSelectedProfile();
    User[] u = p.getUsers();
    if (p.getListType() == 0) {
        drawNodeP(g, map, node);
    } else if (p.getListType() == 2) {
        for (int i = 0; i < u.length; i++) if (u[i].id == user.id) {
            drawNodeP(g, map, node);
        }
    } else {
        boolean t = false;
        for (int i = 0; i < u.length; i++) if (u[i].id == user.id) {
            t = true;
        }
        if (!t)
            drawNodeP(g, map, node);
    }
}

Output:
 public void drawNode(Graphics g, ZMapWidget map, Node node) {
-    User user = map.dc.users.get(map.dc.changesets.get(map.dc.changesetsIndex.get(node.changesetId)).userId);
-    Profile p = Configuration.instance.getSelectedProfile();
-    User[] u = p.getUsers();
-    if (p.getListType() == 0) {
+    if (isVisibleNode(map, node))
         drawNodeP(g, map, node);


Input:
private boolean canAddToContacts(Contact contact) {
    final String name = contact.getName();
    if (!TextUtils.isEmpty(contact.getNumber())) {
        char c = contact.getNumber().charAt(0);
        if (isSpecialChar(c)) {
            return false;
        }
    }
    if (!TextUtils.isEmpty(name)) {
        char c = name.charAt(0);
        if (isSpecialChar(c)) {
            return false;
        }
    }
    if (!(Mms.isEmailAddress(name) || Mms.isPhoneNumber(name))) {
        return false;
    }
    return true;
}

Output:
     }
-    if (!(Mms.isEmailAddress(name) || Mms.isPhoneNumber(name))) {
+    if (!(Mms.isEmailAddress(name) || Mms.isPhoneNumber(name) || MessageUtils.isLocalNumber(contact.getNumber()))) {
         return false;


Input:
public final static String generateHash(String data) throws Exception {
    String hashedData = data;
    try {
        byte[] bytes = data.getBytes("String_Node_Str");
        MessageDigest digest = MessageDigest.getInstance("String_Node_Str");
        digest.update(bytes, 0, bytes.length);
        byte[] digestBytes = digest.digest();
        hashedData = Base64.encodeToString(digestBytes, Base64.URL_SAFE | Base64.NO_WRAP | Base64.NO_PADDING);
    } catch (Exception e) {
        throw e;
    }
    return hashedData;
}

Output:
     try {
-        byte[] bytes = data.getBytes("String_Node_Str");
+        byte[] bytes = data.getBytes(StandardCharsets.US_ASCII);
         MessageDigest digest = MessageDigest.getInstance("String_Node_Str");


Input:
private boolean chapMatchSrc(GrammarChapNode curChap, String src) {
    if (curChap.getName().contains(src)) {
        return true;
    }
    Enumeration sections = curChap.children();
    while (sections.hasMoreElements()) {
        GrammarSectionNode curSec = (GrammarSectionNode) sections.nextElement();
        if (curSec.getName().contains(src)) {
            return true;
        }
    }
    return false;
}

Output:
 private boolean chapMatchSrc(GrammarChapNode curChap, String src) {
-    if (curChap.getName().contains(src)) {
+    if (curChap.getName().toLowerCase().contains(src.toLowerCase())) {
         return true;


Input:
public long getEntityOwnerId() {
    Account caller = CallContext.current().getCallingAccount();
    if (accountName != null && domainId != null) {
        Account account = _accountService.finalizeOwner(caller, accountName, domainId, projectId);
        return account.getId();
    } else if (projectId != null) {
        Project project = _projectService.getProject(projectId);
        if (project != null) {
            if (project.getState() == Project.State.Active) {
                return project.getProjectAccountId();
            } else {
                throw new PermissionDeniedException("String_Node_Str" + project.getState() + "String_Node_Str");
            }
        } else {
            throw new InvalidParameterValueException("String_Node_Str");
        }
    } else if (networkId != null) {
        Network network = _networkService.getNetwork(networkId);
        if (network == null) {
            throw new InvalidParameterValueException("String_Node_Str");
        }
        NetworkOffering offering = _configService.getNetworkOffering(network.getNetworkOfferingId());
        DataCenter zone = _entityMgr.findById(DataCenter.class, network.getDataCenterId());
        if (zone.getNetworkType() == NetworkType.Basic && offering.getElasticIp() && offering.getElasticLb()) {
            return caller.getAccountId();
        }
        return network.getAccountId();
    } else if (vpcId != null) {
        Vpc vpc = _vpcService.getVpc(getVpcId());
        if (vpc == null) {
            throw new InvalidParameterValueException("String_Node_Str");
        }
        return vpc.getAccountId();
    }
    return caller.getAccountId();
}

Output:
         }
-        NetworkOffering offering = _configService.getNetworkOffering(network.getNetworkOfferingId());
+        NetworkOffering offering = _entityMgr.findById(NetworkOffering.class, network.getNetworkOfferingId());
         DataCenter zone = _entityMgr.findById(DataCenter.class, network.getDataCenterId());


Input:
public Bitmap apply(Bitmap bitmap, float scaleFactor, boolean highQuality) {
    Rect cropBounds = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
    RectF crop = mGeometry.getCropBounds(bitmap);
    if (crop.width() > 0 && crop.height() > 0)
        crop.roundOut(cropBounds);
    Bitmap temp = null;
    if (mGeometry.hasSwitchedWidthHeight()) {
        temp = Bitmap.createBitmap(cropBounds.height(), cropBounds.width(), mConfig);
    } else {
        temp = Bitmap.createBitmap(cropBounds.width(), cropBounds.height(), mConfig);
    }
    float[] displayCenter = { temp.getWidth() / 2f, temp.getHeight() / 2f };
    Matrix m1 = mGeometry.buildTotalXform(bitmap.getWidth(), bitmap.getHeight(), displayCenter);
    Canvas canvas = new Canvas(temp);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setFilterBitmap(true);
    paint.setDither(true);
    canvas.drawBitmap(bitmap, m1, paint);
    return temp;
}

Output:
     if (crop.width() > 0 && crop.height() > 0)
-        crop.roundOut(cropBounds);
+        cropBounds = GeometryMath.roundNearest(crop);
     Bitmap temp = null;


Input:
public void generateInWorld(World world, Random rand, int centerX, int bottomY, int centerZ) {
    PosMutable pos = new PosMutable();
    int x, y, z, index = 0;
    for (y = 0; y < sizeY; y++) {
        for (x = -radX; x <= radX; x++) {
            for (z = -radZ; z <= radZ; z++) {
                pos.set(centerX + x, bottomY + y, centerZ + z).setBlock(world, blocks[index], metadata[index], 2);
                ++index;
            }
        }
    }
    tileEntityMap.forEachEntry((ind, value) -> {
        toPos(ind, pos);
        value.generateTile(pos.getTileEntity(world), rand);
        return true;
    });
    scheduledUpdates.forEach(ind -> {
        toPos(ind, pos);
        world.markBlockForUpdate(pos.getX(), pos.getY(), pos.getZ());
        return true;
    });
    entityList.forEach(entity -> {
        entity.setPosition(centerX + entity.posX, bottomY + entity.posY, centerZ + entity.posZ);
        world.spawnEntityInWorld(entity);
    });
}

Output:
     int x, y, z, index = 0;
-    for (y = 0; y < sizeY; y++) {
+    for (z = -radZ; z <= radZ; z++) {
         for (x = -radX; x <= radX; x++) {


Input:
public void onBlockClicked(World world, int x, int y, int z, EntityPlayer player) {
    if (world.isRemote) {
        ScreenHitTileEntity screenHitTileEntity = (ScreenHitTileEntity) world.getTileEntity(x, y, z);
        int dx = screenHitTileEntity.getDx();
        int dy = screenHitTileEntity.getDy();
        int dz = screenHitTileEntity.getDz();
        Block block = world.getBlock(x + dx, y + dy, z + dz);
        if (block != ScreenSetup.screenBlock) {
            return;
        }
        MovingObjectPosition mouseOver = Minecraft.getMinecraft().objectMouseOver;
        PacketHandler.INSTANCE.sendToServer(new PacketServerCommand(x + dx, y + dy, z + dz, ScreenTileEntity.CMD_CLICK, new Argument("String_Node_Str", mouseOver.hitVec.xCoord - x - dx), new Argument("String_Node_Str", mouseOver.hitVec.yCoord - y - dy), new Argument("String_Node_Str", mouseOver.hitVec.zCoord - z - dz), new Argument("String_Node_Str", mouseOver.sideHit)));
    }
}

Output:
         MovingObjectPosition mouseOver = Minecraft.getMinecraft().objectMouseOver;
-        PacketHandler.INSTANCE.sendToServer(new PacketServerCommand(x + dx, y + dy, z + dz, ScreenTileEntity.CMD_CLICK, new Argument("String_Node_Str", mouseOver.hitVec.xCoord - x - dx), new Argument("String_Node_Str", mouseOver.hitVec.yCoord - y - dy), new Argument("String_Node_Str", mouseOver.hitVec.zCoord - z - dz), new Argument("String_Node_Str", mouseOver.sideHit)));
+        ScreenTileEntity screenTileEntity = (ScreenTileEntity) world.getTileEntity(x + dx, y + dy, z + dz);
+        screenTileEntity.hitScreenClient(mouseOver.hitVec.xCoord - x - dx, mouseOver.hitVec.yCoord - y - dy, mouseOver.hitVec.zCoord - z - dz, mouseOver.sideHit);
     }


Input:
private String getColumnValue(ColumnConfig column, Database database) {
    if (column.getValue() != null) {
        return "String_Node_Str" + column.getValue().replaceAll("String_Node_Str", "String_Node_Str") + "String_Node_Str";
    } else if (column.getValueNumeric() != null) {
        return column.getValueNumeric();
    } else if (column.getValueBoolean() != null) {
        if (column.getValueBoolean()) {
            return database.getTrueBooleanValue();
        } else {
            return database.getFalseBooleanValue();
        }
    } else if (column.getValueDate() != null) {
        return database.getDateLiteral(column.getValueDate());
    } else {
        return "String_Node_Str";
    }
}

Output:
         if (column.getValueBoolean()) {
-            return database.getTrueBooleanValue();
+            returnValue = database.getTrueBooleanValue();
         } else {


Input:
public <D> Loader<D> restartLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
    if (mCreatingLoader) {
        throw new IllegalStateException("String_Node_Str");
    }
    LoaderInfo info = mLoaders.get(id);
    if (DEBUG)
        Log.v(TAG, "String_Node_Str" + this + "String_Node_Str" + args);
    if (info != null) {
        LoaderInfo inactive = mInactiveLoaders.get(id);
        if (inactive != null) {
            if (info.mHaveData) {
                if (DEBUG)
                    Log.v(TAG, "String_Node_Str" + info);
                inactive.mDeliveredData = false;
                inactive.destroy();
                info.mLoader.abandon();
                mInactiveLoaders.put(id, info);
            } else {
                if (!info.mStarted) {
                    if (DEBUG)
                        Log.v(TAG, "String_Node_Str");
                    mLoaders.put(id, null);
                    info.destroy();
                } else {
                    if (DEBUG)
                        Log.v(TAG, "String_Node_Str");
                    info.cancel();
                    if (info.mPendingLoader != null) {
                        if (DEBUG)
                            Log.v(TAG, "String_Node_Str" + info.mPendingLoader);
                        info.mPendingLoader.destroy();
                        info.mPendingLoader = null;
                    }
                    if (DEBUG)
                        Log.v(TAG, "String_Node_Str");
                    info.mPendingLoader = createLoader(id, args, (LoaderManager.LoaderCallbacks<Object>) callback);
                    return (Loader<D>) info.mPendingLoader.mLoader;
                }
            }
        } else {
            if (DEBUG)
                Log.v(TAG, "String_Node_Str" + info);
            info.mLoader.abandon();
            mInactiveLoaders.put(id, info);
        }
    }
    info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>) callback);
    return (Loader<D>) info.mLoader;
}

Output:
             } else {
-                if (!info.mStarted) {
+                if (!info.cancel()) {
                     if (DEBUG)


Input:
Artifact introduceShallowArtifact(BranchId destinationBranch) throws OseeCoreException {
    Artifact shallowArt = ArtifactTypeManager.getFactory(getArtifactType()).reflectExisitingArtifact(artId, getGuid(), getArtifactType(), gammaId, destinationBranch, modType);
    return shallowArt;
}

Output:
 Artifact introduceShallowArtifact(BranchId destinationBranch) throws OseeCoreException {
-    Artifact shallowArt = ArtifactTypeManager.getFactory(getArtifactType()).reflectExisitingArtifact(artId, getGuid(), getArtifactType(), gammaId, destinationBranch, modType);
+    Artifact shallowArt = ArtifactTypeManager.getFactory(getArtifactType()).reflectExisitingArtifact(artId, getGuid(), getArtifactType(), gammaId, destinationBranch, modType, applicabilityId);
     return shallowArt;


Input:
protected void initPage(BuildServerWizardPage page) {
    page.setTitle(Messages.NewHudsonServerWizard_Title);
    page.setMessage(Messages.NewHudsonServerWizard_Message);
}

Output:
 protected void initPage(BuildServerWizardPage page) {
-    page.setTitle(Messages.NewHudsonServerWizard_Title);
-    page.setMessage(Messages.NewHudsonServerWizard_Message);
+    page.setTitle(Messages.NewServerWizard_Title);
+    page.setMessage(Messages.NewServerWizard_Message);
 }


Input:
private JsonObject loadNextJsonObject() {
    if (this.currentPage == null) {
        this.loadNextPage();
    }
    while (this.currentPage.hasNext() || this.hasMorePages) {
        while (this.currentPage.hasNext()) {
            JsonObject jsonObject = this.currentPage.next().asObject();
            if (this.filter.shouldInclude(jsonObject)) {
                return jsonObject;
            }
        }
        if (this.hasMorePages) {
            this.loadNextPage();
        }
    }
    return null;
}

Output:
             JsonObject jsonObject = this.currentPage.next().asObject();
-            if (this.filter.shouldInclude(jsonObject)) {
+            if (this.filter == null || this.filter.shouldInclude(jsonObject)) {
                 return jsonObject;


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View rootView = inflater.inflate(R.layout.fragment_searchresult_detail, container, false);
    view = rootView;
    findViews();
    toolbar.setVisibility(View.VISIBLE);
    setHasOptionsMenu(false);
    if (getActivity() instanceof SearchResultDetailActivity) {
        toolbar.setNavigationIcon(R.drawable.abc_ic_ab_back_mtrl_am_alpha);
        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                getActivity().supportFinishAfterTransition();
            }
        });
        back_button_visible = true;
    }
    toolbar.inflateMenu(R.menu.search_result_details_activity);
    refreshMenu(toolbar.getMenu());
    toolbar.setOnMenuItemClickListener(this);
    setRetainInstance(true);
    setProgress();
    scrollView.addCallbacks(this);
    if (getArguments().containsKey(ARG_ITEM_COVER_BITMAP)) {
        Bitmap bitmap = getArguments().getParcelable(ARG_ITEM_COVER_BITMAP);
        ivCover.setImageBitmap(bitmap);
        Palette.generateAsync(bitmap, new Palette.PaletteAsyncListener() {
            public void onGenerated(Palette palette) {
                Palette.Swatch swatch = palette.getDarkVibrantSwatch();
                if (swatch != null) {
                    ivCover.setBackgroundColor(swatch.getRgb());
                    tint.setBackgroundColor(swatch.getRgb());
                }
            }
        });
        analyzeWhitenessOfCoverAsync(bitmap);
        image_analyzed = true;
        showCoverView(true);
    } else {
        showCoverView(false);
    }
    fixEllipsize(tvTitel);
    return rootView;
}

Output:
     scrollView.addCallbacks(this);
-    if (getArguments().containsKey(ARG_ITEM_COVER_BITMAP)) {
+    if (getArguments().containsKey(ARG_ITEM_COVER_BITMAP) && !ft.getStatus().equals(AsyncTask.Status.FINISHED)) {
         Bitmap bitmap = getArguments().getParcelable(ARG_ITEM_COVER_BITMAP);


Input:
public void testGetStatus() {
    TrainAnneal anneal = new TrainAnneal(true, new TrialAlgo(), new TrialScore());
    assertEquals("String_Node_Str", anneal.getStatus());
}

Output:
 public void testGetStatus() {
-    TrainAnneal anneal = new TrainAnneal(true, new TrialAlgo(), new TrialScore());
+    TrainAnneal anneal = new TrainAnneal(new TrialAlgo(), new TrialScore());
     assertEquals("String_Node_Str", anneal.getStatus());


Input:
public static void removeAllEmbargoTypes() {
    List<EmbargoType> embargos = settingRepo.findAllEmbargoTypes();
    for (EmbargoType embargo : embargos) {
        embargo.delete();
        Logger.info("String_Node_Str", context.getPerson().getFormattedName(NameFormat.FIRST_LAST), context.getPerson().getId(), context.getPerson().getEmail(), embargo.getId(), embargo.getName(), embargo.getDescription(), embargo.getDuration(), embargo.isActive());
    }
    flash.put("String_Node_Str", "String_Node_Str");
    configurableSettings();
}

Output:
     for (EmbargoType embargo : embargos) {
-        embargo.delete();
-        Logger.info("String_Node_Str", context.getPerson().getFormattedName(NameFormat.FIRST_LAST), context.getPerson().getId(), context.getPerson().getEmail(), embargo.getId(), embargo.getName(), embargo.getDescription(), embargo.getDuration(), embargo.isActive());
+        if (!embargo.isSystemRequired()) {
+            embargo.delete();
+            Logger.info("String_Node_Str", context.getPerson().getFormattedName(NameFormat.FIRST_LAST), context.getPerson().getId(), context.getPerson().getEmail(), embargo.getId(), embargo.getName(), embargo.getDescription(), embargo.getDuration(), embargo.isActive());
+        }
     }


Input:
private int getErrorStringId(int errorType, boolean endpointed) {
    switch(errorType) {
        case RecognitionManager.ERROR_CLIENT:
            return R.string.voice_not_installed;
        case RecognitionManager.ERROR_NETWORK:
            return R.string.voice_network_error;
        case RecognitionManager.ERROR_NETWORK_TIMEOUT:
            return endpointed ? R.string.voice_network_error : R.string.voice_too_much_speech;
        case RecognitionManager.ERROR_AUDIO:
            return R.string.voice_audio_error;
        case RecognitionManager.ERROR_SERVER:
            return R.string.voice_server_error;
        case RecognitionManager.ERROR_SPEECH_TIMEOUT:
            return R.string.voice_speech_timeout;
        case RecognitionManager.ERROR_NO_MATCH:
            return R.string.voice_no_match;
        default:
            return R.string.voice_error;
    }
}

Output:
     switch(errorType) {
-        case RecognitionManager.ERROR_CLIENT:
+        case SpeechRecognizer.ERROR_CLIENT:
             return R.string.voice_not_installed;


Input:
public void run() {
    String proto = System.getProtocolByPort(openPort), entry = openPort;
    if (proto != null)
        entry = openPort + "String_Node_Str" + proto + "String_Node_Str";
    else
        entry = portProto + "String_Node_Str" + openPort;
    mPortList.add(entry);
    mListAdapter.notifyDataSetChanged();
    System.addOpenPort(Integer.parseInt(openPort), Network.Protocol.fromString(portProto));
}

Output:
 public void run() {
-    String proto = System.getProtocolByPort(openPort), entry = openPort;
-    if (proto != null)
-        entry = openPort + "String_Node_Str" + proto + "String_Node_Str";
+    String entry;
+    if (resolvedProtocol != null)
+        entry = portNumber + "String_Node_Str" + resolvedProtocol + "String_Node_Str";
     else


Input:
public WSItemPK putItem(WSPutItem wsPutItem) throws RemoteException {
    try {
        String projection = wsPutItem.getXmlString();
        Element root = Util.parse(projection).getDocumentElement();
        String concept = root.getLocalName();
        DataModelPOJO dataModel = com.amalto.core.util.Util.getDataModelCtrlLocal().getDataModel(new DataModelPOJOPK(wsPutItem.getWsDataModelPK().getPk()));
        Document schema = Util.parse(dataModel.getSchema());
        XSDKey conceptKey = com.amalto.core.util.Util.getBusinessConceptKey(schema, concept);
        String[] itemKeyValues = com.amalto.core.util.Util.getKeyValuesFromItem(root, conceptKey);
        if (conceptKey.getFields().length == 1) {
            Element conceptRoot = Util.parse(projection).getDocumentElement();
            if (Util.getNodeList(conceptRoot, "String_Node_Str" + concept + "String_Node_Str" + conceptKey.getFields()[0]).getLength() == 0) {
                Element rootNS = Util.getRootElement("String_Node_Str", schema.getDocumentElement().getNamespaceURI(), "String_Node_Str");
                NodeList complexLists = Util.getNodeList(schema.getDocumentElement(), "String_Node_Str", rootNS.getNamespaceURI(), "String_Node_Str");
                List<UUIDKey> keys = new ArrayList<UUIDKey>();
                for (int i = 0; i < complexLists.getLength(); i++) {
                    Element element = (Element) complexLists.item(i);
                    UUIDKey uuidKey = Util.getUUIDKey(element);
                    if (uuidKey != null) {
                        keys.add(uuidKey);
                        if (i == 0) {
                            itemKeyValues = new String[] { uuidKey.getUuidValue() };
                        }
                    }
                }
                if (keys.size() > 0) {
                    if (itemKeyValues == null || itemKeyValues[0] == null)
                        itemKeyValues = new String[] { keys.get(0).getUuidValue() };
                    projection = Util.getProjectXMLString(keys.toArray(new UUIDKey[keys.size()]), projection);
                }
            }
        }
        DataClusterPOJOPK dcpk = new DataClusterPOJOPK(wsPutItem.getWsDataClusterPK().getPk());
        ItemPOJOPK itemPOJOPK = com.amalto.core.util.Util.getItemCtrl2Local().putItem(new ItemPOJO(dcpk, concept, itemKeyValues, System.currentTimeMillis(), projection), dataModel);
        if (itemPOJOPK == null)
            return null;
        com.amalto.core.util.Util.getDataClusterCtrlLocal().addToVocabulary(dcpk, projection);
        return new WSItemPK(new WSDataClusterPK(itemPOJOPK.getDataClusterPOJOPK().getUniqueId()), itemPOJOPK.getConceptName(), itemPOJOPK.getIds());
    } catch (com.amalto.core.util.XtentisException e) {
        throw (new RemoteException(e.getLocalizedMessage()));
    } catch (Exception e) {
        throw new RemoteException((e.getCause() == null ? e.getLocalizedMessage() : e.getCause().getLocalizedMessage()));
    }
}

Output:
         String[] itemKeyValues = com.amalto.core.util.Util.getKeyValuesFromItem(root, conceptKey);
-        if (conceptKey.getFields().length == 1) {
-            Element conceptRoot = Util.parse(projection).getDocumentElement();
-            if (Util.getNodeList(conceptRoot, "String_Node_Str" + concept + "String_Node_Str" + conceptKey.getFields()[0]).getLength() == 0) {
-                Element rootNS = Util.getRootElement("String_Node_Str", schema.getDocumentElement().getNamespaceURI(), "String_Node_Str");
-                NodeList complexLists = Util.getNodeList(schema.getDocumentElement(), "String_Node_Str", rootNS.getNamespaceURI(), "String_Node_Str");
-                List<UUIDKey> keys = new ArrayList<UUIDKey>();
-                for (int i = 0; i < complexLists.getLength(); i++) {
-                    Element element = (Element) complexLists.item(i);
-                    UUIDKey uuidKey = Util.getUUIDKey(element);
-                    if (uuidKey != null) {
-                        keys.add(uuidKey);
-                        if (i == 0) {
-                            itemKeyValues = new String[] { uuidKey.getUuidValue() };
-                        }
-                    }
-                }
-                if (keys.size() > 0) {
-                    if (itemKeyValues == null || itemKeyValues[0] == null)
-                        itemKeyValues = new String[] { keys.get(0).getUuidValue() };
-                    projection = Util.getProjectXMLString(keys.toArray(new UUIDKey[keys.size()]), projection);
+        Element conceptRoot = (Element) root.cloneNode(true);
+        Util.generateUUIDForElement(schema, concept, conceptRoot);
+        for (int j = 0; j < conceptKey.getFields().length; j++) {
+            for (int i = 0; i < conceptRoot.getChildNodes().getLength(); i++) {
+                Node node = conceptRoot.getChildNodes().item(i);
+                String name = node.getLocalName();
+                if (node.getNodeType() != Node.ELEMENT_NODE)
+                    continue;
+                String key = conceptKey.getFields()[j];
+                if (name.equals(key) && itemKeyValues[j] == null) {
+                    itemKeyValues[j] = node.getTextContent();
+                    break;
                 }


Input:
public void dispose() {
    LogListener.removeListener(this);
}

Output:
 public void dispose() {
-    LogListener.removeListener(this);
+    ftpClient.removeLogListener(this);
 }


Input:
public void testDeleteItemNotExisting() {
    TodoListItem item = new TodoListItem("String_Node_Str", 0, new Deadline(), false, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    repository.delete(item);
    TodoListItem fromDb = repository.getItemById(item.getUuid());
    assertNull(fromDb);
}

Output:
 public void testDeleteItemNotExisting() {
-    TodoListItem item = new TodoListItem("String_Node_Str", 0, new Deadline(), false, "String_Node_Str", "String_Node_Str", "String_Node_Str");
+    TodoListItem item = createItem();
     repository.delete(item);


Input:
private static TurboUser updateRandomUser(String repoId) {
    int i = (int) (Math.random() * userCounter);
    return new TurboUser(repoId, "String_Node_Str" + i + "String_Node_Str" + Math.random());
}

Output:
     int i = (int) (Math.random() * userCounter);
-    return new TurboUser(repoId, "String_Node_Str" + i + "String_Node_Str" + Math.random());
+    return users.set(i, new TurboUser(repoId, "String_Node_Str" + (i + 1) + "String_Node_Str" + Math.random()));
 }


Input:
public void testMissingFieldHandling() throws Exception {
    BufferedProtocolReadToWrite p = new BufferedProtocolReadToWrite(new ThriftSchemaConverter().toStructType(StructV3.class));
    CountingErrorHandler countingHandler = new CountingErrorHandler();
    p.unregisterAllErrorHandlers();
    p.registerErrorHandler(countingHandler);
    final ByteArrayOutputStream in = new ByteArrayOutputStream();
    StructV4WithExtracStructField dataWithNewSchema = new StructV4WithExtracStructField("String_Node_Str");
    dataWithNewSchema.setAge("String_Node_Str");
    dataWithNewSchema.setGender("String_Node_Str");
    StructV3 structV3 = new StructV3("String_Node_Str");
    structV3.setAge("String_Node_Str");
    dataWithNewSchema.setAddedStruct(structV3);
    dataWithNewSchema.write(protocol(in));
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    p.readOne(protocol(new ByteArrayInputStream(in.toByteArray())), protocol(out));
    assertEquals(0, countingHandler.corruptedCount);
    assertEquals(1, countingHandler.recordCountOfMissingFields);
    assertEquals(1, countingHandler.fieldIgnoredCount);
}

Output:
 public void testMissingFieldHandling() throws Exception {
-    BufferedProtocolReadToWrite p = new BufferedProtocolReadToWrite(new ThriftSchemaConverter().toStructType(StructV3.class));
-    CountingErrorHandler countingHandler = new CountingErrorHandler();
-    p.unregisterAllErrorHandlers();
-    p.registerErrorHandler(countingHandler);
+    BufferedProtocolReadToWrite structForRead = new BufferedProtocolReadToWrite(new ThriftSchemaConverter().toStructType(StructV3.class));
+    CountingErrorHandler countingHandler = new CountingErrorHandler() {
+        public void handleFieldIgnored(TField field) {
+            assertEquals(field.id, 4);
+            fieldIgnoredCount++;
+        }
+    };
+    structForRead.unregisterAllErrorHandlers();
+    structForRead.registerErrorHandler(countingHandler);
     final ByteArrayOutputStream in = new ByteArrayOutputStream();


Input:
private synchronized CacheDownload getNextRedditInQueue() {
    while (redditDownloadsQueued.isEmpty()) {
        try {
            wait();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    CacheDownload next = null;
    RequestIdentifier nextKey = null;
    for (final HashMap.Entry<RequestIdentifier, CacheDownload> entry : redditDownloadsQueued.entrySet()) {
        if (next == null || entry.getValue().isHigherPriorityThan(next)) {
            next = entry.getValue();
            nextKey = entry.getKey();
        }
    }
    redditDownloadsQueued.remove(nextKey);
    downloadsInProgress.put(nextKey, next);
    return next;
}

Output:
     RequestIdentifier nextKey = null;
-    for (final HashMap.Entry<RequestIdentifier, CacheDownload> entry : redditDownloadsQueued.entrySet()) {
+    for (final Map.Entry<RequestIdentifier, CacheDownload> entry : redditDownloadsQueued.entrySet()) {
         if (next == null || entry.getValue().isHigherPriorityThan(next)) {


Input:
private static File getResultFile(FileBatchJob batchJob) {
    File f;
    File fsorted;
    try {
        final String uuid = UUID.randomUUID().toString();
        f = File.createTempFile("String_Node_Str", uuid + "String_Node_Str", FileUtils.getTempDir());
        f.deleteOnExit();
        fsorted = File.createTempFile("String_Node_Str", uuid + "String_Node_Str", FileUtils.getTempDir());
        fsorted.deleteOnExit();
    } catch (IOException e) {
        throw new IOFailure("String_Node_Str", e);
    }
    BatchStatus status = ArcRepositoryClientFactory.getViewerInstance().batch(batchJob, Settings.get(CommonSettings.USE_REPLICA_ID));
    status.getResultFile().copyTo(f);
    FileUtils.sortCrawlLog(f, fsorted);
    FileUtils.remove(f);
    return fsorted;
}

Output:
     status.getResultFile().copyTo(f);
-    FileUtils.sortCrawlLog(f, fsorted);
+    FileUtils.sortCrawlLogOnTimestamp(f, fsorted);
     FileUtils.remove(f);


Input:
public void initCheck() throws InterruptedException {
    System.out.println("String_Node_Str" + getClass().getSimpleName() + "String_Node_Str");
    assertEquals("String_Node_Str", ContextUtil.getCurrentActivity());
    assertEquals(true, DeviceUtil.moreThanTargetSdkVersion("String_Node_Str"));
    WaitUtil.forceWait(3);
}

Output:
 public void initCheck() throws InterruptedException {
-    System.out.println("String_Node_Str" + getClass().getSimpleName() + "String_Node_Str");
+    System.err.println("String_Node_Str" + getClass().getSimpleName() + "String_Node_Str");
     assertEquals("String_Node_Str", ContextUtil.getCurrentActivity());


Input:
public String toString() {
    StringBuffer ret = new StringBuffer();
    if (fields == null)
        return "String_Node_Str";
    for (Iterator fieldIt = fields.keySet().iterator(); fieldIt.hasNext(); ) {
        final Object field = (Object) fieldIt.next();
        ret.append("String_Node_Str" + field + "String_Node_Str" + fields.get(field) + "String_Node_Str");
    }
    return ret.toString();
}

Output:
     StringBuffer ret = new StringBuffer();
-    if (fields == null)
-        return "String_Node_Str";
-    for (Iterator fieldIt = fields.keySet().iterator(); fieldIt.hasNext(); ) {
-        final Object field = (Object) fieldIt.next();
-        ret.append("String_Node_Str" + field + "String_Node_Str" + fields.get(field) + "String_Node_Str");
+    if (fields != null) {
+        for (Iterator fieldIt = fields.keySet().iterator(); fieldIt.hasNext(); ) {
+            final Object field = (Object) fieldIt.next();
+            ret.append("String_Node_Str" + field + "String_Node_Str" + fields.get(field) + "String_Node_Str");
+            empty = false;
+        }
     }


Input:
private void setBuddyList() {
    PresenceInfo[] presenceInfoList = pm.getAllUsers();
    ArrayList<String> userList = new ArrayList();
    for (int i = 0; i < presenceInfoList.length; i++) {
        PresenceInfo info = presenceInfoList[i];
        if (info.callID == null) {
            continue;
        }
        userList.add(info.usernameAlias);
    }
    String[] userArray = userList.toArray(new String[0]);
    SortUsers.sort(userArray);
    this.userList = userList;
    buddyList.setListData(userArray);
    enableButtons();
}

Output:
     SortUsers.sort(userArray);
-    this.userList = userList;
-    buddyList.setListData(userArray);
+    boolean needToUpdate = false;
+    if (currentArray.length == userArray.length) {
+        for (int i = 0; i < currentArray.length; i++) {
+            if (currentArray[i].equals(userArray[i]) == false) {
+                needToUpdate = true;
+                break;
+            }
+        }
+    } else {
+        needToUpdate = true;
+    }
+    if (needToUpdate) {
+        currentArray = userArray;
+        buddyList.setListData(userArray);
+    }
     enableButtons();


Input:
public void configure(Set<Parameter> stepParameters) throws EoulsanException {
    for (Parameter p : stepParameters) {
        if (FORMAT_PARAMETER.equals(p.getName()))
            this.format = DataFormatRegistry.getInstance().getDataFormatFromName(p.getValue());
        else if (OUTPUT_COMPRESSION_PARAMETER.equals(p.getName()))
            this.outputCompression = CompressionType.valueOf(p.getValue());
    }
    if (this.format == null)
        new EoulsanException("String_Node_Str");
    if (this.outputCompression == null)
        new EoulsanException("String_Node_Str");
}

Output:
     if (this.format == null)
-        new EoulsanException("String_Node_Str");
+        throw new EoulsanException("String_Node_Str");
     if (this.outputCompression == null)


Input:
public void testResponseContainsCloseHeaderOnHttp10() throws Exception {
    Socket socket = new Socket(address.getAddress(), address.getPort());
    socket.setKeepAlive(false);
    socket.setSoTimeout(3000);
    PrintWriter pw = new PrintWriter(socket.getOutputStream());
    pw.print("String_Node_Str");
    pw.print("String_Node_Str");
    pw.flush();
    BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    String line;
    List<String> lines = new ArrayList<>();
    while ((line = reader.readLine()) != null) {
        lines.add(line);
    }
    assertThat(lines, hasItem("String_Node_Str"));
}

Output:
     socket.setSoTimeout(3000);
-    PrintWriter pw = new PrintWriter(socket.getOutputStream());
-    pw.print("String_Node_Str");
-    pw.print("String_Node_Str");
-    pw.flush();
-    BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+    OutputStream outputStream = socket.getOutputStream();
+    outputStream.write("String_Node_Str".getBytes(StandardCharsets.UTF_8));
+    outputStream.write("String_Node_Str".getBytes(StandardCharsets.UTF_8));
+    outputStream.flush();
+    BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
     String line;


Input:
protected void refreshVisuals() {
    OPMStructuralLinkAggregator model = (OPMStructuralLinkAggregator) getModel();
    ((GraphicalEditPart) getParent()).setLayoutConstraint(this, figure, model.getConstraints());
}

Output:
 protected void refreshVisuals() {
-    OPMStructuralLinkAggregator model = (OPMStructuralLinkAggregator) getModel();
+    OPMStructuralLink model = (OPMStructuralLink) getModel();
     ((GraphicalEditPart) getParent()).setLayoutConstraint(this, figure, model.getConstraints());


Input:
public void me(String[] args, User user) {
    if (args.length == 0) {
        user.sendMessage(ChatColor.YELLOW + "String_Node_Str");
        return;
    }
    if (user.isMuted()) {
        user.sendMessage(ChatColor.GRAY + plugin.mainProperties.getString("String_Node_Str", "String_Node_Str"));
        return;
    }
    String message = "String_Node_Str";
    for (String word : args) {
        if (message == "String_Node_Str") {
            message += word;
        } else {
            message += "String_Node_Str" + word;
        }
    }
    boolean blocked = ChatChecker.checkBlocked(message, plugin);
    if (blocked) {
        user.sendMessage(ChatColor.GRAY + plugin.mainProperties.getString("String_Node_Str", "String_Node_Str"));
        return;
    }
    long slowTimeLeft = plugin.chatListen.slow.playerBlocked(user.getName());
    if ((!plugin.perm.userFile.hasPermission(user.getName(), "String_Node_Str", true, true)) && plugin.chatListen.slow.isEnabled()) {
        if (slowTimeLeft > 0) {
            user.sendMessage(ChatColor.GRAY + "String_Node_Str" + (int) Math.ceil(slowTimeLeft / 1000) + "String_Node_Str");
            return;
        } else {
            plugin.chatListen.slow.playerAdd(user.getName());
        }
    }
    message = ChatColor.WHITE + "String_Node_Str" + user.getColor() + user.getName() + "String_Node_Str" + ChatColor.WHITE + message;
    plugin.getServer().broadcastMessage(message);
    new User(plugin).sendMessage(message);
}

Output:
     plugin.getServer().broadcastMessage(message);
-    new User(plugin).sendMessage(message);
+    User.getUser(plugin).sendMessage(message);
 }


Input:
private String getDateAggregatedCompletedString(Expression sqlExpression, String colName, String table, DateGrain dateAggregationType) {
    int nbExtractedColumns = 0;
    String result = "String_Node_Str";
    String aliases = "String_Node_Str";
    String alias;
    switch(dateAggregationType) {
        case DAY:
            alias = getAlias(colName, DateGrain.DAY);
            result = dbms().extractDay(colName) + alias + comma(result);
            aliases = alias + comma(aliases);
            nbExtractedColumns++;
        case WEEK:
            alias = getAlias(colName, DateGrain.WEEK);
            result = dbms().extractWeek(colName) + alias + comma(result);
            aliases = alias + comma(aliases);
            nbExtractedColumns++;
        case MONTH:
            alias = getAlias(colName, DateGrain.MONTH);
            result = dbms().extractMonth(colName) + alias + comma(result);
            aliases = alias + comma(aliases);
            nbExtractedColumns++;
        case QUARTER:
            alias = getAlias(colName, DateGrain.QUARTER);
            result = dbms().extractQuarter(colName) + alias + comma(result);
            aliases = alias + comma(aliases);
            nbExtractedColumns++;
        case YEAR:
            alias = getAlias(colName, DateGrain.YEAR);
            result = dbms().extractYear(colName) + alias + comma(result);
            aliases = alias + comma(aliases);
            nbExtractedColumns++;
            break;
        case NONE:
            result = colName;
            nbExtractedColumns++;
            break;
        default:
            break;
    }
    String sql = replaceVariablesLow(sqlExpression.getBody(), result, table, aliases);
    return sql;
}

Output:
     }
-    String sql = replaceVariablesLow(sqlExpression.getBody(), result, table, aliases);
+    String groupByAliases = dbms().supportAliasesInGroupBy() ? aliases : result;
+    String sql = replaceVariablesLow(sqlExpression.getBody(), result, table, groupByAliases);
     return sql;


Input:
public void testWithResolveIdInAnotherBuild() throws Exception {
    Project other = new Project();
    other.setProperty("String_Node_Str", "String_Node_Str");
    other.setProperty("String_Node_Str", "String_Node_Str");
    IvyResolve resolve = new IvyResolve();
    resolve.setProject(other);
    resolve.setFile(new File("String_Node_Str"));
    resolve.setResolveId("String_Node_Str");
    resolve.execute();
    resolve = new IvyResolve();
    resolve.setProject(project);
    resolve.setFile(new File("String_Node_Str"));
    resolve.execute();
    deliver.setResolveId("String_Node_Str");
    deliver.setPubrevision("String_Node_Str");
    deliver.setDeliverpattern("String_Node_Str");
    deliver.execute();
    File deliveredIvyFile = new File("String_Node_Str");
    assertTrue(deliveredIvyFile.exists());
    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(new IvySettings(), deliveredIvyFile.toURL(), true);
    assertEquals(ModuleRevisionId.newInstance("String_Node_Str", "String_Node_Str", "String_Node_Str"), md.getModuleRevisionId());
    DependencyDescriptor[] dds = md.getDependencies();
    assertEquals(1, dds.length);
    assertEquals(ModuleRevisionId.newInstance("String_Node_Str", "String_Node_Str", "String_Node_Str"), dds[0].getDependencyRevisionId());
}

Output:
     assertTrue(deliveredIvyFile.exists());
-    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(new IvySettings(), deliveredIvyFile.toURL(), true);
+    ModuleDescriptor md = XmlModuleDescriptorParser.getInstance().parseDescriptor(new IvySettings(), deliveredIvyFile.toURI().toURL(), true);
     assertEquals(ModuleRevisionId.newInstance("String_Node_Str", "String_Node_Str", "String_Node_Str"), md.getModuleRevisionId());


Input:
private void checkFilePath(String path, final boolean readOnly) {
    path = new File(path).getAbsolutePath();
    if (isCallerScript()) {
        if (!path.startsWith(GlobalConfiguration.Paths.getScriptCacheDirectory())) {
            boolean fail = true;
            if (!GlobalConfiguration.RUNNING_FROM_JAR) {
                String check = new File(GlobalConfiguration.Paths.ROOT).getAbsolutePath();
                try {
                    check = new File(check).getCanonicalPath();
                } catch (final IOException ignored) {
                }
                fail = !path.startsWith(check);
            } else {
                final String check = new File(GlobalConfiguration.class.getProtectionDomain().getCodeSource().getLocation().getPath()).getAbsolutePath();
                if (readOnly && path.equals(check)) {
                    fail = false;
                }
            }
            for (final String prefix : new String[] { GlobalConfiguration.Paths.getScreenshotsDirectory(), GlobalConfiguration.Paths.getScriptsDirectory(), GlobalConfiguration.Paths.getWebCache() }) {
                if (path.startsWith(prefix)) {
                    fail = false;
                    break;
                }
            }
            final String jre = System.getProperty("String_Node_Str");
            if (readOnly && jre != null && !jre.isEmpty() && path.startsWith(jre)) {
                fail = false;
            }
            if (GlobalConfiguration.getCurrentOperatingSystem() == OperatingSystem.WINDOWS) {
                final String sysroot = System.getenv("String_Node_Str");
                if (readOnly && sysroot != null & !sysroot.isEmpty() && path.startsWith(sysroot)) {
                    fail = false;
                }
            }
            if (fail) {
                throw new SecurityException();
            }
        }
    }
    if (path.equalsIgnoreCase(new File(GlobalConfiguration.Paths.getAccountsFile()).getAbsolutePath())) {
        for (final StackTraceElement s : Thread.currentThread().getStackTrace()) {
            final String name = s.getClassName();
            if (name.equals(AccountStore.class.getName())) {
                return;
            }
        }
        throw new SecurityException();
    }
}

Output:
             }
-            for (final String prefix : new String[] { GlobalConfiguration.Paths.getScreenshotsDirectory(), GlobalConfiguration.Paths.getScriptsDirectory(), GlobalConfiguration.Paths.getWebCache() }) {
+            for (final String prefix : new String[] { GlobalConfiguration.Paths.getScreenshotsDirectory(), GlobalConfiguration.Paths.getScriptsDirectory(), GlobalConfiguration.Paths.getWebDatabase() }) {
                 if (path.startsWith(prefix)) {


Input:
public void setup() throws Exception {
    final URL root = new URL(TestServlet.class.getResource("String_Node_Str"), "String_Node_Str");
    final String baseDir = new File(root.getFile().replaceAll("String_Node_Str", "String_Node_Str")).toString();
    final String sourceDir = baseDir + "String_Node_Str";
    hz = Hazelcast.newHazelcastInstance(new FileSystemXmlConfig(new File(sourceDir + "String_Node_Str", "String_Node_Str")));
    serverPort1 = availablePort();
    server1 = getServletContainer(serverPort1, sourceDir, serverXml1);
    if (serverXml2 != null) {
        serverPort2 = availablePort();
        server2 = getServletContainer(serverPort2, sourceDir, serverXml2);
    }
}

Output:
 public void setup() throws Exception {
-    final URL root = new URL(TestServlet.class.getResource("String_Node_Str"), "String_Node_Str");
-    final String baseDir = new File(root.getFile().replaceAll("String_Node_Str", "String_Node_Str")).toString();
-    final String sourceDir = baseDir + "String_Node_Str";
-    hz = Hazelcast.newHazelcastInstance(new FileSystemXmlConfig(new File(sourceDir + "String_Node_Str", "String_Node_Str")));
-    serverPort1 = availablePort();
-    server1 = getServletContainer(serverPort1, sourceDir, serverXml1);
-    if (serverXml2 != null) {
-        serverPort2 = availablePort();
-        server2 = getServletContainer(serverPort2, sourceDir, serverXml2);
+    ContainerContext cc = CONTAINER_CONTEXT_MAP.get(getClass());
+    if (cc == null) {
+        ensureInstanceIsUp();
+        CONTAINER_CONTEXT_MAP.put(getClass(), new ContainerContext(this, serverXml1, serverXml2, serverPort1, serverPort2, server1, server2, hz));
+    } else {
+        cc.copyInto(this);
+        ensureInstanceIsUp();
+        cc.copyFrom(this);
     }


Input:
public Object extract(GetResponse response) {
    return response.getField(field).getValue();
}

Output:
 public Object extract(GetResponse response) {
-    return response.getField(field).getValue();
+    GetField getField = response.getField(field);
+    if (getField != null) {
+        return getField.getValue();
+    }
+    return null;
 }


Input:
private static long getStatusID(Uri uri) {
    String str = "String_Node_Str";
    String[] arrayOfString = uri.toString().split("String_Node_Str");
    for (int i = 0; i < arrayOfString.length; i++) {
        if (arrayOfString[i].startsWith("String_Node_Str")) {
            str = arrayOfString[(i + 1)];
            break;
        }
    }
    return Long.parseLong(str);
}

Output:
     String str = "String_Node_Str";
-    String[] arrayOfString = uri.toString().split("String_Node_Str");
+    String[] arrayOfString = uri.getPath().toString().split("String_Node_Str");
     for (int i = 0; i < arrayOfString.length; i++) {


Input:
private SignResponse performLegacySignature(CryptoMarkerType cryptoMarker, byte[] slotHandle, BaseTemplateContext templateCTX) throws APDUTemplateException, APDUException, WSHelper.WSException {
    SignResponse response = WSHelper.makeResponse(SignResponse.class, WSHelper.makeResultOK());
    List<CardCallTemplateType> legacyCommands = cryptoMarker.getLegacySignatureGenerationInfo();
    CardCommandAPDU cmdAPDU = null;
    CardResponseAPDU responseAPDU = null;
    byte[] signedMessage;
    for (CardCallTemplateType cctt : legacyCommands) {
        CardCommandTemplate template = new CardCommandTemplate(cctt);
        cmdAPDU = template.evaluate(templateCTX);
        responseAPDU = cmdAPDU.transmit(dispatcher, slotHandle, Collections.<byte[]>emptyList());
    }
    signedMessage = responseAPDU.getData();
    while (responseAPDU.getTrailer()[0] == (byte) 0x61) {
        CardCommandAPDU getResponseData = new CardCommandAPDU((byte) 0x00, (byte) 0xC0, (byte) 0x00, (byte) 0x00, responseAPDU.getTrailer()[1]);
        responseAPDU = getResponseData.transmit(dispatcher, slotHandle, Collections.<byte[]>emptyList());
        signedMessage = Arrays.concatenate(signedMessage, responseAPDU.getData());
    }
    if (!Arrays.areEqual(responseAPDU.getTrailer(), new byte[] { (byte) 0x90, (byte) 0x00 })) {
        TransmitResponse tr = new TransmitResponse();
        tr.getOutputAPDU().add(responseAPDU.toByteArray());
        WSHelper.checkResult(response);
    }
    response.setSignature(signedMessage);
    return response;
}

Output:
     List<CardCallTemplateType> legacyCommands = cryptoMarker.getLegacySignatureGenerationInfo();
-    CardCommandAPDU cmdAPDU = null;
+    CardCommandAPDU cmdAPDU;
     CardResponseAPDU responseAPDU = null;


Input:
protected Answer copySnapshot(DataObject srcData, DataObject destData) {
    String value = configDao.getValue(Config.BackupSnapshotWait.toString());
    int _backupsnapshotwait = NumbersUtil.parseInt(value, Integer.parseInt(Config.BackupSnapshotWait.getDefaultValue()));
    DataObject cacheData = null;
    Answer answer = null;
    try {
        if (needCacheStorage(srcData, destData)) {
            Scope selectedScope = pickCacheScopeForCopy(srcData, destData);
            cacheData = cacheMgr.getCacheObject(srcData, selectedScope);
            CopyCommand cmd = new CopyCommand(srcData.getTO(), destData.getTO(), _backupsnapshotwait, _mgmtServer.getExecuteInSequence());
            cmd.setCacheTO(cacheData.getTO());
            EndPoint ep = selector.select(srcData, destData);
            if (ep == null) {
                String errMsg = "String_Node_Str";
                s_logger.error(errMsg);
                answer = new Answer(cmd, false, errMsg);
            } else {
                answer = ep.sendMessage(cmd);
            }
        } else {
            CopyCommand cmd = new CopyCommand(srcData.getTO(), destData.getTO(), _backupsnapshotwait, _mgmtServer.getExecuteInSequence());
            EndPoint ep = selector.select(srcData, destData);
            if (ep == null) {
                String errMsg = "String_Node_Str";
                s_logger.error(errMsg);
                answer = new Answer(cmd, false, errMsg);
            } else {
                answer = ep.sendMessage(cmd);
            }
        }
        if (answer == null || !answer.getResult()) {
            if (cacheData != null) {
                cacheMgr.deleteCacheObject(cacheData);
            }
        }
        return answer;
    } catch (Exception e) {
        s_logger.debug("String_Node_Str" + e.toString());
        if (cacheData != null) {
            cacheMgr.deleteCacheObject(cacheData);
        }
        throw new CloudRuntimeException(e.toString());
    }
}

Output:
             cacheData = cacheMgr.getCacheObject(srcData, selectedScope);
-            CopyCommand cmd = new CopyCommand(srcData.getTO(), destData.getTO(), _backupsnapshotwait, _mgmtServer.getExecuteInSequence());
+            CopyCommand cmd = new CopyCommand(srcData.getTO(), destData.getTO(), _backupsnapshotwait, VirtualMachineManager.ExecuteInSequence.value());
             cmd.setCacheTO(cacheData.getTO());


Input:
private BaseFont createFont(String ffn, int fontStyle) {
    String key = ffn + fontStyle;
    synchronized (baseFonts) {
        BaseFont font = (BaseFont) baseFonts.get(key);
        if (font == null) {
            String encoding = getEncoding(ffn);
            Font f = FontFactory.getFont(ffn, encoding, BaseFont.NOT_EMBEDDED, 14, fontStyle);
            font = f.getBaseFont();
            baseFonts.put(key, font);
        }
        return font;
    }
}

Output:
             String encoding = getEncoding(ffn);
-            Font f = FontFactory.getFont(ffn, encoding, BaseFont.NOT_EMBEDDED, 14, fontStyle);
+            Font f = null;
+            try {
+                f = FontFactory.getFont(ffn, encoding, BaseFont.NOT_EMBEDDED, 14, fontStyle);
+            } catch (Throwable de) {
+                logger.log(Level.WARNING, de.getLocalizedMessage());
+                return null;
+            }
             font = f.getBaseFont();


Input:
public <T> T getServiceObject(Class<T> klass) {
    ServiceReference sref = null;
    sref = context.getServiceReference(klass.getName());
    if (sref != null) {
        return (T) context.getService(sref);
    } else {
        return null;
    }
}

Output:
     if (sref != null) {
-        return (T) context.getService(sref);
+        T service = (T) context.getService(sref);
+        context.ungetService(sref);
+        return service;
     } else {


Input:
public void openExerciseViewer() {
    Platform.runLater(() -> {
        final File selectedFile = prHRMFileOpenDialog.get().selectHRMFile(document.getOptions(), null);
        if (selectedFile != null) {
            SwingUtilities.invokeLater(() -> {
                EVMain pv = prExerciseViewer.get();
                pv.showExercise(selectedFile.getAbsolutePath(), document.getOptions(), false);
            });
        }
    });
}

Output:
     Platform.runLater(() -> {
-        final File selectedFile = prHRMFileOpenDialog.get().selectHRMFile(document.getOptions(), null);
+        final File selectedFile = prHRMFileOpenDialog.get().selectHRMFile(context.getPrimaryStage(), document.getOptions(), null);
         if (selectedFile != null) {


Input:
protected boolean isUpToDate(List<File> sourceFiles, File destFile) {
    List<File> destFiles;
    if ((sourceFiles == null) || (sourceFiles.isEmpty())) {
        return true;
    } else if ((destFile == null) || (!destFile.exists())) {
        return false;
    } else if (!destFile.isDirectory()) {
        destFiles = Arrays.asList(destFile);
    } else {
        destFiles = new ArrayList<File>();
        buildFileList(destFiles, destFile);
    }
    return !destFiles.isEmpty() && getLatestTimestamp(sourceFiles) < getEarliestTimestamp(destFiles);
}

Output:
     }
-    return !destFiles.isEmpty() && getLatestTimestamp(sourceFiles) < getEarliestTimestamp(destFiles);
+    if (destFiles.isEmpty()) {
+        debug("String_Node_Str");
+        return false;
+    } else {
+        File youngestSource = getYoungest(sourceFiles);
+        File oldestDest = getOldest(destFiles);
+        if (youngestSource.lastModified() < oldestDest.lastModified()) {
+            debug("String_Node_Str", destFile, oldestDest, youngestSource);
+            return true;
+        } else {
+            debug("String_Node_Str", destFile, oldestDest, youngestSource);
+            return false;
+        }
+    }
 }


Input:
public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
    int width = right - left;
    int height = bottom - top;
    tryToCloseSubList();
    if (mMaxPreviewWidth == 0 && mMaxPreviewHeight == 0) {
        mMaxPreviewWidth = width;
        mMaxPreviewHeight = height;
    }
    if (mOrientationResize != mPrevOrientationResize || mAspectRatioResize) {
        layoutPreview(mAspectRatio);
        mAspectRatioResize = false;
    }
}

Output:
     }
-    if (mOrientationResize != mPrevOrientationResize || mAspectRatioResize) {
+    if (mOrientationResize != mPrevOrientationResize || mAspectRatioResize || !mIsLayoutInitializedAlready) {
         layoutPreview(mAspectRatio);


Input:
public static int getTimeout(HazelcastInstance instance, String regionName) {
    int ttl = DEFAULT_TIMEOUT;
    try {
        final MapConfig cfg = instance.getConfig().findMatchingMapConfig(regionName);
        if (cfg.getTimeToLiveSeconds() > 0) {
            ttl = cfg.getTimeToLiveSeconds() * 1000;
        }
    } catch (UnsupportedOperationException ignore) {
    }
    return ttl;
}

Output:
         if (cfg.getTimeToLiveSeconds() > 0) {
-            ttl = cfg.getTimeToLiveSeconds() * 1000;
+            return cfg.getTimeToLiveSeconds() * 1000;
         }


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object value, CoreAbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    if (null == value) {
        return false;
    }
    Object originalValue = value;
    VariableXPathObjectMapping mapping = (VariableXPathObjectMapping) this.getMapping();
    Descriptor descriptor = (Descriptor) mapping.getReferenceDescriptor();
    if (descriptor.hasInheritance()) {
        Class objectValueClass = value.getClass();
        if (!(objectValueClass == descriptor.getJavaClass())) {
            descriptor = (Descriptor) session.getDescriptor(objectValueClass);
        }
    }
    Marshaller marshaller = marshalRecord.getMarshaller();
    XPathFragment rootFragment;
    ObjectBuilder objectBuilder = (TreeObjectBuilder) descriptor.getObjectBuilder();
    List extraNamespaces = objectBuilder.addExtraNamespacesToNamespaceResolver(descriptor, marshalRecord, session, true, true);
    String defaultRootElementString = descriptor.getDefaultRootElement();
    marshalRecord.beforeContainmentMarshal(value);
    rootFragment = mapping.getXPathFragmentForValue(value, marshalRecord.getNamespaceResolver(), marshalRecord.isNamespaceAware(), marshalRecord.getNamespaceSeparator());
    if (rootFragment.isGeneratedPrefix()) {
        if (extraNamespaces == null) {
            extraNamespaces = new ArrayList();
        }
        extraNamespaces.add(new Namespace(rootFragment.getPrefix(), rootFragment.getNamespaceURI()));
    }
    XPathFragment groupingFragment = marshalRecord.openStartGroupingElements(namespaceResolver);
    if (mapping.isAttribute()) {
        ObjectBuilder tob = (ObjectBuilder) mapping.getReferenceDescriptor().getObjectBuilder();
        MappingNodeValue textMappingNodeValue = (MappingNodeValue) tob.getRootXPathNode().getTextNode().getMarshalNodeValue();
        Mapping textMapping = textMappingNodeValue.getMapping();
        if (textMapping.isAbstractDirectMapping()) {
            DirectMapping xmlDirectMapping = (DirectMapping) textMapping;
            Object fieldValue = xmlDirectMapping.getFieldValue(xmlDirectMapping.valueFromObject(value, xmlDirectMapping.getField(), session), session, marshalRecord);
            QName schemaType = ((Field) xmlDirectMapping.getField()).getSchemaTypeForValue(fieldValue, session);
            marshalRecord.attribute(rootFragment, namespaceResolver, fieldValue, schemaType);
            return true;
        } else {
            return textMappingNodeValue.marshalSingleValue(rootFragment, marshalRecord, value, textMapping.getAttributeValueFromObject(value), session, namespaceResolver, marshalContext);
        }
    } else {
        marshalRecord.closeStartGroupingElements(groupingFragment);
        getXPathNode().startElement(marshalRecord, rootFragment, object, session, marshalRecord.getNamespaceResolver(), objectBuilder, value);
        writeExtraNamespaces(extraNamespaces, marshalRecord, session);
        marshalRecord.addXsiTypeAndClassIndicatorIfRequired(descriptor, (Descriptor) mapping.getReferenceDescriptor(), (Field) mapping.getField(), originalValue, value, false, false);
        objectBuilder.buildRow(marshalRecord, value, session, marshaller, null);
        marshalRecord.afterContainmentMarshal(object, value);
        marshalRecord.endElement(rootFragment, namespaceResolver);
        marshalRecord.removeExtraNamespacesFromNamespaceResolver(extraNamespaces, session);
    }
    return true;
}

Output:
     XPathFragment rootFragment;
-    ObjectBuilder objectBuilder = (TreeObjectBuilder) descriptor.getObjectBuilder();
+    ObjectBuilder objectBuilder = (ObjectBuilder) descriptor.getObjectBuilder();
     List extraNamespaces = objectBuilder.addExtraNamespacesToNamespaceResolver(descriptor, marshalRecord, session, true, true);


Input:
public boolean hasNext() {
    if (taskCanceled)
        return false;
    if (firstValue)
        return true;
    return values.hasNext();
}

Output:
         return false;
-    if (firstValue)
+    if (bufferIdx < VALUE_BUFFER_SIZE)
         return true;


Input:
public void onCreate() {
    String prefs = getDefaultSharedPreferencesName();
    SharedPreferencesBackupHelper sharedPreferencesBackupHelper = new SharedPreferencesBackupHelper(this, prefs);
    addHelper(PREFS_BACKUP_KEY, sharedPreferencesBackupHelper);
    FileBackupHelper fileBackupHelper = new FileBackupHelper(this, DatabaseHelper.KEY_FILE, DatabaseHelper.SETTINGS_FILE);
    addHelper(FILES_BACKUP_KEY, fileBackupHelper);
}

Output:
     addHelper(PREFS_BACKUP_KEY, sharedPreferencesBackupHelper);
-    FileBackupHelper fileBackupHelper = new FileBackupHelper(this, DatabaseHelper.KEY_FILE, DatabaseHelper.SETTINGS_FILE);
+    FileBackupHelper fileBackupHelper = new FileBackupHelper(this, Constants.FILENAME_ENCRYPTED_KEY, Constants.FILENAME_DATABASE, Constants.FILENAME_DATABASE_BACKUP);
     addHelper(FILES_BACKUP_KEY, fileBackupHelper);


Input:
private String getDefaultTlsDirectory() {
    return System.getProperty("String_Node_Str") + File.separator + "String_Node_Str" + File.separator + "String_Node_Str";
}

Output:
 private String getDefaultTlsDirectory() {
-    return System.getProperty("String_Node_Str") + File.separator + "String_Node_Str" + File.separator + "String_Node_Str";
+    return "String_Node_Str" + File.separator + "String_Node_Str" + File.separator + "String_Node_Str";
 }


Input:
public void initializeDistributedObject(String serviceName, String name) {
    if (serviceName == null) {
        throw new NullPointerException("String_Node_Str");
    }
    if (name == null) {
        throw new NullPointerException("String_Node_Str");
    }
    ProxyRegistry registry = ConcurrencyUtil.getOrPutIfAbsent(registries, serviceName, registryConstructor);
    registry.getProxy(name, true, true);
}

Output:
     ProxyRegistry registry = ConcurrencyUtil.getOrPutIfAbsent(registries, serviceName, registryConstructor);
-    registry.getProxy(name, true, true);
+    registry.createProxy(name, true, true);
 }


Input:
private void openFilterOptions() {
    final Intent intent = new Intent(this, ActivityFilter.class);
    intent.putExtra(ActivityFilter.INPUT_FILTER_ARRAY, filters);
    intent.putExtra(ActivityFilter.INPUT_DISTANCE, currentDistanceInKilometers);
    startActivityForResult(intent, ActivityFilter.FILTER_REQUEST_CODE);
}

Output:
     final Intent intent = new Intent(this, ActivityFilter.class);
-    intent.putExtra(ActivityFilter.INPUT_FILTER_ARRAY, filters);
+    intent.putExtra(ActivityFilter.INPUT_FILTER_ARRAY, state.filters);
     intent.putExtra(ActivityFilter.INPUT_DISTANCE, currentDistanceInKilometers);


Input:
public boolean completeTx(SendRequest req) {
    lock.lock();
    try {
        Preconditions.checkArgument(!req.completed, "String_Node_Str");
        BigInteger value = BigInteger.ZERO;
        for (TransactionOutput output : req.tx.getOutputs()) {
            value = value.add(output.getValue());
        }
        value = value.add(req.fee);
        log.info("String_Node_Str", req.tx.getOutputs().size(), bitcoinValueToFriendlyString(value));
        LinkedList<TransactionOutput> candidates = calculateSpendCandidates(true);
        CoinSelection selection = coinSelector.select(value, candidates);
        if (selection.valueGathered.compareTo(value) < 0) {
            log.warn("String_Node_Str" + bitcoinValueToFriendlyString(value.subtract(selection.valueGathered)));
            return false;
        }
        checkState(selection.gathered.size() > 0);
        req.tx.getConfidence().setConfidenceType(ConfidenceType.NOT_SEEN_IN_CHAIN);
        BigInteger change = selection.valueGathered.subtract(value);
        if (change.compareTo(BigInteger.ZERO) > 0) {
            Address changeAddress = req.changeAddress != null ? req.changeAddress : getChangeAddress();
            log.info("String_Node_Str", bitcoinValueToFriendlyString(change));
            req.tx.addOutput(new TransactionOutput(params, req.tx, change, changeAddress));
        }
        for (TransactionOutput output : selection.gathered) {
            req.tx.addInput(output);
        }
        try {
            req.tx.signInputs(Transaction.SigHash.ALL, this, req.aesKey);
        } catch (ScriptException e) {
            throw new RuntimeException(e);
        }
        int size = req.tx.bitcoinSerialize().length;
        if (size > Transaction.MAX_STANDARD_TX_SIZE) {
            log.error("String_Node_Str", size, Transaction.MAX_STANDARD_TX_SIZE);
            return false;
        }
        req.tx.getConfidence().setSource(TransactionConfidence.Source.SELF);
        req.completed = true;
        log.info("String_Node_Str", req.tx.getHashAsString());
        return true;
    } finally {
        lock.unlock();
    }
}

Output:
         req.completed = true;
-        log.info("String_Node_Str", req.tx.getHashAsString());
+        log.info("String_Node_Str", req.tx.getHashAsString(), req.tx.getInputs().size());
         return true;


Input:
public AbstractComponentsProvider loadUserComponentsProvidersFromExtension() {
    providers = new ArrayList<AbstractComponentsProvider>();
    IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
    IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint("String_Node_Str");
    IExtension[] extensions = extensionPoint.getExtensions();
    for (IExtension extension : extensions) {
        IConfigurationElement[] configurationElements = extension.getConfigurationElements();
        for (IConfigurationElement configurationElement : configurationElements) {
            String id = configurationElement.getAttribute("String_Node_Str");
            if ("String_Node_Str".equals(id)) {
                String folderName = configurationElement.getAttribute("String_Node_Str");
                try {
                    AbstractComponentsProvider componentsProvider = (AbstractComponentsProvider) configurationElement.createExecutableExtension("String_Node_Str");
                    componentsProvider.setId(id);
                    componentsProvider.setFolderName(folderName);
                    return componentsProvider;
                } catch (CoreException e) {
                    log.error(Messages.getString("String_Node_Str") + id, e);
                }
            }
        }
    }
    return null;
}

Output:
 public AbstractComponentsProvider loadUserComponentsProvidersFromExtension() {
-    providers = new ArrayList<AbstractComponentsProvider>();
-    IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
-    IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint("String_Node_Str");
-    IExtension[] extensions = extensionPoint.getExtensions();
-    for (IExtension extension : extensions) {
-        IConfigurationElement[] configurationElements = extension.getConfigurationElements();
-        for (IConfigurationElement configurationElement : configurationElements) {
-            String id = configurationElement.getAttribute("String_Node_Str");
-            if ("String_Node_Str".equals(id)) {
-                String folderName = configurationElement.getAttribute("String_Node_Str");
-                try {
-                    AbstractComponentsProvider componentsProvider = (AbstractComponentsProvider) configurationElement.createExecutableExtension("String_Node_Str");
-                    componentsProvider.setId(id);
-                    componentsProvider.setFolderName(folderName);
-                    return componentsProvider;
-                } catch (CoreException e) {
-                    log.error(Messages.getString("String_Node_Str") + id, e);
-                }
-            }
+    if (providers == null) {
+        loadComponentsProvidersFromExtension();
+    }
+    for (AbstractComponentsProvider provider : providers) {
+        if ("String_Node_Str".equals(provider.getId())) {
+            return provider;
         }


Input:
public synchronized File getFile(RemoteFileDesc rfd) {
    File incDir = SharingSettings.INCOMPLETE_DIRECTORY.getValue();
    incDir.mkdirs();
    String convertedName = CommonUtils.convertFileName(rfd.getFileName());
    URN sha1 = rfd.getSHA1Urn();
    if (sha1 != null) {
        File file = (File) hashes.get(sha1);
        if (file != null) {
            return file;
        } else {
            for (int i = 1; ; i++) {
                file = new File(incDir, tempName(convertedName, rfd.getSize(), i));
                try {
                    file = FileUtils.getCanonicalFile(file);
                } catch (IOException ignored) {
                }
                if (!hashes.values().contains(file))
                    break;
            }
            hashes.put(sha1, file);
            return file;
        }
    } else {
        File f = new File(incDir, tempName(convertedName, rfd.getSize(), 0));
        try {
            f = FileUtils.getCanonicalFile(f);
        } catch (IOException ignored) {
        }
        return f;
    }
}

Output:
                 file = new File(incDir, tempName(convertedName, rfd.getSize(), i));
-                try {
-                    file = FileUtils.getCanonicalFile(file);
-                } catch (IOException ignored) {
-                }
+                file = FileUtils.getCanonicalFile(file);
                 if (!hashes.values().contains(file))


Input:
protected int sameDocSingle(EObject o, EStructuralFeature f) {
    InternalEObject value = (InternalEObject) helper.getValue(o, f);
    if (value == null) {
        return SKIP;
    } else if (value.eIsProxy()) {
        return CROSS_DOC;
    } else {
        Resource res = value.eResource();
        return res == helper.getResource() ? SAME_DOC : CROSS_DOC;
    }
}

Output:
         Resource res = value.eResource();
-        return res == helper.getResource() ? SAME_DOC : CROSS_DOC;
+        return res == helper.getResource() || res == null ? SAME_DOC : CROSS_DOC;
     }