Input:
private void updateROMPublicProperties(Properties designProps, ReportElementHandle sourceHandle) throws SemanticException {
    if (designProps == null)
        return;
    EList publicProps = designProps.getProperties();
    for (int i = 0; i < publicProps.size(); i++) {
        Property prop = (Property) publicProps.get(i);
        String propName = prop.getName();
        String propValue = prop.getValue();
        PropertyValueValidationUtil.validateProperty(sourceHandle, propName, propValue);
        sourceHandle.getElement().setProperty(propName, propValue);
    }
}

Output:
         PropertyValueValidationUtil.validateProperty(sourceHandle, propName, propValue);
-        sourceHandle.getElement().setProperty(propName, propValue);
+        sourceHandle.setProperty(propName, propValue);
     }


Input:
public void handleRequest(HttpServerExchange exchange, RequestContext context) throws Exception {
    ObjectId oid;
    String sid;
    if (ObjectId.isValid(context.getDocumentId())) {
        sid = null;
        oid = new ObjectId(context.getDocumentId());
    } else {
        sid = context.getDocumentId();
        oid = null;
    }
    BasicDBObject query;
    if (oid != null) {
        query = new BasicDBObject("String_Node_Str", oid);
    } else {
        query = new BasicDBObject("String_Node_Str", sid);
    }
    DBObject document = CollectionDAO.getCollection(context.getDBName(), context.getCollectionName()).findOne(query);
    if (document == null) {
        ResponseHelper.endExchangeWithMessage(exchange, HttpStatus.SC_NOT_FOUND, "String_Node_Str" + context.getDBName() + "String_Node_Str" + context.getCollectionName() + "String_Node_Str" + context.getDocumentId() + "String_Node_Str");
        return;
    }
    Object etag = document.get("String_Node_Str");
    if (etag != null && ObjectId.isValid("String_Node_Str" + etag)) {
        ObjectId _etag = new ObjectId("String_Node_Str" + etag);
        document.put("String_Node_Str", Instant.ofEpochSecond(_etag.getTimestamp()).toString());
        if (false && RequestHelper.checkReadEtag(exchange, etag.toString())) {
            ResponseHelper.endExchange(exchange, HttpStatus.SC_NOT_MODIFIED);
            return;
        }
    }
    ResponseHelper.injectEtagHeader(exchange, document);
    exchange.setResponseCode(HttpStatus.SC_OK);
    DocumentRepresentationFactory.sendDocument(exchange, context, document);
    exchange.endExchange();
}

Output:
     exchange.setResponseCode(HttpStatus.SC_OK);
-    DocumentRepresentationFactory.sendDocument(exchange, context, document);
+    DocumentRepresentationFactory.sendDocument(requestPath, exchange, context, document);
     exchange.endExchange();


Input:
public void perform(Run<?, ?> build, EnvVars envVars, FilePath workspace, Launcher launcher, TaskListener listener) throws AbortException {
    KlocworkLogger logger = new KlocworkLogger("String_Node_Str", listener.getLogger());
    if (gatewayConfig.getEnableServerGateway()) {
        logger.logMessage("String_Node_Str");
        for (KlocworkGatewayServerConfig pfConfig : gatewayConfig.getGatewayServerConfigs()) {
            String request = "String_Node_Str" + envVars.get(KlocworkConstants.KLOCWORK_PROJECT);
            if (!StringUtils.isEmpty(pfConfig.getQuery())) {
                try {
                    request += "String_Node_Str" + URLEncoder.encode(pfConfig.getQuery(), "String_Node_Str");
                } catch (UnsupportedEncodingException ex) {
                    throw new AbortException(ex.getMessage());
                }
            }
            logger.logMessage("String_Node_Str" + pfConfig.getConditionName());
            logger.logMessage("String_Node_Str" + request);
            JSONArray response;
            try {
                String[] ltokenLine = KlocworkUtil.getLtokenValues(envVars, launcher);
                KlocworkApiConnection kwService = new KlocworkApiConnection(envVars.get(KlocworkConstants.KLOCWORK_URL), ltokenLine[KlocworkConstants.LTOKEN_USER_INDEX], ltokenLine[KlocworkConstants.LTOKEN_HASH_INDEX]);
                response = kwService.sendRequest(request);
            } catch (IOException ex) {
                throw new AbortException("String_Node_Str" + "String_Node_Str" + ex.getMessage());
            }
            logger.logMessage("String_Node_Str" + Integer.toString(response.size()));
            logger.logMessage("String_Node_Str" + pfConfig.getThreshold());
            if (response.size() >= Integer.parseInt(pfConfig.getThreshold())) {
                logger.logMessage("String_Node_Str");
                build.setResult(pfConfig.getResultValue());
            }
            for (int i = 0; i < response.size(); i++) {
                JSONObject jObj = response.getJSONObject(i);
                logger.logMessage(jObj.toString());
            }
        }
    }
    if (gatewayConfig.getEnableDesktopGateway()) {
        logger.logMessage("String_Node_Str");
        String xmlReport = envVars.expand(KlocworkUtil.getDefaultKwcheckReportFile(gatewayConfig.getGatewayDesktopConfig().getReportFile()));
        logger.logMessage("String_Node_Str" + xmlReport);
        try {
            int totalIssueCount = launcher.getChannel().call(new KlocworkXMLReportParser(workspace.getRemote(), xmlReport));
            logger.logMessage("String_Node_Str" + Integer.toString(totalIssueCount));
            logger.logMessage("String_Node_Str" + gatewayConfig.getGatewayDesktopConfig().getThreshold());
            if (totalIssueCount >= Integer.parseInt(gatewayConfig.getGatewayDesktopConfig().getThreshold())) {
                logger.logMessage("String_Node_Str");
                build.setResult(Result.FAILURE);
            }
        } catch (InterruptedException | IOException ex) {
            throw new AbortException(ex.getMessage());
        }
    }
}

Output:
                 try {
-                    request += "String_Node_Str" + URLEncoder.encode(pfConfig.getQuery(), "String_Node_Str");
+                    request += "String_Node_Str";
+                    if (!pfConfig.getQuery().toLowerCase().contains("String_Node_Str") && !pfConfig.getQuery().toLowerCase().contains("String_Node_Str")) {
+                        request += "String_Node_Str";
+                    }
+                    request += URLEncoder.encode(pfConfig.getQuery(), "String_Node_Str");
                 } catch (UnsupportedEncodingException ex) {


Input:
public void widgetSelected(final SelectionEvent arg0) {
    selectedEscape = comboLinebreak.getSelectionIndex();
    evaluatePage();
}

Output:
 public void widgetSelected(final SelectionEvent arg0) {
-    selectedEscape = comboLinebreak.getSelectionIndex();
+    selectedLinebreak = comboLinebreak.getSelectionIndex();
+    customLinebreak = true;
     evaluatePage();


Input:
private EvictionConfig getEvictionConfig(final Node node) {
    final EvictionConfig evictionConfig = new EvictionConfig();
    final Node size = node.getAttributes().getNamedItem("String_Node_Str");
    final Node maxSizePolicy = node.getAttributes().getNamedItem("String_Node_Str");
    final Node evictionPolicy = node.getAttributes().getNamedItem("String_Node_Str");
    if (size != null) {
        evictionConfig.setSize(Integer.parseInt(getTextContent(size)));
    }
    if (maxSizePolicy != null) {
        evictionConfig.setMaxSizePolicy(EvictionConfig.MaxSizePolicy.valueOf(upperCaseInternal(getTextContent(maxSizePolicy))));
    }
    if (evictionPolicy != null) {
        evictionConfig.setEvictionPolicy(EvictionPolicy.valueOf(upperCaseInternal(getTextContent(evictionPolicy))));
    }
    return evictionConfig;
}

Output:
     if (maxSizePolicy != null) {
-        evictionConfig.setMaxSizePolicy(EvictionConfig.MaxSizePolicy.valueOf(upperCaseInternal(getTextContent(maxSizePolicy))));
+        evictionConfig.setMaximumSizePolicy(EvictionConfig.MaxSizePolicy.valueOf(upperCaseInternal(getTextContent(maxSizePolicy))));
     }


Input:
public void glDrawArrays(int primitive, int offset, int vertexCount) {
    IGraphicsDevice.super.glDrawArrays(primitive, offset, vertexCount);
    GLES30.glDrawArrays(primitive, offset, vertexCount);
}

Output:
 public void glDrawArrays(int primitive, int offset, int vertexCount) {
-    IGraphicsDevice.super.glDrawArrays(primitive, offset, vertexCount);
+    Data.renderCallsThisFrame++;
+    Data.totalRenderCalls++;
     GLES30.glDrawArrays(primitive, offset, vertexCount);


Input:
public ServiceTags getServiceTagsIfUpdated(long lastKnownVersion) throws Exception {
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + lastKnownVersion + "String_Node_Str");
    }
    ServiceTags ret;
    WebResource webResource = createWebResource(RangerRESTUtils.REST_URL_GET_SERVICE_TAGS_IF_UPDATED).queryParam(RangerRESTUtils.SERVICE_NAME_PARAM, serviceName).queryParam(RangerRESTUtils.LAST_KNOWN_TAG_VERSION_PARAM, Long.toString(lastKnownVersion)).queryParam(RangerRESTUtils.REST_PARAM_PLUGIN_ID, pluginId);
    ClientResponse response = webResource.accept(RangerRESTUtils.REST_MIME_TYPE_JSON).get(ClientResponse.class);
    if (response != null && response.getStatus() == 200) {
        ret = response.getEntity(ServiceTags.class);
    } else {
        RESTResponse resp = RESTResponse.fromClientResponse(response);
        LOG.error("String_Node_Str" + webResource.toString() + "String_Node_Str" + resp.toString() + "String_Node_Str" + serviceName + "String_Node_Str" + "String_Node_Str" + lastKnownVersion);
        throw new Exception(resp.getMessage());
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + lastKnownVersion + "String_Node_Str");
    }
    return ret;
}

Output:
     ServiceTags ret;
-    WebResource webResource = createWebResource(RangerRESTUtils.REST_URL_GET_SERVICE_TAGS_IF_UPDATED).queryParam(RangerRESTUtils.SERVICE_NAME_PARAM, serviceName).queryParam(RangerRESTUtils.LAST_KNOWN_TAG_VERSION_PARAM, Long.toString(lastKnownVersion)).queryParam(RangerRESTUtils.REST_PARAM_PLUGIN_ID, pluginId);
+    WebResource webResource = createWebResource(RangerRESTUtils.REST_URL_GET_SERVICE_TAGS_IF_UPDATED + serviceName).queryParam(RangerRESTUtils.LAST_KNOWN_TAG_VERSION_PARAM, Long.toString(lastKnownVersion)).queryParam(RangerRESTUtils.REST_PARAM_PLUGIN_ID, pluginId);
     ClientResponse response = webResource.accept(RangerRESTUtils.REST_MIME_TYPE_JSON).get(ClientResponse.class);


Input:
public List<MetricGraphData> getMetricValue(CriteriaInfo criteriaInfo, long beginTime, long duration, int aggregationPeriod, String autoDelay) {
    List<MetricGraphData> result = new ArrayList<MetricGraphData>();
    Map<Long, MetricGraphData> metricGraphDataByTime = new TreeMap<Long, MetricGraphData>();
    String encodedMetricName = criteriaInfo.getMetricName();
    String metricName = decodeMetricName(encodedMetricName);
    long endTime = beginTime + TimeUnit.SECONDS.toMillis(duration);
    boolean serverSide = MonitoringSystem.COLLECTION_LOCATION_SERVER.equals(criteriaInfo.getRoleType());
    boolean totalizeResultsPerService = false;
    Map<String, List<String>> filters = new HashMap<String, List<String>>();
    if (criteriaInfo.getServiceName() != null) {
        filters.put("String_Node_Str", Arrays.asList(criteriaInfo.getServiceName().trim()));
    }
    if (criteriaInfo.getOperationName() != null) {
        filters.put("String_Node_Str", Arrays.asList(criteriaInfo.getOperationName().trim()));
    }
    if (criteriaInfo.getConsumerName() != null) {
        filters.put("String_Node_Str", Arrays.asList(criteriaInfo.getConsumerName().trim()));
    }
    Map<String, List<MetricValue<?>>> metricValuesMap;
    List<String> serviceNames = filters.get("String_Node_Str");
    List<String> operationNames = filters.get("String_Node_Str");
    List<String> consumerNames = filters.get("String_Node_Str");
    if (operationNames == null || operationNames.isEmpty()) {
        operationNames = metricsServiceOperationByIpDAO.findMetricOperationNames(serviceNames);
        operationNames = removeServiceNamePrefix(operationNames);
        filters.put("String_Node_Str", operationNames);
        totalizeResultsPerService = true;
    }
    if (consumerNames != null && !consumerNames.isEmpty()) {
        for (String serviceName : serviceNames) {
            List<String> ipAddressList = ipPerDayAndServiceNameDAO.findByDateAndServiceName(System.currentTimeMillis(), serviceName);
            metricValuesMap = metricValuesDAO.findMetricValuesByConsumer(ipAddressList, metricName, beginTime, endTime, serverSide, aggregationPeriod, serviceName, operationNames, consumerNames);
            for (String consumerName : consumerNames) {
                List<MetricValue<?>> metricValues = metricValuesMap.get(consumerName);
                for (int i = 0; i < duration / aggregationPeriod; ++i) {
                    long startTime = beginTime + TimeUnit.SECONDS.toMillis(i * aggregationPeriod);
                    long stopTime = startTime + TimeUnit.SECONDS.toMillis(aggregationPeriod);
                    double value = 0;
                    for (MetricValue<?> metricValue : metricValues) {
                        long time = metricValue.getTimeMiliseconds();
                        if (startTime <= time && time < stopTime) {
                            value += metricValue.getValueForMetric(encodedMetricName);
                        }
                    }
                    MetricGraphData metricGraphData = new MetricGraphData();
                    metricGraphData.setCount(value);
                    metricGraphData.setTimeSlot(startTime);
                    metricGraphData.setCriteria(null);
                    if (totalizeResultsPerService) {
                        MetricGraphData alreadyStoredMetricGraph = null;
                        if (metricGraphDataByTime.containsKey(startTime)) {
                            alreadyStoredMetricGraph = metricGraphDataByTime.get(startTime);
                            alreadyStoredMetricGraph.setCount(metricGraphData.getCount() + alreadyStoredMetricGraph.getCount());
                        } else {
                            result.add(metricGraphData);
                            metricGraphDataByTime.put(startTime, metricGraphData);
                        }
                    } else {
                        result.add(metricGraphData);
                    }
                }
            }
        }
    } else {
        for (String serviceName : serviceNames) {
            List<String> ipAddressList = ipPerDayAndServiceNameDAO.findByDateAndServiceName(System.currentTimeMillis(), serviceName);
            metricValuesMap = metricValuesDAO.findMetricValuesByOperation(ipAddressList, metricName, beginTime, endTime, serverSide, aggregationPeriod, filters);
            operationNames = filters.get("String_Node_Str");
            for (String opName : operationNames) {
                List<MetricValue<?>> metricValues = metricValuesMap.get(opName);
                for (int i = 0; i < duration / aggregationPeriod; ++i) {
                    long startTime = beginTime + TimeUnit.SECONDS.toMillis(i * aggregationPeriod);
                    long stopTime = startTime + TimeUnit.SECONDS.toMillis(aggregationPeriod);
                    double value = 0;
                    for (MetricValue<?> metricValue : metricValues) {
                        long time = metricValue.getTimeMiliseconds();
                        if (startTime <= time && time < stopTime) {
                            value += metricValue.getValueForMetric(encodedMetricName);
                            break;
                        }
                    }
                    MetricGraphData metricGraphData = new MetricGraphData();
                    metricGraphData.setCount(value);
                    metricGraphData.setTimeSlot(startTime);
                    metricGraphData.setCriteria(null);
                    if (totalizeResultsPerService) {
                        MetricGraphData alreadyStoredMetricGraph = null;
                        if (metricGraphDataByTime.containsKey(startTime)) {
                            alreadyStoredMetricGraph = metricGraphDataByTime.get(startTime);
                            alreadyStoredMetricGraph.setCount(metricGraphData.getCount() + alreadyStoredMetricGraph.getCount());
                        } else {
                            result.add(metricGraphData);
                            metricGraphDataByTime.put(startTime, metricGraphData);
                        }
                    } else {
                        result.add(metricGraphData);
                    }
                }
            }
        }
    }
    return result;
}

Output:
         for (String serviceName : serviceNames) {
-            List<String> ipAddressList = ipPerDayAndServiceNameDAO.findByDateAndServiceName(System.currentTimeMillis(), serviceName);
+            List<String> ipAddressList = ipPerDayAndServiceNameDAO.findByDateAndServiceName(beginTime, serviceName);
+            ipAddressList = ListUtils.sum(ipAddressList, ipPerDayAndServiceNameDAO.findByDateAndServiceName(endTime, serviceName));
             metricValuesMap = metricValuesDAO.findMetricValuesByConsumer(ipAddressList, metricName, beginTime, endTime, serverSide, aggregationPeriod, serviceName, operationNames, consumerNames);


Input:
public String genPigJoinCode(String uidColumnName, String outputPath, List<ColumnFile> columnFileList) throws IOException {
    ByteArrayOutputStream byos = new ByteArrayOutputStream();
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(byos));
    try {
        List<String> relations = new ArrayList<String>();
        int i = 0;
        for (ColumnFile columnFile : columnFileList) {
            String relation = DATA_PREFIX + (i++);
            writeLine(writer, relation + "String_Node_Str" + columnFile.getFilePath() + "String_Node_Str");
            if (columnFile.hasSelectedVar(uidColumnName)) {
                writeLine(writer, relation + "String_Node_Str" + relation + "String_Node_Str" + columnFile.genFieldSelector() + "String_Node_Str");
            } else {
                writeLine(writer, relation + "String_Node_Str" + relation + "String_Node_Str" + uidColumnName + "String_Node_Str" + columnFile.genFieldSelector() + "String_Node_Str");
            }
            relations.add(relation);
        }
        writeLine(writer, "String_Node_Str" + genGroupByClauses(relations, uidColumnName) + "String_Node_Str");
        writeLine(writer, "String_Node_Str" + genFlattenClauses(relations) + "String_Node_Str");
        writeLine(writer, "String_Node_Str" + genRenameClauses(columnFileList, relations));
        writeLine(writer, "String_Node_Str" + outputPath + "String_Node_Str");
    } catch (IOException e) {
        LOG.error("String_Node_Str", e);
        throw e;
    } finally {
        IOUtils.closeQuietly(writer);
        IOUtils.closeQuietly(byos);
    }
    return byos.toString();
}

Output:
             } else {
-                writeLine(writer, relation + "String_Node_Str" + relation + "String_Node_Str" + uidColumnName + "String_Node_Str" + columnFile.genFieldSelector() + "String_Node_Str");
+                writeLine(writer, relation + "String_Node_Str" + relation + "String_Node_Str" + uidColumnName + "String_Node_Str" + uidColumnName + "String_Node_Str" + columnFile.genFieldSelector() + "String_Node_Str");
             }


Input:
private void cancelGroupChildrenLocked(NotificationRecord r, int callingUid, int callingPid, String listenerName, int reason) {
    Notification n = r.getNotification();
    if (!n.isGroupSummary()) {
        return;
    }
    String pkg = r.sbn.getPackageName();
    int userId = r.getUserId();
    if (pkg == null) {
        if (DBG)
            Log.e(TAG, "String_Node_Str" + r.getKey());
        return;
    }
    final int N = mNotificationList.size();
    for (int i = N - 1; i >= 0; i--) {
        NotificationRecord childR = mNotificationList.get(i);
        StatusBarNotification childSbn = childR.sbn;
        if ((childSbn.isGroup() && !childSbn.getNotification().isGroupSummary()) && childR.getGroupKey().equals(r.getGroupKey())) {
            EventLogTags.writeNotificationCancel(callingUid, callingPid, pkg, childSbn.getId(), childSbn.getTag(), userId, 0, 0, reason, listenerName);
            mNotificationList.remove(i);
            cancelNotificationLocked(childR, false, reason);
        }
    }
}

Output:
             mNotificationList.remove(i);
-            cancelNotificationLocked(childR, false, reason);
+            cancelNotificationLocked(childR, sendDelete, reason);
         }


Input:
public void setResponse(org.apache.catalina.Response response) {
    this.response = response;
    sessionTracker.setResponse((Response) response);
}

Output:
     this.response = response;
-    sessionTracker.setResponse((Response) response);
+    if (response instanceof Response) {
+        sessionTracker.setResponse((Response) response);
+    }
 }


Input:
public void actionPerformed(ActionEvent e) {
    try {
        TryCatchBlockNode tcbn = new TryCatchBlockNode(null, null, null, null);
        if (new InsnEditDialogue(mn, tcbn).open())
            if (tcbn.handler != null && tcbn.start != null && tcbn.end != null) {
                if (tcbn.type != null && tcbn.type.equals("String_Node_Str")) {
                    tcbn.type = null;
                }
                mn.tryCatchBlocks.add(tcbn);
            }
    } catch (Exception ex) {
        new ErrorDisplay(ex);
    }
    TCBList.this.addNodes(cn, mn);
}

Output:
     try {
-        TryCatchBlockNode tcbn = new TryCatchBlockNode(null, null, null, null);
+        TryCatchBlockNode tcbn = new TryCatchBlockNode(null, null, null, "String_Node_Str");
         if (new InsnEditDialogue(mn, tcbn).open())


Input:
public void writeData(ByteBuf data) {
    super.writeData(data);
    byte[] dBytes = BitSetUtils.toByteArray(delta);
    data.writeBytes(dBytes);
    for (ForgeDirection dir : ForgeDirection.values()) {
        FluidStack liquid = renderCache[dir.ordinal()];
        if (delta.get(dir.ordinal() * FLUID_DATA_NUM + FLUID_ID_BIT)) {
            if (liquid != null) {
                data.writeShort(liquid.fluidID);
                data.writeInt(colorRenderCache[dir.ordinal()]);
            } else {
                data.writeShort(0);
                data.writeInt(0xFFFFFF);
            }
        }
        if (delta.get(dir.ordinal() * FLUID_DATA_NUM + FLUID_AMOUNT_BIT)) {
            if (liquid != null) {
                data.writeInt(liquid.amount);
            } else {
                data.writeInt(0);
            }
        }
    }
}

Output:
     super.writeData(data);
-    byte[] dBytes = BitSetUtils.toByteArray(delta);
+    byte[] dBytes = BitSetUtils.toByteArray(delta, 2);
     data.writeBytes(dBytes);


Input:
protected boolean validateStateFieldPathExpression(StateFieldPathExpression expression, boolean associationFieldValid) {
    boolean valid = true;
    expression.getIdentificationVariable().accept(this);
    if (expression.hasIdentificationVariable() && !expression.endsWithDot()) {
        Object mapping = helper.resolveMapping(expression);
        if (mapping != null) {
            if (helper.isCollectionMapping(mapping)) {
                addProblem(expression, StateFieldPathExpression_CollectionType, expression.toParsedText());
                valid = false;
            } else if (!associationFieldValid && helper.isRelationshipMapping(mapping)) {
                addProblem(expression, StateFieldPathExpression_AssociationField, expression.toParsedText());
                valid = false;
            } else if (helper.isTransient(mapping)) {
                addProblem(expression, StateFieldPathExpression_NoMapping, expression.toParsedText());
                valid = false;
            }
        } else {
            Object type = helper.getType(expression);
            if (!helper.isTypeResolvable(type)) {
                addProblem(expression, StateFieldPathExpression_NotResolvable, expression.toParsedText());
                valid = false;
            } else if (helper.isEnumType(type)) {
                String enumConstant = expression.getPath(expression.pathSize() - 1);
                boolean found = false;
                for (String constant : helper.getEnumConstants(type)) {
                    if (constant.equals(enumConstant)) {
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    int startIndex = position(expression) + helper.getTypeName(type).length() + 1;
                    int endIndex = startIndex + enumConstant.length();
                    addProblem(expression, startIndex, endIndex, StateFieldPathExpression_InvalidEnumConstant, enumConstant);
                    valid = false;
                }
                usedIdentificationVariables.remove(expression.getIdentificationVariable());
            } else {
                addProblem(expression, StateFieldPathExpression_NoMapping, expression.toParsedText());
                valid = false;
            }
        }
    }
    return valid;
}

Output:
             if (helper.isCollectionMapping(mapping)) {
-                addProblem(expression, StateFieldPathExpression_CollectionType, expression.toParsedText());
-                valid = false;
-            } else if (!associationFieldValid && helper.isRelationshipMapping(mapping)) {
-                addProblem(expression, StateFieldPathExpression_AssociationField, expression.toParsedText());
-                valid = false;
+                if (pathType != PathType.ANY_FIELD_INCLUDING_COLLECTION) {
+                    addProblem(expression, StateFieldPathExpression_CollectionType, expression.toActualText());
+                    valid = false;
+                }
             } else if (helper.isTransient(mapping)) {


Input:
public InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionRequest request) throws IOException {
    TopicMetadataCache metadataCache = getTopicMetadataCache(c.getEnvironment());
    LOG.info("String_Node_Str");
    Scan scan = new Scan();
    scan.setFilter(new PayloadDataFilter(c.getEnvironment(), System.currentTimeMillis(), prefixLength, metadataCache));
    return new StoreScanner(store, store.getScanInfo(), scan, scanners, scanType, store.getSmallestReadPoint(), earliestPutTs);
}

Output:
     Scan scan = new Scan();
-    scan.setFilter(new PayloadDataFilter(c.getEnvironment(), System.currentTimeMillis(), prefixLength, metadataCache));
+    scan.setFilter(new PayloadDataFilter(c.getEnvironment(), System.currentTimeMillis(), prefixLength, topicMetadataCache));
     return new StoreScanner(store, store.getScanInfo(), scan, scanners, scanType, store.getSmallestReadPoint(), earliestPutTs);


Input:
public Response get(String id, boolean unread, Integer limit, Integer offset) throws JSONException {
    if (!authenticate()) {
        throw new ForbiddenClientException();
    }
    CategoryDao categoryDao = new CategoryDao();
    Category category = null;
    try {
        category = categoryDao.getCategory(id, principal.getId());
    } catch (NoResultException e) {
        throw new ClientException("String_Node_Str", MessageFormat.format("String_Node_Str", id));
    }
    UserArticleCriteria userArticleCriteria = new UserArticleCriteria();
    userArticleCriteria.setUnread(unread);
    userArticleCriteria.setUserId(principal.getId());
    userArticleCriteria.setSubscribed(true);
    if (category.getParentId() != null) {
        userArticleCriteria.setCategoryId(id);
    }
    UserArticleDao userArticleDao = new UserArticleDao();
    PaginatedList<UserArticleDto> paginatedList = PaginatedLists.create(limit, offset);
    userArticleDao.findByCriteria(userArticleCriteria, paginatedList);
    JSONObject response = new JSONObject();
    List<JSONObject> articles = new ArrayList<JSONObject>();
    for (UserArticleDto userArticle : paginatedList.getResultList()) {
        articles.add(ArticleAssembler.asJson(userArticle));
    }
    response.put("String_Node_Str", paginatedList.getResultCount());
    response.put("String_Node_Str", articles);
    return Response.ok().entity(response).build();
}

Output:
     userArticleCriteria.setUserId(principal.getId());
-    userArticleCriteria.setSubscribed(true);
+    userArticleCriteria.setVisible(true);
     if (category.getParentId() != null) {


Input:
public int getElementNumberOfFoldChangeReduction(ISet compareSet) {
    int numberOfElements = 0;
    ContentVirtualArray origVA = compareSet.getContentVA(ContentVAType.CONTENT);
    double[] resultVector = setToFoldChangeResult.get(compareSet).getFirst();
    FoldChangeSettings settings = setToFoldChangeResult.get(compareSet).getSecond();
    double foldChangeRatio = settings.getRatio();
    FoldChangeEvaluator foldChangeEvaluator = settings.getEvaluator();
    for (Integer contentIndex = 0; contentIndex < origVA.size(); contentIndex++) {
        switch(foldChangeEvaluator) {
            case LESS:
                if (resultVector[contentIndex] > -foldChangeRatio)
                    continue;
                break;
            case GREATER:
                if (resultVector[contentIndex] < foldChangeRatio)
                    continue;
                break;
            case SAME:
                if (Math.abs(resultVector[contentIndex]) > foldChangeRatio)
                    continue;
                break;
        }
        numberOfElements++;
    }
    return numberOfElements;
}

Output:
             case LESS:
-                if (resultVector[contentIndex] > -foldChangeRatio)
+                if (resultVector[contentIndex] > foldChangeRatio)
                     continue;


Input:
public static int parameterCount(final Collection<? extends VariableElement> params) {
    int result = params.size();
    for (VariableElement param : params) {
        if (isAnnotatedWith(param, annotations().param())) {
            --result;
        }
    }
    return (result - (hasCause(params) ? 1 : 0));
}

Output:
     for (VariableElement param : params) {
-        if (isAnnotatedWith(param, annotations().param())) {
+        if (isAnnotatedWith(param, annotations().param()) || isAnnotatedWith(param, annotations().field()) || isAnnotatedWith(param, annotations().property())) {
             --result;


Input:
private void completeDestdir() {
    if (!copyInjars && (null == sourceRootCopyFilter)) {
        return;
    } else if (!destDir.canWrite()) {
        String s = "String_Node_Str" + destDir;
        throw new BuildException(s);
    }
    final Project project = getProject();
    if (copyInjars) {
        String taskName = getTaskName() + "String_Node_Str";
        String[] paths = injars.list();
        if (!LangUtil.isEmpty(paths)) {
            PatternSet patternSet = new PatternSet();
            patternSet.setProject(project);
            patternSet.setIncludes("String_Node_Str");
            patternSet.setExcludes("String_Node_Str");
            for (int i = 0; i < paths.length; i++) {
                Expand unzip = new Expand();
                unzip.setProject(project);
                unzip.setTaskName(taskName);
                unzip.setDest(destDir);
                unzip.setSrc(new File(paths[i]));
                unzip.addPatternset(patternSet);
                unzip.execute();
            }
        }
    }
    if ((null != sourceRootCopyFilter) && (null != sourceRoots)) {
        String[] paths = sourceRoots.list();
        if (!LangUtil.isEmpty(paths)) {
            Copy copy = new Copy();
            copy.setProject(project);
            copy.setTodir(destDir);
            for (int i = 0; i < paths.length; i++) {
                FileSet fileSet = new FileSet();
                fileSet.setDir(new File(paths[i]));
                fileSet.setIncludes("String_Node_Str");
                fileSet.setExcludes(sourceRootCopyFilter);
                copy.addFileset(fileSet);
            }
            copy.execute();
        }
    }
}

Output:
         return;
-    } else if (!destDir.canWrite()) {
+    } else if ((destDir == DEFAULT_DESTDIR) || !destDir.canWrite()) {
         String s = "String_Node_Str" + destDir;


Input:
public void setSavable(boolean savable) {
    saveLive.getAndSet(savable);
}

Output:
 public void setSavable(boolean savable) {
-    saveLive.getAndSet(savable);
+    saveLive.set(savable);
 }


Input:
protected final void initialize() {
    super.initialize();
    setLabelPosition(Position.ABOVE_LITERAL);
    final LineAttributes lia = LineAttributesImpl.create(ColorDefinitionImpl.BLACK(), LineStyle.SOLID_LITERAL, 0);
    lia.setVisible(true);
    setLineAttributes(lia);
}

Output:
     setLabelPosition(Position.ABOVE_LITERAL);
-    final LineAttributes lia = LineAttributesImpl.create(ColorDefinitionImpl.BLACK(), LineStyle.SOLID_LITERAL, 0);
+    final LineAttributes lia = LineAttributesImpl.create(null, LineStyle.SOLID_LITERAL, 0);
     lia.setVisible(true);


Input:
private void handle_null_service_context(ServerRequestInfo ri, ServiceContext sc, ORB orb) {
    if (_logger.isLoggable(Level.FINE)) {
        _logger.log(Level.FINE, "String_Node_Str" + ri.operation());
    }
    int secStatus = secContextUtil.setSecurityContext(null, ri.object_id(), ri.operation(), getServerSocket());
    if (secStatus == SecurityContextUtil.STATUS_FAILED) {
        SASContextBody sasctxbody = createContextError(INVALID_MECHANISM_MAJOR, INVALID_MECHANISM_MINOR);
        sc = createSvcContext(sasctxbody, orb);
        ri.add_reply_service_context(sc, NO_REPLACE);
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, "String_Node_Str");
        }
        throw new NO_PERMISSION();
    }
}

Output:
         SASContextBody sasctxbody = createContextError(INVALID_MECHANISM_MAJOR, INVALID_MECHANISM_MINOR);
-        sc = createSvcContext(sasctxbody, orb);
+        ServiceContext sc = createSvcContext(sasctxbody, orb);
         ri.add_reply_service_context(sc, NO_REPLACE);


Input:
public void initialize(IMessaging messaging, Properties props) throws IOException {
    m_bossGroup = new NioEventLoopGroup();
    m_workerGroup = new NioEventLoopGroup();
    initializePlainTCPTransport(messaging, props);
    initializeWebSocketTransport(messaging, props);
    initializeSSLTCPTransport(messaging, props);
}

Output:
     initializeWebSocketTransport(messaging, props);
-    initializeSSLTCPTransport(messaging, props);
+    String sslTcpPortProp = props.getProperty(Constants.SSL_PORT_PROPERTY_NAME);
+    String wssPortProp = props.getProperty(Constants.WSS_PORT_PROPERTY_NAME);
+    if (sslTcpPortProp != null || wssPortProp != null) {
+        SslHandler sslHandler = initSSLHandler(props);
+        if (sslHandler == null) {
+            LOG.error("String_Node_Str");
+            return;
+        }
+        initializeSSLTCPTransport(messaging, props, sslHandler);
+        initializeWSSTransport(messaging, props, sslHandler);
+    }
 }


Input:
public void shutdown() {
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + getIp() + "String_Node_Str" + getGossipPort() + "String_Node_Str" + getDataPort());
    }
    if (gossipWorkerGroup != null) {
        gossipWorkerGroup.shutdownGracefully();
    }
    if (dataWorkerGroup != null) {
        dataWorkerGroup.shutdownGracefully();
    }
}

Output:
 public void shutdown() {
-    if (LOG.isDebugEnabled()) {
-        LOG.debug("String_Node_Str" + getIp() + "String_Node_Str" + getGossipPort() + "String_Node_Str" + getDataPort());
+    if (LOG.isTraceEnabled()) {
+        LOG.trace("String_Node_Str" + getIp() + "String_Node_Str" + getGossipPort() + "String_Node_Str" + getDataPort());
     }


Input:
public void endReceipt() {
    try {
        PrinterJob printJob = PrinterJob.getPrinterJob();
        printJob.setPrintable(new PrintableTicket(m_ticketcurrent));
        PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet();
        aset.add(OrientationRequested.PORTRAIT);
        aset.add(new Copies(1));
        aset.add(new JobName(AppLocal.APP_NAME + "String_Node_Str", null));
        if (isReceiptPrinter.equals("String_Node_Str")) {
            MediaSize myISO = new MediaSize(widthOfPaper, heightOfPaper, Size2DSyntax.MM, MediaSizeName.NA_LEGAL);
            aset.add(MediaSizeName.NA_LEGAL);
        } else {
            aset.add(MediaSizeName.ISO_A4);
        }
        if (printservice == null) {
            if (printJob.printDialog(aset)) {
                printJob.print();
            }
        } else {
            printJob.setPrintService(printservice);
            printJob.print(aset);
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    m_ticketcurrent = null;
}

Output:
         PrinterJob printJob = PrinterJob.getPrinterJob();
-        printJob.setPrintable(new PrintableTicket(m_ticketcurrent));
-        PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet();
-        aset.add(OrientationRequested.PORTRAIT);
-        aset.add(new Copies(1));
-        aset.add(new JobName(AppLocal.APP_NAME + "String_Node_Str", null));
-        if (isReceiptPrinter.equals("String_Node_Str")) {
-            MediaSize myISO = new MediaSize(widthOfPaper, heightOfPaper, Size2DSyntax.MM, MediaSizeName.NA_LEGAL);
-            aset.add(MediaSizeName.NA_LEGAL);
-        } else {
-            aset.add(MediaSizeName.ISO_A4);
-        }
+        printJob.setJobName(AppLocal.APP_NAME + "String_Node_Str");
+        printerBook.countLinesOnPage(m_ticketcurrent);
+        printJob.setPageable(printerBook.getBook());
         if (printservice == null) {


Input:
private RingbufferContainer clone(RingbufferContainer original) {
    BufferObjectDataOutput out = serializationService.createObjectDataOutput(100000);
    BufferObjectDataInput in = null;
    try {
        original.writeData(out);
        byte[] bytes = out.toByteArray();
        sleepMillis(CLOCK_DIFFERENCE_MS);
        RingbufferContainer clone = new RingbufferContainer(original.name);
        in = serializationService.createObjectDataInput(bytes);
        clone.readData(in);
        return clone;
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        closeResource(out);
        closeResource(in);
    }
}

Output:
         sleepMillis(CLOCK_DIFFERENCE_MS);
-        RingbufferContainer clone = new RingbufferContainer(original.name);
+        RingbufferContainer clone = new RingbufferContainer(original.getName());
         in = serializationService.createObjectDataInput(bytes);


Input:
public ChatRoom createChatRoom(String roomName, Map<String, Object> roomProperties) throws OperationFailedException, OperationNotSupportedException {
    assertSupportedAndConnected();
    ChatRoom room = null;
    if (roomName == null)
        roomName = "String_Node_Str" + StringUtils.randomString(4);
    else
        room = findRoom(roomName);
    if (room == null) {
        if (logger.isInfoEnabled())
            logger.info("String_Node_Str");
        if (getXmppConnection().getHost().toLowerCase().contains("String_Node_Str")) {
            roomName = "String_Node_Str" + UUID.randomUUID().toString() + "String_Node_Str";
        }
        MultiUserChat muc = null;
        try {
            muc = new MultiUserChat(getXmppConnection(), getCanonicalRoomName(roomName));
            muc.create(StringUtils.parseName(getXmppConnection().getUser()));
        } catch (XMPPException ex) {
            logger.error("String_Node_Str", ex);
            throw new OperationFailedException("String_Node_Str", ex.getXMPPError().getCode(), ex.getCause());
        }
        boolean isPrivate = false;
        if (roomProperties != null) {
            Object isPrivateObject = roomProperties.get("String_Node_Str");
            if (isPrivateObject != null) {
                isPrivate = isPrivateObject.equals(true);
            }
        }
        try {
            Form form;
            if (isPrivate) {
                Form initForm = muc.getConfigurationForm();
                form = initForm.createAnswerForm();
                Iterator<FormField> fieldIterator = initForm.getFields();
                while (fieldIterator.hasNext()) {
                    FormField initField = fieldIterator.next();
                    if (initField == null || initField.getVariable() == null || initField.getType() == FormField.TYPE_FIXED || initField.getType() == FormField.TYPE_HIDDEN)
                        continue;
                    FormField submitField = form.getField(initField.getVariable());
                    if (submitField == null)
                        continue;
                    Iterator<String> value = initField.getValues();
                    while (value.hasNext()) submitField.addValue(value.next());
                }
                String[] fields = { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
                Boolean[] values = { true, true, false };
                for (int i = 0; i < fields.length; i++) {
                    FormField field = new FormField(fields[i]);
                    field.setType("String_Node_Str");
                    form.addField(field);
                    form.setAnswer(fields[i], values[i]);
                }
            } else {
                form = new Form(Form.TYPE_SUBMIT);
            }
            muc.sendConfigurationForm(form);
        } catch (XMPPException e) {
            logger.error("String_Node_Str", e);
        }
        room = createLocalChatRoomInstance(muc);
        room.setLocalUserRole(ChatRoomMemberRole.OWNER);
    }
    return room;
}

Output:
             muc = new MultiUserChat(getXmppConnection(), getCanonicalRoomName(roomName));
-            muc.create(StringUtils.parseName(getXmppConnection().getUser()));
+            muc.create(JabberActivator.getGlobalDisplayDetailsService().getDisplayName(jabberProvider));
         } catch (XMPPException ex) {


Input:
void setHyperlink(HyperlinkDef link) {
    if (link != null) {
        String hyperlink = link.getLink();
        if (hyperlink != null) {
            if (hyperlink.startsWith("String_Node_Str") && hyperlink.endsWith("String_Node_Str")) {
                hyperlink = hyperlink.substring(1, hyperlink.length() - 1);
            }
            writer.openTag("String_Node_Str");
            writer.attribute("String_Node_Str", part.getHyperlinkId(hyperlink));
            if (link.getTooltip() != null) {
                writer.attribute("String_Node_Str", link.getTooltip());
            }
            writer.closeTag("String_Node_Str");
        }
    }
}

Output:
     if (link != null) {
-        String hyperlink = link.getLink();
+        String hyperlink = null;
+        try {
+            hyperlink = URLEncoder.encode(link.getLink(), "String_Node_Str");
+        } catch (UnsupportedEncodingException ue) {
+            logger.log(Level.SEVERE, ue.getLocalizedMessage(), ue);
+        }
         if (hyperlink != null) {


Input:
public static void beforeClass() throws Exception {
    HBaseTestingUtility hBaseTestingUtility = new HBaseTestingUtility();
    hBaseTestingUtility.startMiniDFSCluster(1);
    Configuration hConf = hBaseTestingUtility.getConfiguration();
    hConf.setBoolean("String_Node_Str", true);
    zkServer = InMemoryZKServer.builder().build();
    zkServer.startAndWait();
    cConf = CConfiguration.create();
    cConf.set(Constants.CFG_HDFS_USER, System.getProperty("String_Node_Str"));
    cConf.set(Constants.Zookeeper.QUORUM, zkServer.getConnectionStr());
    cConf.set(Constants.CFG_LOCAL_DATA_DIR, tmpFolder.newFolder().getAbsolutePath());
    cConf.setBoolean(TxConstants.Manager.CFG_DO_PERSIST, true);
    server = TransactionServiceTest.createTxService(zkServer.getConnectionStr(), Networks.getRandomPort(), hConf, tmpFolder.newFolder());
    server.startAndWait();
    injector = Guice.createInjector(new ConfigModule(cConf, hConf), new ZKClientModule(), new LocationRuntimeModule().getInMemoryModules(), new DiscoveryRuntimeModule().getDistributedModules(), new TransactionMetricsModule(), new DataFabricModules().getDistributedModules(), new DataSetsModules().getDistributedModules(false));
    zkClient = injector.getInstance(ZKClientService.class);
    zkClient.startAndWait();
    txStateStorage = injector.getInstance(TransactionStateStorage.class);
    txStateStorage.startAndWait();
}

Output:
     server.startAndWait();
-    injector = Guice.createInjector(new ConfigModule(cConf, hConf), new ZKClientModule(), new LocationRuntimeModule().getInMemoryModules(), new DiscoveryRuntimeModule().getDistributedModules(), new TransactionMetricsModule(), new DataFabricModules().getDistributedModules(), new DataSetsModules().getDistributedModules(false));
+    injector = Guice.createInjector(new ConfigModule(cConf, hConf), new ZKClientModule(), new LocationRuntimeModule().getInMemoryModules(), new DiscoveryRuntimeModule().getDistributedModules(), new TransactionMetricsModule(), new DataFabricModules().getDistributedModules(), new DataSetsModules().getDistributedModules());
     zkClient = injector.getInstance(ZKClientService.class);


Input:
protected void endPrefixMappings(Element elem) throws SAXException {
    NamespaceResolver tmpresolver = getTempResolver(elem);
    if (tmpresolver != null) {
        Enumeration<String> prefixes = tmpresolver.getPrefixes();
        while (prefixes.hasMoreElements()) {
            getContentHandler().endPrefixMapping(prefixes.nextElement());
        }
    }
}

Output:
     if (tmpresolver != null) {
-        Enumeration<String> prefixes = tmpresolver.getPrefixes();
-        while (prefixes.hasMoreElements()) {
-            getContentHandler().endPrefixMapping(prefixes.nextElement());
+        ContentHandler contentHandler = getContentHandler();
+        String defaultNamespace = tmpresolver.getDefaultNamespaceURI();
+        if (null != defaultNamespace) {
+            contentHandler.endPrefixMapping(Constants.EMPTY_STRING);
+        }
+        if (tmpresolver.hasPrefixesToNamespaces()) {
+            for (Entry<String, String> entry : tmpresolver.getPrefixesToNamespaces().entrySet()) {
+                contentHandler.endPrefixMapping(entry.getKey());
+            }
         }


Input:
private String createColumnSelect() {
    StringBuffer query = new StringBuffer("String_Node_Str");
    String sep = "String_Node_Str";
    String table = "String_Node_Str";
    for (int i = 0; i < _selectedNodes.length; i++) {
        INode node = _selectedNodes[i];
        if (node instanceof ColumnNode) {
            ColumnNode column = (ColumnNode) node;
            if (table.length() == 0) {
                table = column.getQualifiedParentTableName();
            }
            if (column.getQualifiedParentTableName().equals(table)) {
                query.append(sep);
                query.append(column.getName());
                sep = "String_Node_Str";
            }
        }
    }
    query.append("String_Node_Str");
    query.append(table);
    return query.toString();
}

Output:
                 query.append(sep);
-                query.append(column.getName());
+                query.append(quote(column.getName(), getQuoteString(column)));
                 sep = "String_Node_Str";


Input:
public void execute(CommandSender sender, List<String> args) {
    if (!hasPermission(sender) || !correctLength(sender, args.size(), 1, 2) || !isPlayer(sender)) {
        return;
    }
    CoreAbility coreAbil = CoreAbility.getAbility(args.get(0));
    if (coreAbil == null || coreAbil.isHiddenAbility() || !coreAbil.isEnabled()) {
        sender.sendMessage(ChatColor.RED + abilityDoesntExist.replace("String_Node_Str", args.get(0)));
        return;
    }
    if (args.size() == 1) {
        bind(sender, args.get(0), ((Player) sender).getInventory().getHeldItemSlot() + 1);
    }
    if (args.size() == 2) {
        bind(sender, args.get(0), Integer.parseInt(args.get(1)));
    }
}

Output:
     if (args.size() == 2) {
-        bind(sender, args.get(0), Integer.parseInt(args.get(1)));
+        try {
+            bind(sender, args.get(0), Integer.parseInt(args.get(1)));
+        } catch (NumberFormatException ex) {
+            sender.sendMessage(ChatColor.RED + wrongNumber);
+        }
     }


Input:
private Control createParameterPageControl(Composite parent) {
    viewer = new PropertyHandleTableViewer(parent, true, true, true);
    TableColumn column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
    column.setText("String_Node_Str");
    column.setResizable(false);
    column.setWidth(23);
    DataSetHandle dataSetHandle = (DataSetHandle) getContainer().getModel();
    isOdaDataSetHandle = ParameterPageUtil.isOdaDataSetHandle(dataSetHandle);
    isJointOrDerivedDataSetHandle = ParameterPageUtil.isJointOrDerivedDataSetHandle(dataSetHandle);
    if (isOdaDataSetHandle) {
        String[] cellLabels = ParameterPageUtil.odaCellLabels;
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[0]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[1]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[2]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[3]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[4]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[5]);
        column.setWidth(180);
    } else {
        String[] cellLabels = ParameterPageUtil.cellLabels;
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[0]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[1]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[2]);
        column.setWidth(100);
        column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
        column.setText(cellLabels[3]);
        column.setWidth(100);
        if (isJointOrDerivedDataSetHandle) {
            column = new TableColumn(viewer.getViewer().getTable(), SWT.LEFT);
            column.setText(ParameterPageUtil.odaCellLabels[5]);
            column.setWidth(180);
        }
    }
    viewer.getViewer().setContentProvider(new ParameterViewContentProvider());
    viewer.getViewer().setLabelProvider(new ParameterViewLableProvider(dataSetHandle));
    adjustParameterOnPosition(parameters);
    if (ParameterPageUtil.isJointDataSetHandle(dataSetHandle)) {
        viewer.getViewer().setInput((JointDataSetHandle) dataSetHandle);
    } else {
        viewer.getViewer().setInput(parameters);
    }
    setToolTips();
    if (!isJointOrDerivedDataSetHandle) {
        addRefreshMenu();
        addListeners();
        dataSetHandle.addListener(this);
    }
    return viewer.getControl();
}

Output:
     adjustParameterOnPosition(parameters);
-    if (ParameterPageUtil.isJointDataSetHandle(dataSetHandle)) {
-        viewer.getViewer().setInput((JointDataSetHandle) dataSetHandle);
+    if (ParameterPageUtil.isJointOrDerivedDataSetHandle(dataSetHandle)) {
+        viewer.getViewer().setInput(dataSetHandle);
     } else {


Input:
private void findConnectedBlocks(HashMap<Coordinate, BlockInfo> connectedBlocks, World world, int x, int y, int z, boolean first) {
    if (y < 0 || y >= world.getActualHeight()) {
        return;
    }
    Coordinate c = new Coordinate(x, y, z);
    if (connectedBlocks.containsKey(c)) {
        return;
    }
    TileEntity tileEntity = world.getTileEntity(x, y, z);
    if (tileEntity != null) {
        Block block = world.getBlock(x, y, z);
        connectedBlocks.put(c, new BlockInfo(tileEntity, block, first));
        findConnectedBlocks(connectedBlocks, world, x + 1, y, z, false);
        findConnectedBlocks(connectedBlocks, world, x - 1, y, z, false);
        findConnectedBlocks(connectedBlocks, world, x, y - 1, z, false);
        findConnectedBlocks(connectedBlocks, world, x, y + 1, z, false);
        findConnectedBlocks(connectedBlocks, world, x, y, z - 1, false);
        findConnectedBlocks(connectedBlocks, world, x, y, z + 1, false);
    }
}

Output:
     if (tileEntity != null) {
-        Block block = world.getBlock(x, y, z);
-        connectedBlocks.put(c, new BlockInfo(tileEntity, block, first));
-        findConnectedBlocks(connectedBlocks, world, x + 1, y, z, false);
-        findConnectedBlocks(connectedBlocks, world, x - 1, y, z, false);
-        findConnectedBlocks(connectedBlocks, world, x, y - 1, z, false);
-        findConnectedBlocks(connectedBlocks, world, x, y + 1, z, false);
-        findConnectedBlocks(connectedBlocks, world, x, y, z - 1, false);
-        findConnectedBlocks(connectedBlocks, world, x, y, z + 1, false);
+        if (tileEntity instanceof IEnergyHandler) {
+            Block block = world.getBlock(x, y, z);
+            connectedBlocks.put(c, new BlockInfo(tileEntity, block, first));
+            findConnectedBlocks(connectedBlocks, world, x + 1, y, z, false);
+            findConnectedBlocks(connectedBlocks, world, x - 1, y, z, false);
+            findConnectedBlocks(connectedBlocks, world, x, y - 1, z, false);
+            findConnectedBlocks(connectedBlocks, world, x, y + 1, z, false);
+            findConnectedBlocks(connectedBlocks, world, x, y, z - 1, false);
+            findConnectedBlocks(connectedBlocks, world, x, y, z + 1, false);
+        }
     }


Input:
private Topic parseLink(JSONObject l, HashMap<String, Topic> thingTypes, TopicMap tm) throws JSONException, TopicMapException {
    if (forceStop()) {
        return null;
    }
    final JSONObject link = l;
    JSONObject linkData = link.getJSONObject("String_Node_Str");
    String kind = link.getString("String_Node_Str");
    String id = linkData.getString("String_Node_Str");
    String title = linkData.getString("String_Node_Str");
    log("String_Node_Str" + title);
    Topic linkTopic = getOrCreateTopic(tm, SI_ROOT + id);
    linkTopic.setDisplayName("String_Node_Str", title);
    linkTopic.setBaseName(title + "String_Node_Str" + id + "String_Node_Str");
    if (!linkData.getBoolean("String_Node_Str")) {
        String linkUrl = linkData.getString("String_Node_Str");
        Topic destinationTopic = getOrCreateTopic(tm, linkUrl);
        destinationTopic.setSubjectLocator(new Locator(linkUrl));
        HashMap<String, Topic> assTypes = getAssociationTypes(tm);
        Association a = tm.createAssociation(assTypes.get("String_Node_Str"));
        a.addPlayer(linkTopic, thingTypes.get(THING_TYPE_LINK));
        a.addPlayer(destinationTopic, assTypes.get("String_Node_Str"));
    }
    linkTopic.addType(thingTypes.get(kind));
    addLinkOccurenceData(tm, linkData, linkTopic);
    if (linkData.has("String_Node_Str")) {
        final String author = linkData.getString("String_Node_Str");
        if (!extracted.contains(author) && CRAWL_SETTINGS.get("String_Node_Str")) {
            String authorUrl = apiRoot + "String_Node_Str" + author + "String_Node_Str";
            ParseCallback<JsonNode> callback = new ParseCallback<JsonNode>(tm, thingTypes) {
                public void run(HttpResponse<JsonNode> response) {
                    try {
                        JSONObject respObject = response.getBody().getObject();
                        Topic account = null;
                        if (respObject.has("String_Node_Str") && respObject.getString("String_Node_Str").equals("String_Node_Str")) {
                            extracted.add(author);
                            account = parseAccount(respObject, thingTypes, tm);
                        }
                        if (account != null) {
                            associateAccount(tm, link, account, thingTypes);
                        }
                    } catch (JSONException | TopicMapException e) {
                        log(e.getMessage());
                    }
                }
            };
            requester.doRequest(Unirest.get(authorUrl), callback);
        }
    }
    if (linkData.has("String_Node_Str")) {
        String subredditId = linkData.getString("String_Node_Str");
        Topic subredditTopic = tm.getTopic(SI_ROOT + subredditId);
        associateSubreddit(tm, link, subredditTopic, thingTypes);
        final String subreddit = linkData.getString("String_Node_Str");
        if (!extracted.contains(subreddit) && CRAWL_SETTINGS.get("String_Node_Str")) {
            String subredditUrl = apiRoot + "String_Node_Str" + subreddit + "String_Node_Str";
            ParseCallback<JsonNode> callback = new ParseCallback<JsonNode>(tm, thingTypes) {

                public void run(HttpResponse<JsonNode> response) {
                    try {
                        JSONObject respObject = response.getBody().getObject();
                        Topic subredditTopic = null;
                        if (respObject.has("String_Node_Str") && respObject.getString("String_Node_Str").equals("String_Node_Str")) {
                            extracted.add(subreddit);
                            subredditTopic = parseSubreddit(respObject, thingTypes, tm);
                        }
                        if (subredditTopic != null) {
                            associateSubreddit(tm, link, subredditTopic, thingTypes);
                        }
                    } catch (JSONException | TopicMapException e) {
                        log(e.getMessage());
                    }
                }
            };
            requester.doRequest(Unirest.get(subredditUrl), callback);
        }
    }
    if (CRAWL_SETTINGS.get("String_Node_Str")) {
        String commentUrl = apiRoot + "String_Node_Str" + linkData.getString("String_Node_Str");
        ParseCallback<JsonNode> callback = new ParseCallback<JsonNode>(tm, thingTypes) {
            public void run(HttpResponse<JsonNode> response) {
                try {
                    JSONArray respArray = response.getBody().getArray();
                    parseThing(respArray.getJSONObject(1), tm, thingTypes);
                } catch (Exception e) {
                }
            }
        };
        requester.doRequest(Unirest.get(commentUrl), callback);
    }
    return linkTopic;
}

Output:
     }
-    if (linkData.has("String_Node_Str")) {
-        String subredditId = linkData.getString("String_Node_Str");
-        Topic subredditTopic = tm.getTopic(SI_ROOT + subredditId);
-        associateSubreddit(tm, link, subredditTopic, thingTypes);
-        final String subreddit = linkData.getString("String_Node_Str");
-        if (!extracted.contains(subreddit) && CRAWL_SETTINGS.get("String_Node_Str")) {
-            String subredditUrl = apiRoot + "String_Node_Str" + subreddit + "String_Node_Str";
-            ParseCallback<JsonNode> callback = new ParseCallback<JsonNode>(tm, thingTypes) {
+    try {
+        if (linkData.has("String_Node_Str")) {
+            String subredditId = linkData.getString("String_Node_Str");
+            String subredditName = linkData.getString("String_Node_Str");
+            Topic subredditTopic = getOrCreateTopic(tm, SI_ROOT + subredditId);
+            associateSubreddit(tm, link, subredditTopic, thingTypes);
+            final String subreddit = linkData.getString("String_Node_Str");
+            if (!extracted.contains(subreddit) && CRAWL_SETTINGS.get("String_Node_Str")) {
+                String subredditUrl = apiRoot + "String_Node_Str" + subreddit + "String_Node_Str";
+                ParseCallback<JsonNode> callback = new ParseCallback<JsonNode>(tm, thingTypes) {


Input:
public static void writeFileByChars(String fileName, String value) {
    String path = fileName;
    ByteBuffer bb = ByteBuffer.wrap(value.getBytes());
    value = null;
    FileChannel out2;
    try {
        out2 = new FileOutputStream(path).getChannel();
        out2.write(bb);
        bb.clear();
        bb = null;
        out2.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        out2 = new FileOutputStream(path).getChannel();
+        FileOutputStream fos = new FileOutputStream(path);
+        out2 = fos.getChannel();
         out2.write(bb);


Input:
public static org.hl7.fhir.dstu2016may.model.Signature convertSignature(org.hl7.fhir.dstu3.model.Signature src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.Signature tgt = new org.hl7.fhir.dstu2016may.model.Signature();
    copyElement(src, tgt);
    for (org.hl7.fhir.dstu3.model.Coding t : src.getType()) tgt.addType(convertCoding(t));
    tgt.setWhen(src.getWhen());
    tgt.setWho(convertType(src.getWho()));
    tgt.setContentType(src.getContentType());
    tgt.setBlob(src.getBlob());
    return tgt;
}

Output:
 public static org.hl7.fhir.dstu2016may.model.Signature convertSignature(org.hl7.fhir.dstu3.model.Signature src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
private void logProcessed() {
    String[] flowlets = { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    for (String flowlet : flowlets) LOG.info("String_Node_Str" + flowlet + "String_Node_Str" + BenchmarkRuntimeStats.getFlowletMetrics(appName, flowName, flowlet).getProcessed());
}

Output:
     String[] flowlets = { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
-    for (String flowlet : flowlets) LOG.info("String_Node_Str" + flowlet + "String_Node_Str" + BenchmarkRuntimeStats.getFlowletMetrics(appName, flowName, flowlet).getProcessed());
+    for (String flowlet : flowlets) {
+        LOG.info("String_Node_Str" + flowlet + "String_Node_Str" + BenchmarkRuntimeStats.getFlowletMetrics(appName, flowName, flowlet).getProcessed());
+    }
 }


Input:
public void onNeighborBlockChange(World world, BlockPos pos, IBlockState state, Block neighborBlock) {
    super.onNeighborBlockChange(world, pos, state, neighborBlock);
    TileEntity tileEntity = world.getTileEntity(pos);
    if (tileEntity instanceof TileAlveary) {
        TileAlveary tileAlveary = (TileAlveary) tileEntity;
        tileAlveary.getMultiblockLogic().getController().reassemble();
    }
}

Output:
         TileAlveary tileAlveary = (TileAlveary) tileEntity;
-        tileAlveary.getMultiblockLogic().getController().reassemble();
+        IAlvearyControllerInternal alvery = tileAlveary.getMultiblockLogic().getController();
+        alvery.reassemble();
+        Proxies.net.sendNetworkPacket(new PacketAlveryChange(alvery), world);
     }


Input:
public void dumpData(Plugin plugin, CommandSender sender, Map<String, String> args) {
    if (!(plugin instanceof PermissionsEx)) {
        return;
    }
    try {
        PermissionBackend backend = PermissionBackend.getBackend(args.get("String_Node_Str"), PermissionsEx.getPermissionManager(), ((PermissionsEx) plugin).getConfigurationNode(), null);
        File dstFile = new File("String_Node_Str", args.get("String_Node_Str"));
        FileOutputStream outStream = new FileOutputStream(dstFile);
        backend.dumpData(new OutputStreamWriter(outStream, "String_Node_Str"));
        outStream.close();
        sender.sendMessage(ChatColor.WHITE + "String_Node_Str" + dstFile.getName() + "String_Node_Str");
    } catch (RuntimeException e) {
        if (e.getCause() instanceof ClassNotFoundException) {
            sender.sendMessage(ChatColor.RED + "String_Node_Str");
        } else {
            sender.sendMessage(ChatColor.RED + "String_Node_Str" + e.getMessage());
            logger.severe("String_Node_Str" + e.getCause().getClass().getName() + "String_Node_Str" + e.getMessage());
        }
    } catch (IOException e) {
        sender.sendMessage(ChatColor.RED + "String_Node_Str" + e.getMessage());
    }
}

Output:
             sender.sendMessage(ChatColor.RED + "String_Node_Str" + e.getMessage());
-            logger.severe("String_Node_Str" + e.getCause().getClass().getName() + "String_Node_Str" + e.getMessage());
+            logger.severe("String_Node_Str" + e.getMessage());
         }


Input:
protected void createResultSection(Composite parent) {
    resultSection = createSection(form, parent, DefaultMessagesImpl.getString("String_Node_Str"), true, "String_Node_Str");
    Composite sectionClient = toolkit.createComposite(resultSection);
    sectionClient.setLayout(new GridLayout(2, false));
    sectionClient.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    resultSection.setClient(sectionClient);
    Analysis analysis = this.masterPage.getAnalysisHandler().getAnalysis();
    EList<Indicator> indicators = analysis.getResults().getIndicators();
    if (indicators.size() > 0) {
        columnDependencyIndicator = (ColumnDependencyIndicator) indicators.get(0);
    }
    createTable(sectionClient);
    creatChart(sectionClient, analysis);
    resultSection.layout();
}

Output:
     createTable(sectionClient);
-    creatChart(sectionClient, analysis);
+    createChart(sectionClient, analysis);
     resultSection.layout();


Input:
public void placeBet(Bet bet) {
    PlaceBetsReq placeBetsReq = new PlaceBetsReq();
    placeBetsReq.setBets(new ArrayOfPlaceBets());
    Strategy strategy = bet.getStrategy();
    BigDecimal liability = strategy.getLiability().divide(new BigDecimal(bet.getTimings().size()));
    Pricing bestPricing = BettingUtil.bestPrice(bet.getHorse().getPrices(), strategy.getAspect());
    if (bestPricing.getPrice().compareTo(strategy.getMaxOdds()) <= 0 && bestPricing.getPrice().compareTo(strategy.getMinOdds()) >= 0) {
        if (strategy.getChasePriceByTick() == 0) {
            if (bestPricing.getAmountAvailable().compareTo(liability) >= 0) {
                placeBetsReq.getBets().getPlaceBets().add(createMOCExchangeBet(bet, liability, bestPricing.getPrice()));
            } else {
                placeBetsReq.getBets().getPlaceBets().add(createMOCExchangeBet(bet, bestPricing.getAmountAvailable(), bestPricing.getPrice()));
                placeBetsReq.getBets().getPlaceBets().add(createLimitedSPBet(bet, liability.subtract(bestPricing.getAmountAvailable())));
            }
        } else {
            placeBetsReq.getBets().getPlaceBets().add(createMOCExchangeBet(bet, liability, BettingUtil.findChasePrice(bestPricing.getPrice(), strategy.getChasePriceByTick(), strategy.getAspect())));
        }
    } else {
        placeBetsReq.getBets().getPlaceBets().add(createLimitedSPBet(bet, liability));
    }
    sendRequest(placeBetsReq);
}

Output:
     Strategy strategy = bet.getStrategy();
-    BigDecimal liability = strategy.getLiability().divide(new BigDecimal(bet.getTimings().size()));
+    BigDecimal liability = strategy.getLiability().divide(new BigDecimal(bet.getNumberOfSplits()), BigDecimal.ROUND_HALF_UP);
     Pricing bestPricing = BettingUtil.bestPrice(bet.getHorse().getPrices(), strategy.getAspect());


Input:
public void show(Entity entity) {
    PacketPlayOutSpawnMob packet = new PacketPlayOutSpawnMob();
    packet.set("String_Node_Str", entity.entityId()).set("String_Node_Str", entity).set("String_Node_Str", ((TridentEntity) entity).protocolMeta);
    if (this instanceof Player) {
        ((TridentPlayer) this).connection().sendPacket(packet);
    }
}

Output:
     PacketPlayOutSpawnMob packet = new PacketPlayOutSpawnMob();
-    packet.set("String_Node_Str", entity.entityId()).set("String_Node_Str", entity).set("String_Node_Str", ((TridentEntity) entity).protocolMeta);
+    ProtocolMetadata protocolMeta = new ProtocolMetadata();
+    ((TridentEntity) entity).encodeMetadata(protocolMeta);
+    packet.set("String_Node_Str", entity.entityId()).set("String_Node_Str", entity).set("String_Node_Str", protocolMeta);
     if (this instanceof Player) {


Input:
public void onMatch(RelOptRuleCall call) {
    final CascadingTableAccessRel tableRel = (CascadingTableAccessRel) call.getRels()[0];
    final TapEnumerableRel tapRel = new TapEnumerableRel(tableRel.getCluster(), tableRel.getTraitSet().plus(EnumerableConvention.ARRAY), tableRel.getTable(), tableRel.name, tableRel.identifier);
    call.transformTo(tapRel);
}

Output:
     final CascadingTableAccessRel tableRel = (CascadingTableAccessRel) call.getRels()[0];
-    final TapEnumerableRel tapRel = new TapEnumerableRel(tableRel.getCluster(), tableRel.getTraitSet().plus(EnumerableConvention.ARRAY), tableRel.getTable(), tableRel.name, tableRel.identifier);
+    final EnumerableTapRel tapRel = new EnumerableTapRel(tableRel.getCluster(), tableRel.getTraitSet().plus(EnumerableConvention.ARRAY), tableRel.getTable());
     call.transformTo(tapRel);


Input:
public String getDownloadableThumbnailUrl(String contentUrl, int width, int height, String method) {
    if (contentUrl == null)
        return null;
    if (contentUrl.startsWith(MATRIX_CONTENT_URI_SCHEME)) {
        String mediaServerAndId = contentUrl.substring(MATRIX_CONTENT_URI_SCHEME.length());
        if (mediaServerAndId.endsWith("String_Node_Str")) {
            mediaServerAndId = mediaServerAndId.substring(0, mediaServerAndId.length() - "String_Node_Str".length());
        }
        String url = mHsConfig.getHomeserverUri().toString() + URI_PREFIX_CONTENT_API;
        if (mediaServerAndId.indexOf("String_Node_Str") < 0) {
            url += "String_Node_Str";
        }
        url += mediaServerAndId;
        url += "String_Node_Str" + width;
        url += "String_Node_Str" + height;
        url += "String_Node_Str" + method;
        return url;
    } else {
        return contentUrl;
    }
}

Output:
 public String getDownloadableThumbnailUrl(String contentUrl, int width, int height, String method) {
-    if (contentUrl == null)
-        return null;
-    if (contentUrl.startsWith(MATRIX_CONTENT_URI_SCHEME)) {
+    if (isValidMatrixContentUrl(contentUrl)) {
         String mediaServerAndId = contentUrl.substring(MATRIX_CONTENT_URI_SCHEME.length());


Input:
public static Equivalence make(Term subject, Term predicate, int temporalOrder) {
    if (subject == null || predicate == null || invalidStatement(subject, predicate)) {
        return null;
    }
    if ((subject instanceof Implication) || (subject instanceof Equivalence) || (predicate instanceof Implication) || (predicate instanceof Equivalence)) {
        return null;
    }
    if (subject.equals(predicate))
        return null;
    if ((temporalOrder == TemporalRules.ORDER_BACKWARD) || ((subject.compareTo(predicate) > 0) && (temporalOrder != TemporalRules.ORDER_FORWARD))) {
        Term interm = subject;
        subject = predicate;
        predicate = interm;
    }
    NativeOperator copula;
    switch(temporalOrder) {
        case TemporalRules.ORDER_BACKWARD:
            temporalOrder = TemporalRules.ORDER_FORWARD;
        case TemporalRules.ORDER_FORWARD:
            copula = NativeOperator.EQUIVALENCE_AFTER;
            break;
        case TemporalRules.ORDER_CONCURRENT:
            copula = NativeOperator.EQUIVALENCE_WHEN;
            break;
        default:
            copula = NativeOperator.EQUIVALENCE;
    }
    Term[] t = Term.toSortedSetArray(subject, predicate);
    if (t.length != 2)
        return null;
    return new Equivalence(t, temporalOrder);
}

Output:
 public static Equivalence make(Term subject, Term predicate, int temporalOrder) {
-    if (subject == null || predicate == null || invalidStatement(subject, predicate)) {
+    if (invalidStatement(subject, predicate)) {
         return null;


Input:
public List<IGroovyProposal> getStatementAndExpressionProposals(ContentAssistContext context, ClassNode completionType, boolean isStatic, Set<ClassNode> categories) {
    String event = null;
    if (GroovyLogManager.manager.hasLoggers()) {
        GroovyLogManager.manager.log(TraceCategory.DSL, "String_Node_Str" + context.fullCompletionExpression);
        event = "String_Node_Str";
        GroovyLogManager.manager.logStart(event);
    }
    List<IContributionElement> contributions;
    List<IGroovyProposal> proposals = new ArrayList<IGroovyProposal>();
    try {
        DSLDStore store = GroovyDSLCoreActivator.getDefault().getContextStoreManager().getDSLDStore(context.unit.getJavaProject());
        ModuleNodeInfo info = context.unit.getModuleInfo(true);
        if (info == null) {
            if (GroovyLogManager.manager.hasLoggers()) {
                GroovyLogManager.manager.log(TraceCategory.CONTENT_ASSIST, "String_Node_Str" + context.unit.getElementName());
            }
            return Collections.EMPTY_LIST;
        }
        GroovyDSLDContext pattern = new GroovyDSLDContext(context.unit, info.module, info.resolver);
        pattern.setCurrentScope(context.currentScope);
        pattern.setTargetType(completionType);
        pattern.setStatic(isStatic);
        pattern.setPrimaryNode(context.location == ContentAssistLocation.STATEMENT || (context.location == ContentAssistLocation.METHOD_CONTEXT && context.currentScope.isPrimaryNode()));
        contributions = store.findContributions(pattern, DSLPreferences.getDisabledScriptsAsSet());
        boolean isMethodContext = context instanceof MethodInfoContentAssistContext;
        for (IContributionElement element : contributions) {
            if (element.contributionName().startsWith(context.getPerceivedCompletionExpression())) {
                IGroovyProposal proposal = element.toProposal(completionType, pattern.getResolverCache());
                if (proposal != null) {
                    proposals.add(proposal);
                }
                if (isMethodContext) {
                    proposals.addAll(element.extraProposals(completionType, pattern.getResolverCache(), (Expression) ((MethodInfoContentAssistContext) context).completionNode));
                }
            }
        }
    } catch (CoreException e) {
        GroovyDSLCoreActivator.logException(e);
    }
    if (event != null) {
        GroovyLogManager.manager.logEnd(event, TraceCategory.DSL);
    }
    return proposals;
}

Output:
         contributions = store.findContributions(pattern, DSLPreferences.getDisabledScriptsAsSet());
-        boolean isMethodContext = context instanceof MethodInfoContentAssistContext;
+        boolean isMethodContext = (context instanceof MethodInfoContentAssistContext);
         for (IContributionElement element : contributions) {


Input:
public Network import_(ReadOnlyDataSource dataSource, Properties parameters) {
    Objects.requireNonNull(dataSource);
    Network network;
    long startTime = System.currentTimeMillis();
    try {
        String ext = findExtension(dataSource);
        if (ext == null) {
            throw new RuntimeException("String_Node_Str" + dataSource.getBaseName() + "String_Node_Str" + Joiner.on("String_Node_Str").join(EXTENSIONS) + "String_Node_Str");
        }
        boolean throwExceptionIfExtensionNotFound = (Boolean) Importers.readParameter(getFormat(), parameters, THROW_EXCEPTION_IF_EXTENSION_NOT_FOUND, defaultValueConfig);
        Anonymizer anonymizer = null;
        if (dataSource.exists("String_Node_Str", "String_Node_Str")) {
            anonymizer = new SimpleAnonymizer();
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(dataSource.newInputStream("String_Node_Str", "String_Node_Str")))) {
                anonymizer.read(reader);
            }
        }
        try (InputStream is = dataSource.newInputStream(null, ext)) {
            network = NetworkXml.read(is, new XmlImportConfig(throwExceptionIfExtensionNotFound), anonymizer);
        }
        LOGGER.debug("String_Node_Str", (System.currentTimeMillis() - startTime));
    } catch (IOException e) {
        throw new ITeslaException(e);
    }
    return network;
}

Output:
             anonymizer = new SimpleAnonymizer();
-            try (BufferedReader reader = new BufferedReader(new InputStreamReader(dataSource.newInputStream("String_Node_Str", "String_Node_Str")))) {
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(dataSource.newInputStream("String_Node_Str", "String_Node_Str"), StandardCharsets.UTF_8))) {
                 anonymizer.read(reader);


Input:
public TaskRead updateWithReturn(Object entity, final String path, final HttpMethod verb, PrettyOutput... prettyOutput) {
    checkConnection();
    try {
        if (verb == HttpMethod.PUT) {
            ResponseEntity<String> response = restUpdate(path, entity);
            if (!validateAuthorization(response)) {
                return null;
            }
            return processResponse(response, HttpMethod.PUT, prettyOutput);
        } else {
            throw new Exception(Constants.HTTP_VERB_ERROR);
        }
    } catch (Exception e) {
        throw new CliRestException(getExceptionMessage(e));
    }
}

Output:
     } catch (Exception e) {
-        throw new CliRestException(getExceptionMessage(e));
+        throw new CliRestException(CommandsUtils.getExceptionMessage(e));
     }


Input:
private void registerGraphicalViewer(GraphicalViewer viewer, IWorkbenchPartReference partRef) {
    IWorkbenchPart part = partRef.getPart(false);
    if (part != null && partRef instanceof WorkbenchPartReference) {
        if (viewer != null) {
            Control partContent = ((WorkbenchPartReference) partRef).getPane().getControl();
            if (partContent != null && !partContent.isDisposed()) {
                partContent.setData(Startup.GD_GEF_VIEWER_DATA_KEY, viewer);
            }
        }
    }
}

Output:
             if (partContent != null && !partContent.isDisposed()) {
-                partContent.setData(Startup.GD_GEF_VIEWER_DATA_KEY, viewer);
+                partContent.setData(Startup.TEST_GEF_VIEWER_DATA_KEY, viewer);
             }


Input:
public void onClick(DialogInterface dialog, int whichButton) {
    try {
        long newFreq = Long.valueOf(et_input.getText().toString());
        source.setFrequency(newFreq);
        analyzerSurface.setVirtualFrequency(newFreq);
    } catch (NumberFormatException e) {
        Log.e(LOGTAG, "String_Node_Str" + e.getMessage());
    }
}

Output:
         long newFreq = Long.valueOf(et_input.getText().toString());
-        source.setFrequency(newFreq);
-        analyzerSurface.setVirtualFrequency(newFreq);
+        if (newFreq <= source.getMaxFrequency() && newFreq >= source.getMinFrequency()) {
+            source.setFrequency(newFreq);
+            analyzerSurface.setVirtualFrequency(newFreq);
+        } else {
+            Toast.makeText(MainActivity.this, "String_Node_Str", Toast.LENGTH_LONG).show();
+        }
     } catch (NumberFormatException e) {


Input:
final void startRetransformClasses(int numClasses) {
    try {
        onCommand(new RetransformationStartNotification(numClasses));
        if (Main.isDebug())
            Main.debugPrint("String_Node_Str" + numClasses + "String_Node_Str");
    } catch (IOException e) {
        Main.debugPrint(e);
    }
}

Output:
 final void startRetransformClasses(int numClasses) {
-    try {
-        onCommand(new RetransformationStartNotification(numClasses));
-        if (Main.isDebug())
-            Main.debugPrint("String_Node_Str" + numClasses + "String_Node_Str");
-    } catch (IOException e) {
-        Main.debugPrint(e);
-    }
+    runtime.send(new RetransformationStartNotification(numClasses));
+    if (Main.isDebug())
+        Main.debugPrint("String_Node_Str" + numClasses + "String_Node_Str");
 }


Input:
public void testGetRankedStats() throws InterruptedException, TimeoutException, ExecutionException {
    try {
        handler.getRankedStats(SUMMONER_ID_1).get(1, MINUTES);
    } catch (RequestException ex) {
        if (ex.getErrorType().code < 500 || ex.getErrorType().code > 599)
            throw ex;
    }
}

Output:
     } catch (RequestException ex) {
-        if (ex.getErrorType().code < 500 || ex.getErrorType().code > 599)
+        if (isNotServerside(ex))
             throw ex;


Input:
public RestResponse<ConstraintInformation> updateRelationshipPropertyValue(String topologyId, String nodeTemplateName, String relationshipName, UpdateIndexedTypePropertyRequest updatePropertyRequest) {
    Topology topology = topologyServiceCore.getOrFail(topologyId);
    topologyService.checkEditionAuthorizations(topology);
    topologyService.throwsErrorIfReleased(topology);
    String propertyName = updatePropertyRequest.getPropertyName();
    String propertyValue = updatePropertyRequest.getPropertyValue();
    String relationshipType = updatePropertyRequest.getType();
    Map<String, IndexedRelationshipType> relationshipTypes = topologyServiceCore.getIndexedRelationshipTypesFromTopology(topology);
    if (!relationshipTypes.get(relationshipType).getProperties().containsKey(propertyName)) {
        throw new NotFoundException("String_Node_Str" + propertyName + "String_Node_Str" + nodeTemplateName + "String_Node_Str" + relationshipType + "String_Node_Str");
    }
    log.debug("String_Node_Str", propertyName, relationshipType, nodeTemplateName, topology.getId(), relationshipTypes.get(relationshipType).getProperties().get(propertyName), propertyValue);
    Map<String, NodeTemplate> nodeTemplates = topologyServiceCore.getNodeTemplates(topology);
    NodeTemplate nodeTemplate = topologyServiceCore.getNodeTemplate(topologyId, nodeTemplateName, nodeTemplates);
    Map<String, RelationshipTemplate> relationships = nodeTemplate.getRelationships();
    try {
        propertyService.setPropertyValue(relationships.get(relationshipName).getProperties(), relationshipTypes.get(relationshipType).getProperties().get(propertyName), propertyName, propertyValue);
    } catch (ConstraintValueDoNotMatchPropertyTypeException | ConstraintViolationException e) {
        return RestConstraintValidator.fromException(e, propertyName, propertyValue);
    }
    topologyServiceCore.save(topology);
    return RestResponseBuilder.<ConstraintInformation>builder().build();
}

Output:
     String propertyName = updatePropertyRequest.getPropertyName();
-    String propertyValue = updatePropertyRequest.getPropertyValue();
+    Object propertyValue = updatePropertyRequest.getPropertyValue();
     String relationshipType = updatePropertyRequest.getType();


Input:
public boolean onHoverEvent(MotionEvent event) {
    final int action = event.getActionMasked();
    if (!mSendingHoverAccessibilityEvents) {
        if ((action == MotionEvent.ACTION_HOVER_ENTER || action == MotionEvent.ACTION_HOVER_MOVE) && !hasHoveredChild() && pointInView(event.getX(), event.getY())) {
            sendAccessibilityHoverEvent(AccessibilityEvent.TYPE_VIEW_HOVER_ENTER);
            mSendingHoverAccessibilityEvents = true;
        }
    } else {
        if (action == MotionEvent.ACTION_HOVER_EXIT || (action == MotionEvent.ACTION_MOVE && !pointInView(event.getX(), event.getY()))) {
            mSendingHoverAccessibilityEvents = false;
            sendAccessibilityHoverEvent(AccessibilityEvent.TYPE_VIEW_HOVER_EXIT);
            if (mAttachInfo != null && !mAttachInfo.mHasWindowFocus) {
                getViewRootImpl().setAccessibilityFocus(null, null);
            }
        }
    }
    if (isHoverable()) {
        switch(action) {
            case MotionEvent.ACTION_HOVER_ENTER:
                setHovered(true);
                break;
            case MotionEvent.ACTION_HOVER_EXIT:
                setHovered(false);
                break;
        }
        dispatchGenericMotionEventInternal(event);
        return true;
    }
    return false;
}

Output:
         }
-        dispatchGenericMotionEventInternal(event);
-        return true;
+        return dispatchGenericMotionEventInternal(event);
     }


Input:
private String makeRepoRelative(Repository repository, IResource res) {
    return stripWorkDir(repository.getWorkTree(), res.getLocation().toFile());
}

Output:
 private String makeRepoRelative(Repository repository, IResource res) {
-    return stripWorkDir(repository.getWorkTree(), res.getLocation().toFile());
+    if (repository.isBare()) {
+        return null;
+    }
+    IPath location = res.getLocation();
+    if (location == null) {
+        return null;
+    }
+    return stripWorkDir(repository.getWorkTree(), location.toFile());
 }


Input:
public synchronized void setHeader(byte[] header) {
    if (header != null) {
        try {
            this.os.write(header, 0, header.length);
        } catch (IOException ioe) {
            logger.error("String_Node_Str", ioe);
        }
    }
}

Output:
         } catch (IOException ioe) {
-            logger.error("String_Node_Str", ioe);
+            LOGGER.error("String_Node_Str", ioe);
         }


Input:
public String toString() {
    throw new RuntimeException("String_Node_Str");
}

Output:
 public String toString() {
-    throw new RuntimeException("String_Node_Str");
+    return super.toStringBrief();
 }


Input:
public boolean dismissPopupKeyboard() {
    if (isPopupShowing()) {
        mMiniKeyboard.closing();
        mMiniKeyboardPopup.dismiss();
        mMiniKeyboardVisible = false;
        mMiniKeyboardOriginX = 0;
        mMiniKeyboardOriginY = 0;
        invalidateAllKeys();
        return true;
    } else
        return false;
}

Output:
 public boolean dismissPopupKeyboard() {
-    if (isPopupShowing()) {
-        mMiniKeyboard.closing();
+    if (mMiniKeyboardPopup.isShowing()) {
+        if (mMiniKeyboard != null)
+            mMiniKeyboard.closing();
         mMiniKeyboardPopup.dismiss();


Input:
public RenderPipelineTask generateTask() {
    if (enabled) {
        return new SetWireframeTask(GL_FILL);
    } else {
        return new SetWireframeTask(GL_LINE);
    }
}

Output:
     if (enabled) {
-        return new SetWireframeTask(GL_FILL);
+        return new SetWireframeTask(ENABLED);
     } else {


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    view = inflater.inflate(R.layout.fragment_account, container, false);
    app = (OpacClient) getActivity().getApplication();
    account = app.getAccount();
    if (getActivity().getIntent().getExtras() != null) {
        if (getActivity().getIntent().getExtras().containsKey("String_Node_Str")) {
            AccountDataSource adata = new AccountDataSource(getActivity());
            adata.open();
            Bundle notif = getActivity().getIntent().getExtras().getBundle("String_Node_Str");
            Set<String> keys = notif.keySet();
            for (String key : keys) {
                long[] val = notif.getLongArray(key);
                adata.notificationSave(val[0], val[1]);
            }
            adata.close();
            if (getActivity().getIntent().getExtras().getLong("String_Node_Str") != app.getAccount().getId()) {
                app.setAccount(getActivity().getIntent().getExtras().getLong("String_Node_Str"));
                accountSelected(app.getAccount());
            }
            NotificationManager nMgr = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            nMgr.cancel(OpacClient.NOTIF_ID);
        }
    }
    setHasOptionsMenu(true);
    accountSelected(app.getAccount());
    final Handler handler = new Handler();
    handler.post(new Runnable() {
        public void run() {
            refreshage();
            handler.postDelayed(this, 60000);
        }
    });
    return view;
}

Output:
                 app.setAccount(getActivity().getIntent().getExtras().getLong("String_Node_Str"));
-                accountSelected(app.getAccount());
+                ((OpacActivity) getActivity()).accountSelected(app.getAccount());
             }


Input:
public void testOverlayBufferTree() {
    MultiOverlayBufferTree tree = new MultiOverlayBufferTree(new byte[0], new DefaultByteRangeComparator());
    final int numElements = 200;
    final SortedMap<String, byte[]> map1 = new TreeMap<String, byte[]>();
    for (int i = 0; i < numElements; i++) {
        String keyString = Integer.toHexString(i);
        String valString = Integer.toHexString((int) (Math.random() * Integer.MAX_VALUE));
        byte[] key = keyString.getBytes();
        byte[] val = valString.getBytes();
        map1.put(keyString, val);
        tree.insert(key, val);
    }
    for (int i = 0; i < numElements; i++) {
        String keyString = Integer.toHexString(i);
        byte[] key = keyString.getBytes();
        assertEquals(tree.lookup(key), map1.get(keyString));
    }
    int snap1 = tree.newOverlay();
    final SortedMap<String, byte[]> map2 = new TreeMap<String, byte[]>(map1);
    for (int i = 0; i < numElements; i += 2) {
        String keyString = Integer.toHexString(i);
        byte[] key = keyString.getBytes();
        tree.insert(key, null);
        map2.remove(keyString);
    }
    for (int i = 0; i < numElements; i++) {
        String keyString = Integer.toHexString(i);
        byte[] key = keyString.getBytes();
        assertEquals(tree.lookup(key), map2.get(keyString));
    }
    int snap2 = tree.newOverlay();
    final SortedMap<String, byte[]> map3 = new TreeMap<String, byte[]>(map2);
    for (int i = 0; i < numElements; i += 5) {
        String keyString = Integer.toHexString(i);
        byte[] key = keyString.getBytes();
        byte[] val = Integer.toHexString((int) (Math.random() * Integer.MAX_VALUE)).getBytes();
        tree.insert(key, val);
        map3.put(keyString, val);
    }
    for (int i = 0; i < numElements; i++) {
        String keyString = Integer.toHexString(i);
        byte[] key = keyString.getBytes();
        assertEquals(tree.lookup(key), map3.get(keyString));
    }
    Iterator<Entry<byte[], byte[]>> it = tree.prefixLookup(null);
    Iterator<byte[]> itExpected = map3.values().iterator();
    while (it.hasNext()) assertEquals(itExpected.next(), it.next().getValue());
    assertFalse(itExpected.hasNext());
    it = tree.prefixLookup(null, snap1);
    itExpected = map1.values().iterator();
    while (it.hasNext()) assertEquals(itExpected.next(), it.next().getValue());
    assertFalse(itExpected.hasNext());
    it = tree.prefixLookup(null, snap2);
    itExpected = map2.values().iterator();
    while (it.hasNext()) assertEquals(itExpected.next(), it.next().getValue());
    assertFalse(itExpected.hasNext());
    it = tree.prefixLookup("String_Node_Str".getBytes());
    itExpected = map3.subMap("String_Node_Str", "String_Node_Str").values().iterator();
    while (it.hasNext()) assertEquals(itExpected.next(), it.next().getValue());
    assertFalse(itExpected.hasNext());
}

Output:
     }
-    Iterator<Entry<byte[], byte[]>> it = tree.prefixLookup(null);
+    Iterator<Entry<byte[], byte[]>> it = tree.prefixLookup(null, false);
     Iterator<byte[]> itExpected = map3.values().iterator();


Input:
public synchronized void start() {
    try {
        parseXmlConfigFile(sFileName);
        if (generalManager.isStandalone()) {
            generalManager.getViewGLCanvasManager().startAnimator();
            swtGUIManager.runApplication();
        }
    } catch (CaleydoRuntimeException gre) {
        generalManager.getLogger().log(Level.SEVERE, "String_Node_Str" + gre.toString());
        generalManager.getGUIBridge().closeApplication();
    }
}

Output:
 public synchronized void start() {
-    try {
-        parseXmlConfigFile(sFileName);
-        if (generalManager.isStandalone()) {
-            generalManager.getViewGLCanvasManager().startAnimator();
-            swtGUIManager.runApplication();
-        }
-    } catch (CaleydoRuntimeException gre) {
-        generalManager.getLogger().log(Level.SEVERE, "String_Node_Str" + gre.toString());
-        generalManager.getGUIBridge().closeApplication();
+    parseXmlConfigFile(sFileName);
+    if (generalManager.isStandalone()) {
+        generalManager.getViewGLCanvasManager().startAnimator();
+        swtGUIManager.runApplication();
     }


Input:
public void testDestinationResolverIsCreatedIfNull() throws Exception {
    AbstractMessageListenerContainer container = new StubAbstractMessageListenerContainer();
    container.setAmazonSqs(Mockito.mock(AmazonSQSAsync.class));
    container.setMessageListener(Mockito.mock(MessageListener.class));
    container.setDestinationName("String_Node_Str");
    container.afterPropertiesSet();
    DestinationResolver destinationResolver = container.getDestinationResolver();
    Assert.assertNotNull(destinationResolver);
    Assert.assertTrue(CachingDestinationResolver.class.isInstance(destinationResolver));
}

Output:
     container.afterPropertiesSet();
-    DestinationResolver destinationResolver = container.getDestinationResolver();
+    DestinationResolver<String> destinationResolver = container.getDestinationResolver();
     Assert.assertNotNull(destinationResolver);


Input:
public void overrideCoprocessorLocalJar(String path) {
    kylinConfig.setProperty(COPROCESSOR_LOCAL_JAR, path);
}

Output:
 public void overrideCoprocessorLocalJar(String path) {
-    kylinConfig.setProperty(COPROCESSOR_LOCAL_JAR, path);
+    System.setProperty(COPROCESSOR_LOCAL_JAR, path);
 }


Input:
protected Answer cloneVolume(DataObject template, DataObject volume) {
    CopyCommand cmd = new CopyCommand(template.getTO(), volume.getTO(), 0, _mgmtServer.getExecuteInSequence());
    try {
        EndPoint ep = selector.select(volume.getDataStore());
        Answer answer = null;
        if (ep == null) {
            String errMsg = "String_Node_Str";
            s_logger.error(errMsg);
            answer = new Answer(cmd, false, errMsg);
        } else {
            answer = ep.sendMessage(cmd);
        }
        return answer;
    } catch (Exception e) {
        s_logger.debug("String_Node_Str", e);
        throw new CloudRuntimeException("String_Node_Str", e);
    }
}

Output:
 protected Answer cloneVolume(DataObject template, DataObject volume) {
-    CopyCommand cmd = new CopyCommand(template.getTO(), volume.getTO(), 0, _mgmtServer.getExecuteInSequence());
+    CopyCommand cmd = new CopyCommand(template.getTO(), volume.getTO(), 0, VirtualMachineManager.ExecuteInSequence.value());
     try {


Input:
public void breakBlock(World world, int x, int y, int z, Block block, int meta) {
    TileEntity tile = world.getTileEntity(x, y, z);
    if (tile instanceof TileAntennaPart && ((TileAntennaPart) tile).network != null) {
        ((TileAntennaPart) tile).network.split((TileAntennaPart) tile);
        if (((TileAntennaPart) tile).connections.size() > 0) {
            for (TileEntity t : ((TileAntennaPart) tile).connections.values()) {
                if (t instanceof TileAntennaPart) {
                    ((TileAntennaPart) t).doConnectionUpdate = true;
                }
            }
        }
    }
    super.breakBlock(world, x, y, z, block, meta);
}

Output:
 public void breakBlock(World world, int x, int y, int z, Block block, int meta) {
-    TileEntity tile = world.getTileEntity(x, y, z);
-    if (tile instanceof TileAntennaPart && ((TileAntennaPart) tile).network != null) {
-        ((TileAntennaPart) tile).network.split((TileAntennaPart) tile);
-        if (((TileAntennaPart) tile).connections.size() > 0) {
-            for (TileEntity t : ((TileAntennaPart) tile).connections.values()) {
-                if (t instanceof TileAntennaPart) {
-                    ((TileAntennaPart) t).doConnectionUpdate = true;
+    if (!world.isRemote) {
+        TileEntity tile = world.getTileEntity(x, y, z);
+        if (tile instanceof TileAntennaPart && ((TileAntennaPart) tile).network != null) {
+            ((TileAntennaPart) tile).network.split((TileAntennaPart) tile);
+            if (((TileAntennaPart) tile).connections.size() > 0) {
+                for (TileEntity t : ((TileAntennaPart) tile).connections.values()) {
+                    if (t instanceof TileAntennaPart) {
+                        ((TileAntennaPart) t).doConnectionUpdate = true;
+                    }
                 }


Input:
public MediaSize asPortrait() {
    return new MediaSize(mId, mPackageName, mLabel, Math.min(mWidthMils, mHeightMils), Math.max(mWidthMils, mHeightMils), mLabelResId);
}

Output:
 public MediaSize asPortrait() {
-    return new MediaSize(mId, mPackageName, mLabel, Math.min(mWidthMils, mHeightMils), Math.max(mWidthMils, mHeightMils), mLabelResId);
+    return new MediaSize(mId, mLabel, mPackageName, Math.min(mWidthMils, mHeightMils), Math.max(mWidthMils, mHeightMils), mLabelResId);
 }


Input:
public LongLongIndex getIndex(ZooFieldDef field) {
    for (FieldIndex fi : fieldIndices) {
        if (fi.fieldId == field.getFieldSchemaId()) {
            if (fi.index == null) {
                if (fi.isUnique) {
                    fi.index = IndexFactory.loadUniqueIndex(DATA_TYPE.FIELD_INDEX, file, fi.page);
                } else {
                    fi.index = IndexFactory.loadIndex(DATA_TYPE.FIELD_INDEX, file, fi.page);
                }
            }
            return fi.index;
        }
    }
    return null;
}

Output:
             if (fi.index == null) {
-                if (fi.isUnique) {
+                if (fi.isUnique && !field.isString()) {
                     fi.index = IndexFactory.loadUniqueIndex(DATA_TYPE.FIELD_INDEX, file, fi.page);