Input:
private void addCommonWebBundleDescriptor(WebBundleDescriptor wbd) {
    super.addBundleDescriptor(wbd);
    WebBundleDescriptorImpl webBundleDescriptor = (WebBundleDescriptorImpl) wbd;
    for (WebComponentDescriptor webComponentDesc : webBundleDescriptor.getWebComponentDescriptors()) {
        WebComponentDescriptorImpl webComponentDescriptor = new WebComponentDescriptorImpl(webComponentDesc);
        webComponentDescriptor.setWebBundleDescriptor(null);
        List<String> removeUrlPatterns = null;
        for (String urlPattern : webComponentDescriptor.getUrlPatternsSet()) {
            String servletName = null;
            if (urlPattern2ServletName != null) {
                servletName = urlPattern2ServletName.get(urlPattern);
            }
            if (servletName != null && (!servletName.equals(webComponentDescriptor.getCanonicalName()))) {
                if (removeUrlPatterns == null) {
                    removeUrlPatterns = new ArrayList<String>();
                }
                removeUrlPatterns.add(urlPattern);
            }
        }
        if (removeUrlPatterns != null) {
            webComponentDescriptor.getUrlPatternsSet().removeAll(removeUrlPatterns);
        }
        addWebComponentDescriptor(webComponentDescriptor);
    }
    getContextParametersSet().addAll(webBundleDescriptor.getContextParametersSet());
    for (MimeMapping mimeMap : webBundleDescriptor.getMimeMappingsSet()) {
        addMimeMapping(mimeMap);
    }
    for (ErrorPageDescriptor errPageDesc : webBundleDescriptor.getErrorPageDescriptorsSet()) {
        addErrorPageDescriptor(errPageDesc);
    }
    getAppListeners().addAll(webBundleDescriptor.getAppListeners());
    combineSecurityConstraints(getSecurityConstraintsSet(), webBundleDescriptor.getSecurityConstraintsSet());
    combineServletFilters(webBundleDescriptor);
    combineServletFilterMappings(webBundleDescriptor);
    if (getLocaleEncodingMappingListDescriptor() == null) {
        setLocaleEncodingMappingListDescriptor(webBundleDescriptor.getLocaleEncodingMappingListDescriptor());
    }
    if (webBundleDescriptor.getJspConfigDescriptor() != null) {
        JspConfigDescriptor jspConfigDesc = getJspConfigDescriptor();
        if (jspConfigDesc == null) {
            jspConfigDesc = new JspConfigDescriptor();
            setJspConfigDescriptor(jspConfigDesc);
        }
        jspConfigDescriptor.add(webBundleDescriptor.getJspConfigDescriptor());
    }
    WebServicesDescriptor thisWebServices = this.getWebServices();
    WebServicesDescriptor otherWebServices = webBundleDescriptor.getWebServices();
    for (WebService ws : otherWebServices.getWebServices()) {
        thisWebServices.addWebService(new WebService(ws));
    }
    if (getSessionConfig() == null) {
        setSessionConfig(webBundleDescriptor.getSessionConfig());
    }
    combineLoginConfiguration(webBundleDescriptor);
    Boolean otherIsDistributable = webBundleDescriptor.isDistributable();
    if (otherIsDistributable != null) {
        if (isDistributable != null) {
            setDistributable(isDistributable && otherIsDistributable);
        } else {
            setDistributable(otherIsDistributable);
        }
    }
    combinePostConstructDescriptors(webBundleDescriptor);
    combinePreDestroyDescriptors(webBundleDescriptor);
    addJndiNameEnvironment(webBundleDescriptor);
}

Output:
     if (webBundleDescriptor.getJspConfigDescriptor() != null) {
-        JspConfigDescriptor jspConfigDesc = getJspConfigDescriptor();
+        JspConfigDescriptorImpl jspConfigDesc = getJspConfigDescriptor();
         if (jspConfigDesc == null) {


Input:
public HTTPRequestValidationHandler addQueryParamsArrayWithPattern(String arrayName, String pattern, boolean required) {
    this.addQueryParamRule(ParameterValidationRuleImpl.ParameterValidationRuleFactory.createValidationRuleWithCustomTypeValidator(arrayName, ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator.createStringTypeValidator(pattern)), !required, false, ParameterLocation.QUERY));
    return this;
}

Output:
 public HTTPRequestValidationHandler addQueryParamsArrayWithPattern(String arrayName, String pattern, boolean required) {
-    this.addQueryParamRule(ParameterValidationRuleImpl.ParameterValidationRuleFactory.createValidationRuleWithCustomTypeValidator(arrayName, ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator.createStringTypeValidator(pattern)), !required, false, ParameterLocation.QUERY));
+    this.addQueryParamRule(ParameterValidationRuleImpl.ParameterValidationRuleFactory.createValidationRuleWithCustomTypeValidator(arrayName, ParameterTypeValidator.createArrayTypeValidator(ParameterTypeValidator.createStringTypeValidator(pattern, null)), !required, false, ParameterLocation.QUERY));
     return this;


Input:
public void onListObtained(boolean successful) {
    RouterServiceValidator vlad = new RouterServiceValidator(finalContext, componentName);
    if (vlad.validate()) {
        queuedService = componentName;
        finalIntent.setAction("String_Node_Str");
        onSdlEnabled(finalContext, finalIntent);
    } else {
        Log.w(TAG, "String_Node_Str" + componentName.getClassName());
    }
}

Output:
     RouterServiceValidator vlad = new RouterServiceValidator(finalContext, componentName);
-    if (vlad.validate()) {
-        queuedService = componentName;
-        finalIntent.setAction("String_Node_Str");
-        onSdlEnabled(finalContext, finalIntent);
-    } else {
-        Log.w(TAG, "String_Node_Str" + componentName.getClassName());
-    }
+    finalIntent.putExtra(TransportConstants.ROUTER_SERVICE_VALIDATED, vlad.validate());
+    onSdlEnabled(finalContext, finalIntent);
 }


Input:
private void onSaveAction() {
    final String htmlName = ClientUtils.removeLastSuffix(view.getNameField().getValue(), HTML_TAG_NEW_LINE);
    if (!FormPanel.valid(view.getCommonForm(), view.getSpecificForm())) {
        return;
    }
    if (htmlName != null && htmlName.isEmpty()) {
        N10N.warn(I18N.CONSTANTS.form_validation_ko());
        return;
    }
    final ElementTypeEnum type = EnumModel.getEnum(view.getTypeField().getValue());
    final LayoutGroupDTO group = view.getLayoutGroupField().getValue();
    final Integer order = ClientUtils.getInteger(view.getOrderField().getValue().intValue());
    final Boolean mandatory = view.getMandatoryField().getValue();
    final PrivacyGroupDTO privacyGroup = view.getPrivacyGroupField().getValue();
    final Boolean amendable = view.getAmendableField().getValue();
    final Boolean exportable = view.getExportableField().getValue();
    final Boolean banner = view.getBannerField().getValue();
    final Integer bannerPosition = ClientUtils.getSimpleValue(view.getBannerPositionField());
    final TextAreaType textAreaType = EnumModel.getEnum(view.getTextAreaTypeField().getValue());
    final Integer length = ClientUtils.getInteger(view.getLengthField().getValue());
    final Boolean decimal = view.getDecimalField().getValue();
    final Integer maxLimit = ClientUtils.getInteger(view.getMaxLimitField().getValue());
    final Integer minLimit = ClientUtils.getInteger(view.getMinLimitField().getValue());
    final Long maxLimitDate = ClientUtils.getTimestamp(view.getMinDateField().getValue());
    final Long minLimitDate = ClientUtils.getTimestamp(view.getMaxDateField().getValue());
    final ReportModelDTO reportModel = view.getReportModelField().getValue();
    final Boolean multiple = view.getMultipleChoicesField().getValue();
    final CategoryTypeDTO category = view.getCategoryTypeField().getValue();
    final Map<String, Object> newFieldProperties = new HashMap<String, Object>();
    newFieldProperties.put(AdminUtil.PROP_FX_NAME, htmlName);
    newFieldProperties.put(AdminUtil.PROP_FX_TYPE, (flexibleElement instanceof BudgetElementDTO) ? ElementTypeEnum.DEFAULT : type);
    newFieldProperties.put(AdminUtil.PROP_FX_GROUP, group);
    newFieldProperties.put(AdminUtil.PROP_FX_ORDER_IN_GROUP, order);
    newFieldProperties.put(AdminUtil.PROP_FX_IN_BANNER, banner);
    newFieldProperties.put(AdminUtil.PROP_FX_POS_IN_BANNER, bannerPosition);
    newFieldProperties.put(AdminUtil.PROP_FX_IS_COMPULSARY, mandatory);
    newFieldProperties.put(AdminUtil.PROP_FX_PRIVACY_GROUP, privacyGroup);
    newFieldProperties.put(AdminUtil.PROP_FX_AMENDABLE, amendable);
    newFieldProperties.put(AdminUtil.PROP_FX_EXPORTABLE, exportable);
    newFieldProperties.put(AdminUtil.PROP_FX_TEXT_TYPE, textAreaType != null ? textAreaType.getCode() : null);
    newFieldProperties.put(AdminUtil.PROP_FX_LENGTH, length);
    newFieldProperties.put(AdminUtil.PROP_FX_MAX_LIMIT, maxLimit);
    newFieldProperties.put(AdminUtil.PROP_FX_MIN_LIMIT, minLimit);
    if (textAreaType == TextAreaType.DATE) {
        newFieldProperties.put(AdminUtil.PROP_FX_MAX_LIMIT, maxLimitDate);
        newFieldProperties.put(AdminUtil.PROP_FX_MIN_LIMIT, minLimitDate);
    }
    if (type == ElementTypeEnum.TEXT_AREA && decimal != null) {
        newFieldProperties.put(AdminUtil.PROP_FX_DECIMAL, decimal);
    }
    newFieldProperties.put(AdminUtil.PROP_FX_REPORT_MODEL, reportModel);
    newFieldProperties.put(AdminUtil.PROP_FX_Q_MULTIPLE, multiple);
    if (category != null && !DEFAULT_CATEGORY_TYPE.equals(category)) {
        newFieldProperties.put(AdminUtil.PROP_FX_Q_CATEGORY, category);
    }
    if (ClientUtils.isNotEmpty(customChoices)) {
        newFieldProperties.put(AdminUtil.PROP_FX_Q_CHOICES, new ArrayList<String>(customChoices));
    }
    if (ClientUtils.isNotEmpty(disabledCustomChoices)) {
        newFieldProperties.put(AdminUtil.PROP_FX_Q_CHOICES_DISABLED, disabledCustomChoices);
    }
    List<BudgetSubFieldDTO> budgetSubFieldsToUpdate = new ArrayList<BudgetSubFieldDTO>();
    if (view.getBudgetFields().getRowCount() > 0) {
        for (int i = 1; i < view.getBudgetFields().getRowCount(); i++) {
            if (view.getBudgetFields().getWidget(i, 0) != null) {
                Object budgetFieldData = ((Text) view.getBudgetFields().getWidget(i, 0)).getData("String_Node_Str");
                if (budgetFieldData != null) {
                    ((BudgetSubFieldDTO) budgetFieldData).setFieldOrder(i);
                    budgetSubFieldsToUpdate.add((BudgetSubFieldDTO) budgetFieldData);
                }
            }
        }
        newFieldProperties.put(AdminUtil.PROP_FX_B_BUDGETSUBFIELDS, budgetSubFieldsToUpdate);
        newFieldProperties.put(AdminUtil.PROP_FX_B_BUDGET_RATIO_DIVIDEND, view.getUpBudgetSubFieldCombo().getValue());
        newFieldProperties.put(AdminUtil.PROP_FX_B_BUDGET_RATIO_DIVISOR, view.getDownBudgetSubFieldCombo().getValue());
    }
    final StringBuilder message = new StringBuilder();
    message.append("String_Node_Str");
    for (Map.Entry<String, Object> newP : newFieldProperties.entrySet()) {
        message.append(newP.getKey()).append('=').append(newP.getValue()).append("String_Node_Str");
    }
    if (Log.isDebugEnabled()) {
        Log.debug(message.append(')').toString());
    }
    if (flexibleElement != null) {
        message.setLength(0);
        message.append("String_Node_Str");
        for (final Entry<String, Object> old : oldFieldProperties.entrySet()) {
            message.append(old.getKey()).append('=').append(old.getValue()).append("String_Node_Str");
            if ((old.getValue() != null && old.getValue().equals(newFieldProperties.get(old.getKey()))) || (old.getValue() == null && newFieldProperties.get(old.getKey()) == null)) {
                newFieldProperties.remove(old.getKey());
            }
        }
        if (Log.isDebugEnabled()) {
            Log.debug(message.append(')').toString());
        }
    }
    message.setLength(0);
    message.append("String_Node_Str");
    for (final Entry<String, Object> newP : newFieldProperties.entrySet()) {
        message.append(newP.getKey()).append('=').append(newP.getValue()).append("String_Node_Str");
    }
    if (Log.isDebugEnabled()) {
        Log.debug(message.append(')').toString());
    }
    if (newFieldProperties.get(AdminUtil.PROP_FX_ORDER_IN_GROUP) != null) {
        newFieldProperties.put(AdminUtil.PROP_FX_GROUP, group);
    }
    newFieldProperties.put(AdminUtil.PROP_FX_FLEXIBLE_ELEMENT, (flexibleElement != null) ? flexibleElement : new TextAreaElementDTO());
    newFieldProperties.put(AdminUtil.ADMIN_PROJECT_MODEL, currentModel);
    newFieldProperties.put(AdminUtil.ADMIN_ORG_UNIT_MODEL, currentModel);
    newFieldProperties.put(AdminUtil.PROP_FX_OLD_FIELDS, oldFieldProperties);
    dispatch.execute(new CreateEntity(currentModel.getEntityName(), newFieldProperties), new CommandResultHandler<CreateResult>() {
        public void onCommandFailure(final Throwable caught) {
            N10N.error(I18N.CONSTANTS.adminFlexibleCreationBox(), I18N.MESSAGES.adminStandardCreationFailure(I18N.CONSTANTS.adminStandardFlexibleName() + "String_Node_Str" + htmlName + "String_Node_Str"));
        }
        public void onCommandSuccess(final CreateResult result) {
            if (result == null) {
                N10N.warn(I18N.CONSTANTS.adminFlexibleCreationBox(), I18N.MESSAGES.adminStandardCreationNull(I18N.CONSTANTS.adminStandardFlexibleName() + "String_Node_Str" + htmlName + "String_Node_Str"));
                return;
            }
            final boolean update = flexibleElement != null;
            final IsModel updatedModel = (IsModel) result.getEntity();
            FlexibleElementDTO updatedOrCreatedFlexibleElement = null;
            if (update) {
                for (final FlexibleElementDTO updatedFlexibleElement : updatedModel.getAllElements()) {
                    if (updatedFlexibleElement.getId().equals(flexibleElement.getId())) {
                        updatedOrCreatedFlexibleElement = updatedFlexibleElement;
                    }
                }
                N10N.infoNotif(I18N.CONSTANTS.adminFlexibleCreationBox(), I18N.MESSAGES.adminStandardUpdateSuccess(I18N.CONSTANTS.adminStandardFlexibleName() + "String_Node_Str" + htmlName + "String_Node_Str"));
            } else {
                final List<Integer> oldFlexibleIds = new ArrayList<Integer>();
                for (final FlexibleElementDTO oldFlexibleElement : currentModel.getAllElements()) {
                    oldFlexibleIds.add(oldFlexibleElement.getId());
                }
                for (final FlexibleElementDTO newFlexibleElement : updatedModel.getAllElements()) {
                    if (!oldFlexibleIds.contains(newFlexibleElement.getId())) {
                        updatedOrCreatedFlexibleElement = newFlexibleElement;
                    }
                }
                N10N.infoNotif(I18N.CONSTANTS.adminFlexibleCreationBox(), I18N.MESSAGES.adminStandardCreationSuccess(I18N.CONSTANTS.adminStandardFlexibleName() + "String_Node_Str" + htmlName + "String_Node_Str"));
            }
            eventBus.fireEvent(new UpdateEvent(UpdateEvent.FLEXIBLE_ELEMENT_UPDATE, updatedModel, update, updatedOrCreatedFlexibleElement));
            hideView();
        }
    }, view.getSaveButton());
}

Output:
     final Integer minLimit = ClientUtils.getInteger(view.getMinLimitField().getValue());
-    final Long maxLimitDate = ClientUtils.getTimestamp(view.getMinDateField().getValue());
-    final Long minLimitDate = ClientUtils.getTimestamp(view.getMaxDateField().getValue());
+    final Long minLimitDate = ClientUtils.getTimestamp(view.getMinDateField().getValue());
+    final Long maxLimitDate = ClientUtils.getTimestamp(view.getMaxDateField().getValue());
     final ReportModelDTO reportModel = view.getReportModelField().getValue();


Input:
public void testTcpSource7() throws InterruptedException {
    log.info("String_Node_Str");
    SiddhiManager siddhiManager = new SiddhiManager();
    String inStreamDefinition = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    String query = ("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    ExecutionPlanRuntime executionPlanRuntime = siddhiManager.createExecutionPlanRuntime(inStreamDefinition + query);
    executionPlanRuntime.addCallback("String_Node_Str", new StreamCallback() {
        public void receive(Event[] events) {
            EventPrinter.print(events);
            eventArrived = true;
            for (Event event : events) {
                count++;
                switch(count) {
                    case 1:
                        Assert.assertEquals("String_Node_Str", event.getData(0));
                        break;
                    case 2:
                        Assert.assertEquals("String_Node_Str", event.getData(0));
                        break;
                    case 3:
                        Assert.assertEquals("String_Node_Str", event.getData(0));
                        break;
                    case 4:
                        Assert.assertEquals("String_Node_Str", event.getData(0));
                        break;
                    case 5:
                        Assert.assertEquals("String_Node_Str", event.getData(0));
                        break;
                    case 6:
                        Assert.assertEquals("String_Node_Str", event.getData(0));
                        break;
                    default:
                        org.junit.Assert.fail();
                }
            }
        }
    });
    executionPlanRuntime.start();
    TCPNettyClient TCPNettyClient = new TCPNettyClient();
    TCPNettyClient.connect("String_Node_Str", 9892);
    ArrayList<Event> arrayList = new ArrayList<Event>(3);
    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 36, 3.0f, 380l, 23.0, true }));
    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 361, 31.0f, 3801l, 231.0, false }));
    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 362, 32.0f, 3802l, 232.0, true }));
    TCPNettyClient.send("String_Node_Str", arrayList.toArray(new Event[3]));
    TCPNettyClient.disconnect();
    TCPNettyClient.shutdown();
    Thread.sleep(300);
    Assert.assertEquals(6, count);
    Assert.assertTrue(eventArrived);
    executionPlanRuntime.shutdown();
}

Output:
     ArrayList<Event> arrayList = new ArrayList<Event>(3);
-    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 36, 3.0f, 380l, 23.0, true }));
-    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 361, 31.0f, 3801l, 231.0, false }));
-    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 362, 32.0f, 3802l, 232.0, true }));
+    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 36, 3.0f, 380L, 23.0, true }));
+    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 361, 31.0f, 3801L, 231.0, false }));
+    arrayList.add(new Event(System.currentTimeMillis(), new Object[] { "String_Node_Str", 362, 32.0f, 3802L, 232.0, true }));
+    TCPNettyClient.send("String_Node_Str", arrayList.toArray(new Event[3]));
     TCPNettyClient.send("String_Node_Str", arrayList.toArray(new Event[3]));


Input:
public void onClick(View v) {
    switch(v.getId()) {
        case R.id.btn_delete:
            MenuHelper.deletePhoto(this, mDeletePhotoRunnable);
            break;
        case R.id.btn_play:
            startPlayVideoActivity();
            break;
        case R.id.btn_share:
            {
                IImage image = mAllImages.getImageAt(mCurrentPosition);
                if (MenuHelper.isMMSUri(image.fullSizeImageUri())) {
                    return;
                }
                startShareMediaActivity(image);
                break;
            }
        case R.id.btn_set_as:
            {
                Uri u = mAllImages.getImageAt(mCurrentPosition).fullSizeImageUri();
                Intent intent = new Intent(Intent.ACTION_ATTACH_DATA, u);
                try {
                    startActivity(Intent.createChooser(intent, getText(R.string.setImage)));
                } catch (android.content.ActivityNotFoundException ex) {
                    Toast.makeText(this, R.string.no_way_to_share_video, Toast.LENGTH_SHORT).show();
                }
                break;
            }
        case R.id.btn_done:
            finish();
            break;
        case R.id.next_image:
            moveNextOrPrevious(1);
            break;
        case R.id.prev_image:
            moveNextOrPrevious(-1);
            break;
    }
}

Output:
         case R.id.btn_delete:
-            MenuHelper.deletePhoto(this, mDeletePhotoRunnable);
+            MenuHelper.deleteImage(this, mDeletePhotoRunnable, mAllImages.getImageAt(mCurrentPosition));
             break;


Input:
public void wrapElement(Element element) {
    if (!isFullyInitialized()) {
        element.getParentNode().replaceChild(getElement(), element);
    } else {
        setElement(element);
        html = null;
    }
    if (wrapInitializationCallback != null) {
        wrapInitializationCallback.execute();
        wrapInitializationCallback = null;
    }
}

Output:
 public void wrapElement(Element element) {
-    if (!isFullyInitialized()) {
-        element.getParentNode().replaceChild(getElement(), element);
-    } else {
-        setElement(element);
-        html = null;
+    if (isFullyInitialized()) {
+        throw new IllegalStateException("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
     }


Input:
public boolean isGroupOpened(int groupIndex) {
    return _opens == null ? true : _opens[groupIndex];
}

Output:
 public boolean isGroupOpened(int groupIndex) {
-    return _opens == null ? true : _opens[groupIndex];
+    return _opens == null || _opens[groupIndex];
 }


Input:
public Boolean call(Example example) {
    CategoricalPrediction prediction = (CategoricalPrediction) forest.classify(example);
    CategoricalFeature target = (CategoricalFeature) example.getTarget();
    return prediction.getMostProbableCategoryEncoding() == target.getEncoding();
}

Output:
 public Boolean call(Example example) {
-    CategoricalPrediction prediction = (CategoricalPrediction) forest.classify(example);
+    CategoricalPrediction prediction = (CategoricalPrediction) forest.predict(example);
     CategoricalFeature target = (CategoricalFeature) example.getTarget();


Input:
protected void parse_medialist(List<ContentValues> medien, Document doc, int offset, String accountName) throws ClientProtocolException, IOException {
    Elements copytrs = doc.select("String_Node_Str");
    SimpleDateFormat sdf = new SimpleDateFormat("String_Node_Str", Locale.GERMAN);
    int trs = copytrs.size();
    if (trs < 1) {
        medien = null;
        return;
    }
    assert (trs > 0);
    for (int i = 0; i < trs; i++) {
        Element tr = copytrs.get(i);
        String prolongCount = "String_Node_Str";
        try {
            String html = httpGet(https_url + "String_Node_Str" + accountName + "String_Node_Str" + db + "String_Node_Str" + tr.child(1).select("String_Node_Str").attr("String_Node_Str"), getDefaultEncoding());
            prolongCount = Jsoup.parse(html).text();
        } catch (IOException e) {
        }
        String reminderCount = tr.child(13).text().trim();
        if (reminderCount.indexOf("String_Node_Str") >= 0 && reminderCount.indexOf("String_Node_Str") >= 0)
            reminderCount = reminderCount.substring(reminderCount.indexOf("String_Node_Str") + 1, reminderCount.indexOf("String_Node_Str"));
        ContentValues e = new ContentValues();
        if (tr.child(4).text().trim().length() < 5 && tr.child(5).text().trim().length() > 4) {
            e.put(AccountData.KEY_LENT_TITLE, tr.child(5).text().trim());
        } else {
            e.put(AccountData.KEY_LENT_TITLE, tr.child(4).text().trim());
        }
        String status = "String_Node_Str";
        if (!reminderCount.equals("String_Node_Str")) {
            status += reminderCount + "String_Node_Str";
        }
        status += prolongCount + "String_Node_Str";
        e.put(AccountData.KEY_LENT_STATUS, status);
        e.put(AccountData.KEY_LENT_DEADLINE, tr.child(21).text().trim());
        try {
            e.put(AccountData.KEY_LENT_DEADLINE_TIMESTAMP, sdf.parse(e.getAsString(AccountData.KEY_LENT_DEADLINE)).getTime());
        } catch (ParseException e1) {
            e1.printStackTrace();
        }
        e.put(AccountData.KEY_LENT_LINK, tr.child(1).select("String_Node_Str").attr("String_Node_Str"));
        medien.add(e);
    }
    assert (medien.size() == trs - 1);
}

Output:
         String reminderCount = tr.child(13).text().trim();
-        if (reminderCount.indexOf("String_Node_Str") >= 0 && reminderCount.indexOf("String_Node_Str") >= 0)
+        if (reminderCount.indexOf("String_Node_Str") >= 0 && reminderCount.indexOf("String_Node_Str") >= 0 && reminderCount.indexOf("String_Node_Str") < reminderCount.indexOf("String_Node_Str"))
             reminderCount = reminderCount.substring(reminderCount.indexOf("String_Node_Str") + 1, reminderCount.indexOf("String_Node_Str"));


Input:
private TaskRead processResponse(ResponseEntity<String> response, HttpMethod verb, PrettyOutput... prettyOutput) throws Exception {
    HttpStatus responseStatus = response.getStatusCode();
    if (responseStatus == HttpStatus.ACCEPTED) {
        HttpHeaders headers = response.getHeaders();
        URI taskURI = headers.getLocation();
        String[] taskURIs = taskURI.toString().split("String_Node_Str");
        String taskId = taskURIs[taskURIs.length - 1];
        TaskRead taskRead;
        int oldProgress = 0;
        Status oldTaskStatus = null;
        Status taskStatus = null;
        int progress = 0;
        do {
            ResponseEntity<TaskRead> taskResponse = restGetById(Constants.REST_PATH_TASK, taskId, TaskRead.class, false);
            taskRead = taskResponse.getBody();
            progress = (int) (taskRead.getProgress() * 100);
            taskStatus = taskRead.getStatus();
            Type taskType = taskRead.getType();
            if ((taskType == Type.DELETE) && (taskStatus == TaskRead.Status.COMPLETED)) {
                clearScreen();
                System.out.println(taskStatus + "String_Node_Str" + progress + "String_Node_Str");
                break;
            }
            if (taskType == Type.SHRINK && !taskRead.getFailNodes().isEmpty()) {
                throw new CliRestException(taskRead.getFailNodes().get(0).getErrorMessage());
            }
            if ((prettyOutput != null && prettyOutput.length > 0 && (taskRead.getType() == Type.VHM ? prettyOutput[0].isRefresh(true) : prettyOutput[0].isRefresh(false))) || oldTaskStatus != taskStatus || oldProgress != progress) {
                clearScreen();
                if (prettyOutput != null && prettyOutput.length > 0 && prettyOutput[0].getCompletedTaskSummary() != null) {
                    for (String summary : prettyOutput[0].getCompletedTaskSummary()) {
                        System.out.println(summary + "String_Node_Str");
                    }
                }
                System.out.println(taskStatus + "String_Node_Str" + progress + "String_Node_Str");
                if (prettyOutput != null && prettyOutput.length > 0) {
                    prettyOutput[0].prettyOutput();
                }
                if (oldTaskStatus != taskStatus || oldProgress != progress) {
                    oldTaskStatus = taskStatus;
                    oldProgress = progress;
                    if (taskRead.getProgressMessage() != null) {
                        System.out.println(taskRead.getProgressMessage());
                    }
                }
            }
            try {
                Thread.sleep(3 * 1000);
            } catch (InterruptedException ex) {
            }
        } while (taskStatus != TaskRead.Status.COMPLETED && taskStatus != TaskRead.Status.FAILED && taskStatus != TaskRead.Status.ABANDONED && taskStatus != TaskRead.Status.STOPPED);
        String errorMsg = taskRead.getErrorMessage();
        if (!taskRead.getStatus().equals(TaskRead.Status.COMPLETED)) {
            throw new CliRestException(errorMsg);
        } else {
            if (taskRead.getType().equals(Type.VHM)) {
                logger.info("String_Node_Str");
                Thread.sleep(5 * 1000);
                if (prettyOutput != null && prettyOutput.length > 0 && prettyOutput[0].isRefresh(true)) {
                    clearScreen();
                    System.out.println(taskStatus + "String_Node_Str" + progress + "String_Node_Str");
                    if (prettyOutput != null && prettyOutput.length > 0) {
                        prettyOutput[0].prettyOutput();
                    }
                }
            } else {
                return taskRead;
            }
        }
    }
    return null;
}

Output:
             }
-            if ((prettyOutput != null && prettyOutput.length > 0 && (taskRead.getType() == Type.VHM ? prettyOutput[0].isRefresh(true) : prettyOutput[0].isRefresh(false))) || oldTaskStatus != taskStatus || oldProgress != progress) {
+            if ((prettyOutput != null && prettyOutput.length > 0 && prettyOutput[0].isRefresh(true)) || oldTaskStatus != taskStatus || oldProgress != progress) {
                 clearScreen();


Input:
public void apply() {
    upgradeVersionKeys();
}

Output:
 public void apply() {
-    upgradeVersionKeys();
+    if (upgradeVersionKeys(table, maxNumberUpdateRows.get())) {
+        table.put(APP_VERSION_UPGRADE_KEY, COLUMN, Bytes.toBytes(ProjectInfo.getVersion().toString()));
+    }
 }


Input:
private void construct() {
    com.espertech.esper.client.Configuration config = new com.espertech.esper.client.Configuration();
    config.addEventType(Event.class);
    Set<Class<? extends Event>> eventTypes = ReflectionUtil.getSubtypesOf(Event.class);
    for (Class<? extends Event> eventType : eventTypes) config.addEventType(eventType);
    config.addImport(IntoMethod.class);
    if (timeProvider != null) {
        config.getEngineDefaults().getThreading().setInternalTimerEnabled(false);
    }
    epService = EPServiceProviderManager.getDefaultProvider(config);
    if (timeProvider != null) {
        lastTime = timeProvider.getInitialTime();
        final EPServiceProviderImpl epService1 = (EPServiceProviderImpl) epService;
        epService1.initialize(lastTime.getMillis());
    }
    epRuntime = epService.getEPRuntime();
    epAdministrator = epService.getEPAdministrator();
    injector = Guice.createInjector(new Module() {
        public void configure(Binder binder) {
            binder.bind(Context.class).toInstance(Context.this);
            binder.bindListener(Matchers.any(), new ProvisionListener() {
                public <T> void onProvision(ProvisionInvocation<T> tProvisionInvocation) {
                    T provision = tProvisionInvocation.provision();
                    subscribe(provision);
                }
            });
            binder.bindListener(Matchers.any(), new TypeListener() {
                public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) {
                    for (Class<?> c = typeLiteral.getRawType(); c != Object.class; c = c.getSuperclass()) {
                        for (final Field field : c.getDeclaredFields()) {
                            if (field.getType().isAssignableFrom(Logger.class)) {
                                typeEncounter.register(new MembersInjector<I>() {
                                    public void injectMembers(I i) {
                                        try {
                                            boolean wasAccessible = field.isAccessible();
                                            field.setAccessible(true);
                                            if (field.get(i) == null) {
                                                field.set(i, LoggerFactory.getLogger(field.getDeclaringClass()));
                                            }
                                            field.setAccessible(wasAccessible);
                                        } catch (IllegalAccessException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                });
                            }
                        }
                    }
                }
            });
        }
    });
}

Output:
 private void construct() {
-    com.espertech.esper.client.Configuration config = new com.espertech.esper.client.Configuration();
-    config.addEventType(Event.class);
+    final com.espertech.esper.client.Configuration esperConfig = new com.espertech.esper.client.Configuration();
+    esperConfig.addEventType(Event.class);
     Set<Class<? extends Event>> eventTypes = ReflectionUtil.getSubtypesOf(Event.class);


Input:
public void testQueueBrowserNextElementWithNoMessage() throws IOException, Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer()) {
        Connection connection = testFixture.establishConnecton(testPeer);
        connection.start();
        testPeer.expectBegin();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("String_Node_Str");
        testPeer.expectQueueBrowserAttach();
        testPeer.expectLinkFlow();
        testPeer.expectLinkFlow(true, true, equalTo(UnsignedInteger.valueOf(1)));
        testPeer.expectDetach(true, true, true);
        QueueBrowser browser = session.createBrowser(queue);
        Enumeration<?> queueView = browser.getEnumeration();
        assertNotNull(queueView);
        assertNull(queueView.nextElement());
        browser.close();
        testPeer.waitForAllHandlersToComplete(3000);
    }
}

Output:
         testPeer.expectLinkFlow();
-        testPeer.expectLinkFlow(true, true, equalTo(UnsignedInteger.valueOf(1)));
+        testPeer.expectLinkFlow(true, true, equalTo(UnsignedInteger.valueOf(JmsPrefetchPolicy.DEFAULT_QUEUE_BROWSER_PREFETCH)));
         testPeer.expectDetach(true, true, true);


Input:
private void createDatabaseSchema() throws SQLException {
    Connection connection = dataSource.getConnection();
    ResultSet result = connection.getMetaData().getTables(connection.getCatalog(), null, null, null);
    boolean exist = false;
    while (result.next()) {
        if (result.getString("String_Node_Str").equalsIgnoreCase("String_Node_Str")) {
            exist = true;
            break;
        }
    }
    if (exist) {
        return;
    }
    QueryBuilder.create(dataSource, properties.getProperty("String_Node_Str")).executeUpdate();
    User admin = new User();
    admin.setName("String_Node_Str");
    admin.setEmail("String_Node_Str");
    admin.setPassword("String_Node_Str");
    admin.setAdmin(true);
    addUser(admin);
    Server server = new Server();
    server.setRegistration(true);
    QueryBuilder.create(dataSource, properties.getProperty("String_Node_Str")).setObject(server).executeUpdate();
    mockData(admin.getId());
}

Output:
     admin.setAdmin(true);
-    addUser(admin);
+    QueryBuilder.create(dataSource, properties.getProperty("String_Node_Str")).setObject(admin).executeUpdate();
     Server server = new Server();


Input:
public static boolean isMFSFeatures(TrainingParameters params) {
    String mfsFeatures = getSuperSenseFeatures(params);
    return !mfsFeatures.equalsIgnoreCase(Flags.DEFAULT_FEATURE_FLAG);
}

Output:
 public static boolean isMFSFeatures(TrainingParameters params) {
-    String mfsFeatures = getSuperSenseFeatures(params);
+    String mfsFeatures = getMFSFeatures(params);
     return !mfsFeatures.equalsIgnoreCase(Flags.DEFAULT_FEATURE_FLAG);


Input:
public void initTriggerFunction() {
    ClassLoader parent = Thread.currentThread().getContextClassLoader();
    GroovyClassLoader loader = new GroovyClassLoader(parent);
    Class groovyClass = loader.parseClass(groovyTriggerFunction);
    try {
        triggerFunction = (GroovyObject) groovyClass.newInstance();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Output:
     try {
-        triggerFunction = (GroovyObject) groovyClass.newInstance();
+        triggerFunction = (TriggerFunction) groovyClass.newInstance();
     } catch (Exception e) {


Input:
public static synchronized Configuration constructConfiguration(String adaptorName, Object project_properties, Object resources_properties) throws Exception {
    CommAdaptor adaptor = adaptors.get(adaptorName);
    if (adaptor == null) {
        Constructor<?> constrAdaptor = Class.forName(adaptorName).getConstructor();
        adaptor = (CommAdaptor) constrAdaptor.newInstance();
        adaptor.init();
        adaptors.put(adaptorName, adaptor);
    }
    if (debug) {
        logger.debug("String_Node_Str" + adaptorName);
    }
    return adaptor.constructConfiguration(project_properties, resources_properties);
}

Output:
     if (adaptor == null) {
-        Constructor<?> constrAdaptor = Class.forName(adaptorName).getConstructor();
-        adaptor = (CommAdaptor) constrAdaptor.newInstance();
+        try {
+            Constructor<?> constrAdaptor = Class.forName(adaptorName).getConstructor();
+            adaptor = (CommAdaptor) constrAdaptor.newInstance();
+        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            throw new ConstructConfigurationException(e);
+        }
         adaptor.init();


Input:
public void finish() {
    Intent ret = new Intent();
    if (listFragment != null && listFragment.hasChanged()) {
        Log.i("String_Node_Str", "String_Node_Str");
        ret.putExtra(REQUEST_UPDATE, true);
    }
    setResult(Activity.RESULT_OK, ret);
    super.finish();
}

Output:
     Intent ret = new Intent();
-    if (listFragment != null && listFragment.hasChanged()) {
-        Log.i("String_Node_Str", "String_Node_Str");
-        ret.putExtra(REQUEST_UPDATE, true);
-    }
+    markChangedIfRequired(ret);
     setResult(Activity.RESULT_OK, ret);


Input:
public static int parseGravity(String value) {
    String[] gravities = value.split("String_Node_Str");
    int returnGravity = Gravity.NO_GRAVITY;
    for (String gravity : gravities) {
        Primitive gravityValue = sGravityMap.get(gravity);
        if (null != gravityValue) {
            returnGravity |= gravityValue.getAsCharacter();
        }
    }
    return returnGravity;
}

Output:
         if (null != gravityValue) {
-            returnGravity |= gravityValue.getAsCharacter();
+            returnGravity |= gravityValue.getAsInt();
         }


Input:
public static List<VirtualFile> getConceptFiles(Project project) {
    Collection<VirtualFile> virtualFiles = FileBasedIndex.getInstance().getContainingFiles(FileTypeIndex.NAME, ConceptFileType.INSTANCE, GlobalSearchScope.projectScope(project));
    return new ArrayList<VirtualFile>(virtualFiles);
}

Output:
     Collection<VirtualFile> virtualFiles = FileBasedIndex.getInstance().getContainingFiles(FileTypeIndex.NAME, ConceptFileType.INSTANCE, GlobalSearchScope.projectScope(project));
-    return new ArrayList<VirtualFile>(virtualFiles);
+    return new ArrayList<>(virtualFiles);
 }


Input:
public void checkWrite(User user, String path) throws SVNException, IOException {
    if (user.isAnonymous()) {
        throw new SVNException(SVNErrorMessage.create(SVNErrorCode.RA_NOT_AUTHORIZED, "String_Node_Str"));
    }
    try {
        final GitlabProject project = getProjectViaSudo(user);
        if (isProjectOwner(project, user))
            return;
        final GitlabPermission permissions = project.getPermissions();
        if (permissions != null) {
            if (hasAccess(permissions.getProjectAccess(), GitlabAccessLevel.Developer) || hasAccess(permissions.getProjectGroupAccess(), GitlabAccessLevel.Developer)) {
                return;
            }
        }
        throw new SVNException(SVNErrorMessage.create(SVNErrorCode.RA_NOT_AUTHORIZED, "String_Node_Str"));
    } catch (FileNotFoundException ignored) {
        throw new SVNException(SVNErrorMessage.create(SVNErrorCode.RA_NOT_AUTHORIZED, "String_Node_Str"));
    }
}

Output:
         final GitlabProject project = getProjectViaSudo(user);
-        if (isProjectOwner(project, user))
+        if (isProjectOwner(project, user)) {
             return;


Input:
protected ResourceHandle getResourceFromPool(ResourceAllocator alloc, ResourceSpec spec) throws PoolingException {
    ResourceHandle result = null;
    ResourceHandle h;
    ArrayList<ResourceHandle> freeResources = new ArrayList<ResourceHandle>();
    try {
        while ((h = ds.getResource()) != null) {
            if (h.hasConnectionErrorOccurred()) {
                ds.removeResource(h);
                continue;
            }
            if (matchConnection(h, alloc)) {
                boolean isValid = isConnectionValid(h, alloc);
                if (h.hasConnectionErrorOccurred() || !isValid) {
                    if (failAllConnections) {
                        h = createSingleResourceAndAdjustPool(alloc, spec);
                        break;
                    } else {
                        ds.removeResource(h);
                        continue;
                    }
                }
                if (h.isShareable() == alloc.shareableWithinComponent()) {
                    result = h;
                    break;
                } else {
                    freeResources.add(h);
                }
            } else {
                freeResources.add(h);
            }
        }
    } finally {
        for (ResourceHandle freeResource : freeResources) {
            ds.returnResource(freeResource);
        }
        freeResources.clear();
    }
    if (result != null) {
        setResourceStateToBusy(result);
    } else {
        result = resizePoolAndGetNewResource(alloc);
    }
    return result;
}

Output:
                     if (failAllConnections) {
-                        h = createSingleResourceAndAdjustPool(alloc, spec);
+                        createSingleResourceAndAdjustPool(alloc, spec);
                         break;


Input:
public void map(Chunk[] chks, NewChunk nc) {
    int chunkSize = chks[0].len();
    Vector x = bx.value();
    for (int r = 0; r < chunkSize; r++) {
        double v = 0;
        for (int c = 0; c < chks.length; c++) {
            v += (chks[c].at0(r) * x.getQuick(c));
        }
        nc.addNum(v);
    }
}

Output:
         for (int c = 0; c < chks.length; c++) {
-            v += (chks[c].at0(r) * x.getQuick(c));
+            v += (chks[c].atd(r) * x.getQuick(c));
         }


Input:
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
    if (command != null && command.getName().equalsIgnoreCase(COMMAND_RELOAD) || command.getName().equalsIgnoreCase(COMMAND_ABBREVIATED))
        return handleMainCommand(sender, args);
    else
        return false;
}

Output:
 public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-    if (command != null && command.getName().equalsIgnoreCase(COMMAND_RELOAD) || command.getName().equalsIgnoreCase(COMMAND_ABBREVIATED))
+    if (command != null && (command.getName().equalsIgnoreCase(COMMAND_RELOAD) || command.getName().equalsIgnoreCase(COMMAND_ABBREVIATED)))
         return handleMainCommand(sender, args);


Input:
public void asyncRealmObjectShouldNotBlockBackgroundCommitNotification() {
    final AtomicInteger numberOfRealmCallbackInvocation = new AtomicInteger(0);
    final CountDownLatch signalClosedRealm = new CountDownLatch(1);
    final Realm realm = looperThread.realm;
    realm.addChangeListener(new RealmChangeListener<Realm>() {
        public void onChange(final Realm realm) {
            switch(numberOfRealmCallbackInvocation.incrementAndGet()) {
                case 1:
                    {
                        Dog dog = realm.where(Dog.class).findFirstAsync();
                        assertTrue(dog.load());
                        dog.addChangeListener(new RealmChangeListener<Dog>() {
                            public void onChange(Dog dog) {
                            }
                        });
                        new Thread() {
                            public void run() {
                                Realm threadRealm = Realm.getInstance(realm.getConfiguration());
                                threadRealm.beginTransaction();
                                threadRealm.createObject(Dog.class);
                                threadRealm.commitTransaction();
                                threadRealm.close();
                                signalClosedRealm.countDown();
                            }
                        }.start();
                        break;
                    }
                case 2:
                    {
                        TestHelper.awaitOrFail(signalClosedRealm);
                        looperThread.testComplete();
                        break;
                    }
            }
        }
    });
    looperThread.postRunnable(new Runnable() {
        public void run() {
            realm.beginTransaction();
            realm.createObject(Dog.class);
            realm.commitTransaction();
        }
    });
}

Output:
     final CountDownLatch signalClosedRealm = new CountDownLatch(1);
-    final Realm realm = looperThread.realm;
+    final Realm realm = looperThread.getRealm();
     realm.addChangeListener(new RealmChangeListener<Realm>() {


Input:
public Object evaluateCondExpr(IConditionalExpression expr) {
    int operator = expr.getOperator();
    IScriptExpression testExpr = expr.getExpression();
    IScriptExpression v1 = expr.getOperand1();
    IScriptExpression v2 = expr.getOperand2();
    if (testExpr == null)
        return Boolean.FALSE;
    Object testExprValue = evaluate(testExpr.getText());
    if (IConditionalExpression.OP_NONE == operator) {
        return testExprValue;
    }
    Object vv1 = null;
    Object vv2 = null;
    if (v1 != null) {
        vv1 = evaluate(v1.getText());
    }
    if (v2 != null) {
        vv2 = evaluate(v2.getText());
    }
    try {
        return ScriptEvalUtil.evalConditionalExpr(testExprValue, expr.getOperator(), vv1, vv2);
    } catch (Exception e) {
        log.log(Level.SEVERE, e.getMessage(), e);
        addException(new EngineException(MessageConstants.INVALID_EXPRESSION_ERROR, expr, e));
        return Boolean.FALSE;
    }
}

Output:
     try {
-        return ScriptEvalUtil.evalConditionalExpr(testExprValue, expr.getOperator(), vv1, vv2);
+        return ScriptEvalUtil.evalExpr(expr, scriptContext.getContext(), scriptContext.getScope(), null, 0);
     } catch (Exception e) {


Input:
public void updateAppConfig(String clusterName, ClusterCreate clusterCreate) {
    logger.debug("String_Node_Str" + clusterName);
    ClusterEntity cluster = clusterEntityMgr.findByName(clusterName);
    if (cluster == null) {
        logger.error("String_Node_Str" + clusterName + "String_Node_Str");
        throw BddException.NOT_FOUND("String_Node_Str", clusterName);
    }
    SoftwareManager softwareManager = getSoftwareManager(cluster.getAppManager());
    clusterCreate.setDistro(cluster.getDistro());
    clusterCreate.setDistroVersion(cluster.getDistroVersion());
    if (!CommonUtil.isBlank(cluster.getAdvancedProperties())) {
        Gson gson = new Gson();
        Map<String, String> advancedProperties = gson.fromJson(cluster.getAdvancedProperties(), Map.class);
        clusterCreate.setExternalHDFS(advancedProperties.get("String_Node_Str"));
        clusterCreate.setExternalMapReduce(advancedProperties.get("String_Node_Str"));
    }
    ClusterBlueprint blueprint = clusterCreate.toBlueprint();
    try {
        softwareManager.validateBlueprint(blueprint);
    } catch (ValidationException e) {
        throw new ClusterConfigException(e, e.getMessage() + e.getFailedMsgList().toString());
    }
    updateInfrastructure(clusterCreate, softwareManager, blueprint);
    Map<String, Object> clusterLevelConfig = clusterCreate.getConfiguration();
    if (clusterLevelConfig != null && clusterLevelConfig.size() > 0) {
        logger.debug("String_Node_Str");
        cluster.setHadoopConfig((new Gson()).toJson(clusterLevelConfig));
        updateVhmJobTrackerPort(clusterCreate, cluster);
    } else {
        logger.debug("String_Node_Str");
        cluster.setHadoopConfig(null);
    }
    setAdvancedProperties(clusterCreate.getExternalHDFS(), clusterCreate.getExternalMapReduce(), cluster);
    updateNodegroupAppConfig(clusterCreate, cluster, clusterCreate.isValidateConfig());
}

Output:
     } catch (ValidationException e) {
-        throw new ClusterConfigException(e, e.getMessage() + e.getFailedMsgList().toString());
+        throw ClusterConfigException.INVALID_SPEC(e.getFailedMsgList());
     }


Input:
public String getUrl(final String path) {
    if (!StringUtils.hasText(path)) {
        return null;
    }
    return fileUrlPrefix + normalizeSeparators(path.substring(uploadDirectory.getAbsolutePath().length() + 1));
}

Output:
     }
-    return fileUrlPrefix + normalizeSeparators(path.substring(uploadDirectory.getAbsolutePath().length() + 1));
+    return L_FILE_URL_PREFIX + normalizeSeparators(path.substring(uploadDirectory.getAbsolutePath().length() + 1));
 }


Input:
protected void doWork(IProgressMonitor monitor) throws Exception {
    logf("String_Node_Str", teamArt.getName());
    List<AbstractValidationRule> rulesSorted = new ArrayList<>(rules);
    Collections.sort(rulesSorted, new ValidationRuleComparator());
    for (AbstractValidationRule rule : rulesSorted) {
        log(rule.getRuleDescription());
    }
    log("String_Node_Str");
    try {
        ChangeData changeData = AtsBranchManager.getChangeDataFromEarliestTransactionId(teamArt);
        Collection<Artifact> changedArtifacts = changeData.getArtifacts(KindType.ArtifactOrRelation, ModificationType.NEW, ModificationType.MODIFIED);
        checkForCancelledStatus(monitor);
        double total = changedArtifacts.size() + rules.size();
        if (total > 0) {
            Collection<String> warnings = new ArrayList<>();
            int workAmount = calculateWork(1 / total);
            String lastTitle = "String_Node_Str";
            int ruleIndex = 1;
            for (AbstractValidationRule rule : rulesSorted) {
                checkForCancelledStatus(monitor);
                String currentTitle = rule.getRuleTitle();
                if (!lastTitle.equals(currentTitle)) {
                    logf("String_Node_Str", currentTitle);
                    lastTitle = currentTitle;
                }
                int artIndex = 1;
                for (Artifact art : changedArtifacts) {
                    monitor.setTaskName(String.format("String_Node_Str", ruleIndex, rules.size(), artIndex, changedArtifacts.size()));
                    checkForCancelledStatus(monitor);
                    ValidationResult result = rule.validate(art, monitor);
                    if (!result.didValidationPass()) {
                        for (String errorMsg : result.getErrorMessages()) {
                            if (art.isOfType(CoreArtifactTypes.DirectSoftwareRequirement)) {
                                logf("String_Node_Str", errorMsg);
                            } else {
                                warnings.add(String.format("String_Node_Str", errorMsg));
                            }
                        }
                    }
                    monitor.worked(workAmount);
                    artIndex++;
                }
                ruleIndex++;
            }
            for (String warning : warnings) {
                log(warning);
            }
        }
        log("String_Node_Str");
    } catch (Exception ex) {
        OseeLog.log(Activator.class, Level.SEVERE, ex);
        logf("String_Node_Str", ex.getLocalizedMessage());
    }
}

Output:
                 }
-                int artIndex = 1;
-                for (Artifact art : changedArtifacts) {
-                    monitor.setTaskName(String.format("String_Node_Str", ruleIndex, rules.size(), artIndex, changedArtifacts.size()));
-                    checkForCancelledStatus(monitor);
-                    ValidationResult result = rule.validate(art, monitor);
-                    if (!result.didValidationPass()) {
-                        for (String errorMsg : result.getErrorMessages()) {
-                            if (art.isOfType(CoreArtifactTypes.DirectSoftwareRequirement)) {
-                                logf("String_Node_Str", errorMsg);
-                            } else {
-                                warnings.add(String.format("String_Node_Str", errorMsg));
+                if (isSkipRelationCheck(rule.getRuleTitle())) {
+                    logf("String_Node_Str");
+                } else {
+                    int artIndex = 1;
+                    for (Artifact art : changedArtifacts) {
+                        monitor.setTaskName(String.format("String_Node_Str", ruleIndex, rules.size(), artIndex, changedArtifacts.size()));
+                        checkForCancelledStatus(monitor);
+                        ValidationResult result = rule.validate(art, monitor);
+                        if (!result.didValidationPass()) {
+                            for (String errorMsg : result.getErrorMessages()) {
+                                if (art.isOfType(CoreArtifactTypes.DirectSoftwareRequirement)) {
+                                    logf("String_Node_Str", errorMsg);
+                                } else {
+                                    warnings.add(String.format("String_Node_Str", errorMsg));
+                                }
                             }


Input:
private void doCommand(ScriptEntry scriptEntry) {
    String outcomeCommand = ((String) scriptEntry.getObject("String_Node_Str")).toUpperCase();
    String[] outcomeArgs = Arrays.copyOf((Object[]) scriptEntry.getObject("String_Node_Str"), ((Object[]) scriptEntry.getObject("String_Node_Str")).length, String[].class);
    try {
        denizen.getScriptEngine().getScriptExecuter().execute(new ScriptEntry(outcomeCommand, outcomeArgs, scriptEntry.getPlayer(), scriptEntry.getNPC(), scriptEntry.getScript().getName(), scriptEntry.getStep()));
    } catch (ScriptEntryCreationException e) {
        dB.echoError("String_Node_Str");
        if (dB.showStackTraces) {
            dB.echoDebug("String_Node_Str");
            e.printStackTrace();
        } else
            dB.echoDebug("String_Node_Str");
    }
}

Output:
     try {
-        denizen.getScriptEngine().getScriptExecuter().execute(new ScriptEntry(outcomeCommand, outcomeArgs, scriptEntry.getPlayer(), scriptEntry.getNPC(), scriptEntry.getScript().getName(), scriptEntry.getStep()));
+        denizen.getScriptEngine().getScriptExecuter().execute(new ScriptEntry(outcomeCommand, outcomeArgs, scriptEntry.getPlayer(), scriptEntry.getNPC(), scriptEntry.getScript().getName(), scriptEntry.getStep()).addObject("String_Node_Str", scriptEntry.getObject("String_Node_Str")));
     } catch (ScriptEntryCreationException e) {


Input:
public void handleEvent(ListenableListEvent event) {
    if (event.type == TYPE.ADDED) {
        EList<TreeNode> nodes = selectedInputTree.getNodes();
        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.addedObjects;
        if (event.index != null) {
            int index = event.index;
            for (IMetadataColumn column : metadataColumns) {
                TreeNode createTreeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                createTreeNode.setName(column.getLabel());
                createTreeNode.setType(column.getTalendType());
                createTreeNode.setNullable(column.isNullable());
                createTreeNode.setPattern(column.getPattern());
                createTreeNode.setXpath(XmlMapUtil.getXPath(selectedInputTree.getName(), createTreeNode.getName(), createTreeNode.getNodeType()));
                selectedInputTree.getNodes().add(index, createTreeNode);
                index = index + 1;
            }
        }
    } else if (event.type == TYPE.REMOVED) {
        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.removedObjects;
        List treeNodeToRemove = new ArrayList();
        for (IMetadataColumn column : metadataColumns) {
            for (TreeNode node : selectedInputTree.getNodes()) {
                if (node.getName() != null && node.getName().equals(column.getLabel())) {
                    XmlMapUtil.detachNodeConnections(node, copyOfMapData, true);
                    treeNodeToRemove.add(node);
                }
            }
        }
        selectedInputTree.getNodes().removeAll(treeNodeToRemove);
        if (selectedInputTree == mainInputTree && mainInputTree.isMultiLoops()) {
            selectedInputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedInputTree));
            List<TreeNode> oldLoops = new ArrayList<TreeNode>();
            XmlMapUtil.getChildLoops(oldLoops, treeNodeToRemove, false);
            if (!oldLoops.isEmpty()) {
                XmlMapUtil.removeloopInOutputTree(MapperManager.this, oldLoops);
            }
        }
    } else if (event.type == TYPE.SWAPED) {
        List<Integer> listIndexTarget = event.indicesTarget;
        List<Integer> listIndexOrignal = event.indicesOrigin;
        for (int i = 0; i < listIndexOrignal.size(); i++) {
            int orignal = listIndexOrignal.get(i);
            int target = listIndexTarget.get(i);
            if (orignal < selectedInputTree.getNodes().size()) {
                TreeNode tempTreeNode = selectedInputTree.getNodes().get(orignal);
                selectedInputTree.getNodes().remove(orignal);
                selectedInputTree.getNodes().add(target, tempTreeNode);
            }
        }
    } else if (event.type == TYPE.REPLACED) {
        List added = (List) event.addedObjects;
        List removed = (List) event.removedObjects;
        boolean needCheckOutput = false;
        List<TreeNode> oldLoops = new ArrayList<TreeNode>();
        if (selectedInputTree == mainInputTree && mainInputTree.isMultiLoops()) {
            needCheckOutput = true;
        }
        List<IMetadataColumn> removedColumn = new ArrayList<IMetadataColumn>();
        List<IMetadataColumn> addedColumn = new ArrayList<IMetadataColumn>();
        if (!added.isEmpty()) {
            addedColumn.addAll((List<IMetadataColumn>) added.get(0));
        }
        if (!removed.isEmpty()) {
            removedColumn.addAll((List<IMetadataColumn>) removed.get(0));
        }
        Map<IMetadataColumn, TreeNode> nodeMap = new HashMap<IMetadataColumn, TreeNode>();
        for (int i = 0; i < removedColumn.size(); i++) {
            IMetadataColumn column = removedColumn.get(i);
            TreeNode node = selectedInputTree.getNodes().get(i);
            boolean found = false;
            for (IMetadataColumn columnAdded : addedColumn) {
                if (column.sameMetacolumnAs(columnAdded)) {
                    nodeMap.put(columnAdded, node);
                    found = true;
                    break;
                }
            }
            if (!found) {
                XmlMapUtil.detachNodeConnections(node, copyOfMapData, true);
                if (needCheckOutput) {
                    XmlMapUtil.getChildLoops(oldLoops, node.getChildren(), false);
                }
            }
        }
        selectedInputTree.getNodes().clear();
        for (IMetadataColumn column : addedColumn) {
            TreeNode treeNode = nodeMap.get(column);
            if (treeNode == null) {
                treeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                treeNode.setName(column.getLabel());
                treeNode.setType(column.getTalendType());
                treeNode.setNullable(column.isNullable());
                treeNode.setPattern(column.getPattern());
                treeNode.setXpath(XmlMapUtil.getXPath(selectedInputTree.getName(), treeNode.getName(), treeNode.getNodeType()));
                if (XmlMapUtil.DOCUMENT.equals(column.getTalendType())) {
                    TreeNode createTreeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                    createTreeNode.setName("String_Node_Str");
                    createTreeNode.setType(XmlMapUtil.DEFAULT_DATA_TYPE);
                    createTreeNode.setNodeType(NodeType.ELEMENT);
                    createTreeNode.setXpath(XmlMapUtil.getXPath(treeNode.getXpath(), createTreeNode.getName(), createTreeNode.getNodeType()));
                    createTreeNode.setLoop(true);
                    createTreeNode.setMain(true);
                    treeNode.getChildren().add(createTreeNode);
                }
            }
            selectedInputTree.getNodes().add(treeNode);
        }
        selectedInputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedInputTree));
        if (!oldLoops.isEmpty()) {
            XmlMapUtil.removeloopInOutputTree(MapperManager.this, oldLoops);
        }
        mapperUI.updateStatusBar();
    }
}

Output:
             List<TreeNode> oldLoops = new ArrayList<TreeNode>();
-            XmlMapUtil.getChildLoops(oldLoops, treeNodeToRemove, false);
+            XmlMapUtil.getChildLoops(oldLoops, treeNodeToRemove);
             if (!oldLoops.isEmpty()) {


Input:
public synchronized ReplicaInputStreams getTmpInputStreams(ExtendedBlock b, long blkOffset, long ckoff) throws IOException {
    ReplicaInfo info = getReplicaInfo(b);
    File blockFile = info.getBlockFile();
    RandomAccessFile blockInFile = new RandomAccessFile(blockFile, "String_Node_Str");
    if (blkOffset > 0) {
        blockInFile.seek(blkOffset);
    }
    File metaFile = info.getMetaFile();
    RandomAccessFile metaInFile = new RandomAccessFile(metaFile, "String_Node_Str");
    if (ckoff > 0) {
        metaInFile.seek(ckoff);
    }
    return new ReplicaInputStreams(new FileInputStream(blockInFile.getFD()), new FileInputStream(metaInFile.getFD()));
}

Output:
     }
-    return new ReplicaInputStreams(new FileInputStream(blockInFile.getFD()), new FileInputStream(metaInFile.getFD()));
+    return new ReplicaInputStreams(blockInFile.getFD(), metaInFile.getFD());
 }


Input:
public void setRegionStatePeristenceEnabled(boolean enabled) {
    if (enabled) {
        MonitoringStatus.getInstanceForApplication(mContext).startStatusPreservation();
    } else {
        MonitoringStatus.getInstanceForApplication(mContext).stopStatusPreservation();
    }
}

Output:
 public void setRegionStatePeristenceEnabled(boolean enabled) {
-    if (enabled) {
-        MonitoringStatus.getInstanceForApplication(mContext).startStatusPreservation();
-    } else {
-        MonitoringStatus.getInstanceForApplication(mContext).stopStatusPreservation();
-    }
+    setRegionStatePersistenceEnabled(enabled);
 }


Input:
private JobDescription prepareJob() throws Exception {
    MethodImplementation method = (MethodImplementation) this.impl;
    TaskParams taskParams = this.taskParams;
    String methodName = method.getAlternativeMethodName();
    String targetPath = getResourceNode().getInstallDir();
    String targetHost = getResourceNode().getHost();
    String targetUser = getResourceNode().getUser();
    if (userNeeded && !targetUser.isEmpty()) {
        targetUser += "String_Node_Str";
    } else {
        targetUser = "String_Node_Str";
    }
    SoftwareDescription sd = new SoftwareDescription();
    sd.setExecutable(targetPath + WORKER_SCRIPT_PATH + WORKER_SCRIPT_NAME);
    ArrayList<String> lArgs = new ArrayList<String>();
    lArgs.add(lang);
    lArgs.add(getResourceNode().getWorkingDir());
    lArgs.add(getResourceNode().getLibPath());
    LinkedList<LogicalData> obsoleteFiles = getResource().clearObsoletes();
    if (obsoleteFiles != null) {
        lArgs.add("String_Node_Str" + obsoleteFiles.size());
        for (LogicalData ld : obsoleteFiles) {
            String renaming = ld.getName();
            lArgs.add(renaming);
        }
    } else {
        lArgs.add("String_Node_Str");
    }
    lArgs.add(Boolean.toString(Tracer.isActivated()));
    lArgs.add(getHostName());
    if (debug) {
        logger.debug("String_Node_Str" + getHostName());
    }
    if (Tracer.isActivated()) {
        lArgs.add(String.valueOf(Tracer.getTaskEventsType()));
        lArgs.add(String.valueOf(this.taskParams.getId() + 1));
        int slot = Tracer.getNextSlot(targetHost);
        lArgs.add(String.valueOf(slot));
        sd.addAttribute("String_Node_Str", slot);
    }
    lArgs.add(getResourceNode().getAppDir());
    lArgs.add(getClasspath());
    lArgs.add(getPythonpath());
    lArgs.add(String.valueOf(debug));
    lArgs.add(STORAGE_CONF);
    lArgs.add(method.getDeclaringClass());
    lArgs.add(methodName);
    lArgs.add(Boolean.toString(taskParams.hasTargetObject()));
    int numParams = taskParams.getParameters().length;
    if (taskParams.hasReturnValue()) {
        numParams--;
    }
    lArgs.add(Integer.toString(numParams));
    for (Parameter param : taskParams.getParameters()) {
        DataType type = param.getType();
        lArgs.add(Integer.toString(type.ordinal()));
        switch(type) {
            case FILE_T:
                DependencyParameter dFilePar = (DependencyParameter) param;
                lArgs.add(dFilePar.getDataTarget());
                break;
            case PSCO_T:
                logger.error("String_Node_Str");
                listener.jobFailed(this, JobEndStatus.SUBMISSION_FAILED);
                break;
            case OBJECT_T:
                DependencyParameter dPar = (DependencyParameter) param;
                DataAccessId dAccId = dPar.getDataAccessId();
                lArgs.add(dPar.getDataTarget());
                if (dAccId instanceof RAccessId) {
                    lArgs.add("String_Node_Str");
                } else {
                    lArgs.add("String_Node_Str");
                }
                break;
            case STRING_T:
                BasicTypeParameter btParS = (BasicTypeParameter) param;
                String value = btParS.getValue().toString();
                int numSubStrings = value.split("String_Node_Str").length;
                lArgs.add(Integer.toString(numSubStrings));
                lArgs.add(value);
                break;
            default:
                BasicTypeParameter btParB = (BasicTypeParameter) param;
                lArgs.add(btParB.getValue().toString());
                break;
        }
    }
    String[] arguments = new String[lArgs.size()];
    arguments = lArgs.toArray(arguments);
    try {
        sd.setArguments(arguments);
    } catch (NullPointerException e) {
        StringBuilder sb = new StringBuilder("String_Node_Str" + this.jobId + "String_Node_Str" + methodName + "String_Node_Str" + method.getDeclaringClass() + "String_Node_Str");
        int i = 0;
        for (Parameter param : taskParams.getParameters()) {
            sb.append("String_Node_Str").append(i).append("String_Node_Str");
            DataType type = param.getType();
            sb.append("String_Node_Str").append(param.getType()).append("String_Node_Str");
            if (type == DataType.FILE_T || type == DataType.OBJECT_T) {
                DependencyParameter dPar = (DependencyParameter) param;
                DataAccessId dAccId = dPar.getDataAccessId();
                sb.append("String_Node_Str").append(dPar.getDataTarget()).append("String_Node_Str");
                if (type == DataType.OBJECT_T) {
                    if (dAccId instanceof RAccessId) {
                        sb.append("String_Node_Str" + "String_Node_Str").append("String_Node_Str");
                    } else {
                        sb.append("String_Node_Str" + "String_Node_Str").append("String_Node_Str");
                    }
                }
            } else if (type == DataType.STRING_T) {
                BasicTypeParameter btParS = (BasicTypeParameter) param;
                String value = btParS.getValue().toString();
                int numSubStrings = value.split("String_Node_Str").length;
                sb.append("String_Node_Str" + Integer.toString(numSubStrings)).append("String_Node_Str");
                sb.append("String_Node_Str" + value).append("String_Node_Str");
            } else {
                BasicTypeParameter btParB = (BasicTypeParameter) param;
                sb.append("String_Node_Str" + btParB.getValue().toString()).append("String_Node_Str");
            }
            i++;
        }
        logger.error(sb.toString());
        listener.jobFailed(this, JobEndStatus.SUBMISSION_FAILED);
    }
    sd.addAttribute("String_Node_Str", jobId);
    sd.addAttribute(SoftwareDescription.WALLTIME_MAX, method.getRequirements().getWallClockLimit());
    if (method.getRequirements().getHostQueues().size() > 0) {
        sd.addAttribute(SoftwareDescription.JOB_QUEUE, method.getRequirements().getHostQueues().get(0));
    }
    sd.addAttribute("String_Node_Str", method.getRequirements().getTotalComputingUnits());
    sd.addAttribute(SoftwareDescription.MEMORY_MAX, method.getRequirements().getMemorySize());
    sd.addAttribute(SoftwareDescription.SANDBOX_ROOT, getResourceNode().getWorkingDir());
    sd.addAttribute(SoftwareDescription.SANDBOX_USEROOT, "String_Node_Str");
    sd.addAttribute(SoftwareDescription.SANDBOX_DELETE, "String_Node_Str");
    if (debug) {
        File outFile = GAT.createFile(context, Protocol.ANY_URI + File.separator + JOBS_DIR + "String_Node_Str" + jobId + "String_Node_Str" + this.getHistory() + "String_Node_Str");
        sd.setStdout(outFile);
    }
    if (debug || usingGlobus) {
        File errFile = GAT.createFile(context, Protocol.ANY_URI + File.separator + JOBS_DIR + "String_Node_Str" + jobId + "String_Node_Str" + this.getHistory() + "String_Node_Str");
        sd.setStderr(errFile);
    }
    Map<String, Object> attributes = new HashMap<String, Object>();
    attributes.put(RES_ATTR, Protocol.ANY_URI + targetUser + targetHost);
    attributes.put("String_Node_Str", "String_Node_Str" + jobId);
    ResourceDescription rd = new HardwareResourceDescription(attributes);
    if (debug) {
        logger.debug("String_Node_Str" + jobId + "String_Node_Str");
        logger.debug("String_Node_Str" + targetHost);
        logger.debug("String_Node_Str" + sd.getExecutable());
        StringBuilder sb = new StringBuilder("String_Node_Str");
        for (String arg : sd.getArguments()) {
            sb.append("String_Node_Str").append(arg);
        }
        logger.debug(sb.toString());
    }
    JobDescription jd = new JobDescription(sd, rd);
    return jd;
}

Output:
     MethodImplementation method = (MethodImplementation) this.impl;
-    TaskParams taskParams = this.taskParams;
+    TaskDescription taskParams = this.taskParams;
     String methodName = method.getAlternativeMethodName();


Input:
public boolean execute(ExecutionContext executionContext) throws ProcessExecutionException, InterruptedException {
    try {
        MultiMassArgs args = (MultiMassArgs) this.getProcessArgs();
        List<File> statsFiles = new ArrayList<File>();
        List<SingleMassArgs> singleMassArgsList = createSingleMassArgsList(args);
        for (SingleMassArgs singleMassArgs : singleMassArgsList) {
            if (!singleMassArgs.getOutputDir().mkdirs()) {
                throw new IOException("String_Node_Str");
            }
            statsFiles.add(singleMassArgs.getStatsFile());
            this.conanProcessService.execute(new SingleMassProcess(singleMassArgs), executionContext);
        }
        if (executionContext.usingScheduler() && !executionContext.isForegroundJob()) {
            this.conanProcessService.waitFor(executionContext.getScheduler().createWaitCondition(ExitStatus.Type.COMPLETED_SUCCESS, args.getJobPrefix() + "String_Node_Str"), executionContext);
        }
        executeMassSelector(args, statsFiles, executionContext);
    } catch (IOException ioe) {
        throw new ProcessExecutionException(-1, ioe);
    }
    return true;
}

Output:
             statsFiles.add(singleMassArgs.getStatsFile());
-            this.conanProcessService.execute(new SingleMassProcess(singleMassArgs), executionContext);
+            SingleMassProcess singleMassProcess = new SingleMassProcess(singleMassArgs);
+            singleMassProcess.setConanProcessService(this.getConanProcessService());
+            singleMassProcess.execute(executionContext);
         }


Input:
public void testDockerBuilderAddFileInSubfolder() throws DockerException, IOException {
    File baseDir = new File(Thread.currentThread().getContextClassLoader().getResource("String_Node_Str").getFile());
    dockerfileBuild(baseDir, "String_Node_Str");
}

Output:
     File baseDir = new File(Thread.currentThread().getContextClassLoader().getResource("String_Node_Str").getFile());
-    dockerfileBuild(baseDir, "String_Node_Str");
+    String response = dockerfileBuild(baseDir);
+    assertThat(response, containsString("String_Node_Str"));
 }


Input:
private void maybeUpdateUsageStatsLocked(ProcessRecord app) {
    if (DEBUG_USAGE_STATS) {
        Slog.d(TAG, "String_Node_Str" + Arrays.toString(app.getPackageList()) + "String_Node_Str" + app.setProcState + "String_Node_Str" + app.curProcState);
    }
    if (mUsageStatsService == null) {
        return;
    }
    boolean isInteraction;
    if (!mSleeping) {
        isInteraction = app.curProcState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
        app.fgInteractionTime = 0;
    } else {
        if (app.curProcState <= ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
            isInteraction = true;
            app.fgInteractionTime = 0;
        } else if (app.curProcState <= ActivityManager.PROCESS_STATE_TOP_SLEEPING) {
            final long now = SystemClock.elapsedRealtime();
            if (app.fgInteractionTime == 0) {
                app.fgInteractionTime = now;
                isInteraction = false;
            } else {
                isInteraction = now > app.fgInteractionTime + SERVICE_USAGE_INTERACTION_TIME;
            }
        } else {
            isInteraction = app.curProcState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
            app.fgInteractionTime = 0;
        }
    }
    if (isInteraction && !app.reportedInteraction) {
        String[] packages = app.getPackageList();
        if (packages != null) {
            for (int i = 0; i < packages.length; i++) {
                mUsageStatsService.reportEvent(packages[i], app.userId, UsageEvents.Event.SYSTEM_INTERACTION);
            }
        }
    }
    app.reportedInteraction = isInteraction;
}

Output:
     boolean isInteraction;
-    if (!mSleeping) {
-        isInteraction = app.curProcState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
+    if (app.curProcState <= ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
+        isInteraction = true;
         app.fgInteractionTime = 0;


Input:
protected List<CtType<?>> obtainClassesFromScope(ProgramVariant variant) {
    if (IngredientSpaceScope.PACKAGE.equals(scope)) {
        return variant.getAffectedClasses();
    }
    if (IngredientSpaceScope.LOCAL.equals(scope)) {
        return variant.getAffectedClasses();
    }
    if (IngredientSpaceScope.GLOBAL.equals(scope)) {
        return MutationSupporter.getFactory().Type().getAll();
    }
    return null;
}

Output:
     if (IngredientSpaceScope.PACKAGE.equals(scope)) {
-        return variant.getAffectedClasses();
+        List<CtType<?>> affected = variant.getAffectedClasses();
+        List<CtType<?>> types = new ArrayList<>();
+        List<CtPackage> packageAnalyzed = new ArrayList<>();
+        for (CtType<?> ing : affected) {
+            CtPackage p = ing.getParent(CtPackage.class);
+            if (!packageAnalyzed.contains(p)) {
+                packageAnalyzed.add(p);
+                for (CtType<?> type : p.getTypes()) {
+                    types.add(type);
+                }
+            }
+        }
+        return types;
     }


Input:
public void visitExtendedItem(ExtendedItemDesign item) {
    ExtendedItemHandle handle = (ExtendedItemHandle) item.getHandle();
    String tagName = handle.getExtensionName();
    IReportItemQuery itemQuery = ExtensionManager.getInstance().createQueryItem(tagName);
    IBaseQueryDefinition[] queries = null;
    IBaseQueryDefinition parentQuery = getParentQuery();
    if (itemQuery != null) {
        try {
            itemQuery.setModelObject(handle);
            queries = itemQuery.getReportQueries(parentQuery);
        } catch (BirtException ex) {
            logger.log(Level.WARNING, ex.getMessage(), ex);
        }
        if (queries != null) {
            item.setQueries(queries);
            for (int i = 0; i < queries.length; i++) {
                if (queries[i] != null) {
                    this.queries.add(queries[i]);
                }
            }
            if (queries.length > 0) {
                IBaseQueryDefinition query = queries[0];
                if (query != null) {
                    item.setQuery(query);
                    pushQuery(query);
                    pushExpressions(query.getRowExpressions());
                    handleReportItemExpressions(item);
                    popExpressions();
                    popQuery();
                }
            }
        }
    }
}

Output:
             for (int i = 0; i < queries.length; i++) {
-                if (queries[i] != null) {
+                if (queries[i] != null && queries[i] instanceof IQueryDefinition) {
                     this.queries.add(queries[i]);


Input:
private static <T extends IsIndexed> void openReferred(final T object, Filter filter) {
    BrowserService.Util.getInstance().find(IndexedDIP.class.getName(), filter, DEFAULT_DIPFILE_SORTER, new Sublist(0, 1), Facets.NONE, LocaleInfo.getCurrentLocale().getLocaleName(), true, Arrays.asList(RodaConstants.DIP_ID), new AsyncCallback<IndexResult<IndexedDIP>>() {

        public void onFailure(Throwable caught) {
            AsyncCallbackUtils.defaultFailureTreatment(caught);
        }
        public void onSuccess(IndexResult<IndexedDIP> result) {
            if (result.getTotalCount() > 0) {
                HistoryUtils.openBrowse(result.getResults().get(0));
            } else {
                HistoryUtils.resolve(object);
            }
        }
    });
}

Output:
 private static <T extends IsIndexed> void openReferred(final T object, Filter filter) {
-    BrowserService.Util.getInstance().find(IndexedDIP.class.getName(), filter, DEFAULT_DIPFILE_SORTER, new Sublist(0, 1), Facets.NONE, LocaleInfo.getCurrentLocale().getLocaleName(), true, Arrays.asList(RodaConstants.DIP_ID), new AsyncCallback<IndexResult<IndexedDIP>>() {
+    BrowserService.Util.getInstance().find(IndexedDIP.class.getName(), filter, DEFAULT_DIPFILE_SORTER, new Sublist(0, 1), Facets.NONE, LocaleInfo.getCurrentLocale().getLocaleName(), true, Arrays.asList(RodaConstants.INDEX_UUID, RodaConstants.DIP_ID), new AsyncCallback<IndexResult<IndexedDIP>>() {


Input:
public String getDataSoFar() {
    Assert.isNotNull(this.dataSoFar);
    return this.dataSoFar;
}

Output:
 public String getDataSoFar() {
-    Assert.isNotNull(this.dataSoFar);
+    Assert.isNotNull(this.dataSoFar, "String_Node_Str");
     return this.dataSoFar;


Input:
public void clear() {
    synchronized (cacheMapDatabase) {
        cacheMapDatabase.clear();
    }
}

Output:
 public void clear() {
-    synchronized (cacheMapDatabase) {
+    synchronized (cacheMapLock) {
         cacheMapDatabase.clear();


Input:
public void shouldExecuteRaiseAnExceptionIfTheListOfSolutionsIsEmpty() {
    selection = new NaryTournamentSelection<Solution<?>>();
    population = new ArrayList<>(0);
    selection.execute(population);
}

Output:
 public void shouldExecuteRaiseAnExceptionIfTheListOfSolutionsIsEmpty() {
-    selection = new NaryTournamentSelection<Solution<?>>();
-    population = new ArrayList<>(0);
+    NaryTournamentSelection<IntegerSolution> selection = new NaryTournamentSelection<>();
+    List<IntegerSolution> population = new ArrayList<>(0);
     selection.execute(population);


Input:
public void onPlayerLeaveIsland(IslandExitEvent e) {
    if (DEBUG)
        plugin.getLogger().info("String_Node_Str");
    final Player player = plugin.getServer().getPlayer(e.getPlayer());
    if (!plugin.getGrid().locationIsOnIsland(player, e.getLocation())) {
        if (DEBUG)
            plugin.getLogger().info("String_Node_Str");
        if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && player.isFlying() && player.getGameMode().equals(GameMode.SURVIVAL)) {
            if (DEBUG)
                plugin.getLogger().info("String_Node_Str" + Settings.flyTimeOutside + "String_Node_Str");
            if (Settings.flyTimeOutside == 0) {
                player.setAllowFlight(false);
                player.setFlying(false);
                if (DEBUG)
                    plugin.getLogger().info("String_Node_Str");
            } else {
                plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
                    public void run() {
                        if (!plugin.getGrid().playerIsOnIsland(player) && player.isFlying()) {
                            player.setAllowFlight(false);
                            player.setFlying(false);
                            if (DEBUG)
                                plugin.getLogger().info("String_Node_Str");
                        }
                    }
                }, 20 * Settings.flyTimeOutside);
            }
        }
        for (String perm : Settings.temporaryPermissions) {
            if (temporaryPerms.containsKey(player.getUniqueId()) && VaultHelper.checkPerm(player, perm)) {
                VaultHelper.removePerm(player, perm);
                if (DEBUG)
                    plugin.getLogger().info("String_Node_Str" + perm);
                List<String> perms = temporaryPerms.get(player.getUniqueId());
                perms.remove(perm);
                if (perms.isEmpty())
                    temporaryPerms.remove(player.getUniqueId());
                else
                    temporaryPerms.put(player.getUniqueId(), perms);
            }
        }
    }
}

Output:
     final Player player = plugin.getServer().getPlayer(e.getPlayer());
-    if (!plugin.getGrid().locationIsOnIsland(player, e.getLocation())) {
-        if (DEBUG)
-            plugin.getLogger().info("String_Node_Str");
-        if (VaultHelper.checkPerm(player, Settings.PERMPREFIX + "String_Node_Str") && player.isFlying() && player.getGameMode().equals(GameMode.SURVIVAL)) {
-            if (DEBUG)
-                plugin.getLogger().info("String_Node_Str" + Settings.flyTimeOutside + "String_Node_Str");
-            if (Settings.flyTimeOutside == 0) {
-                player.setAllowFlight(false);
-                player.setFlying(false);
-                if (DEBUG)
-                    plugin.getLogger().info("String_Node_Str");
-            } else {
-                plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
-                    public void run() {
-                        if (!plugin.getGrid().playerIsOnIsland(player) && player.isFlying()) {
-                            player.setAllowFlight(false);
-                            player.setFlying(false);
-                            if (DEBUG)
-                                plugin.getLogger().info("String_Node_Str");
-                        }
-                    }
-                }, 20 * Settings.flyTimeOutside);
-            }
-        }
-        for (String perm : Settings.temporaryPermissions) {
-            if (temporaryPerms.containsKey(player.getUniqueId()) && VaultHelper.checkPerm(player, perm)) {
-                VaultHelper.removePerm(player, perm);
-                if (DEBUG)
-                    plugin.getLogger().info("String_Node_Str" + perm);
-                List<String> perms = temporaryPerms.get(player.getUniqueId());
-                perms.remove(perm);
-                if (perms.isEmpty())
-                    temporaryPerms.remove(player.getUniqueId());
-                else
-                    temporaryPerms.put(player.getUniqueId(), perms);
-            }
-        }
+    if (DEBUG) {
+        plugin.getLogger().info("String_Node_Str" + e.getLocation());
+        plugin.getLogger().info("String_Node_Str" + player.getLocation());
     }


Input:
private RDSaveUtil getRdSaveUtil() {
    if (this.rdSaveUtil == null) {
        rdSaveUtil = new RDSaveUtil(context, queryDefn, queryResults.getID());
    }
    return this.rdSaveUtil;
}

Output:
     if (this.rdSaveUtil == null) {
-        rdSaveUtil = new RDSaveUtil(context, queryDefn, queryResults.getID());
+        rdSaveUtil = new RDSaveUtil(session.getEngineContext(), queryDefn, queryResults.getID());
     }


Input:
public Association hasMany(String name) {
    Association assoc = new Association(relations, name, false, true);
    relations.put(name, assoc);
    return assoc;
}

Output:
 public Association hasMany(String name) {
-    Association assoc = new Association(relations, name, false, true);
-    relations.put(name, assoc);
-    return assoc;
+    return assoc(name, false, true);
 }


Input:
public void testIVWithIncrementSorts() throws Exception {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    hier2.createLevel("String_Node_Str");
    cqd.createMeasure("String_Node_Str");
    IBinding binding1 = new Binding("String_Node_Str");
    binding1.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding1);
    IBinding binding2 = new Binding("String_Node_Str");
    binding2.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding2);
    IBinding binding3 = new Binding("String_Node_Str");
    binding3.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding3);
    IBinding binding4 = new Binding("String_Node_Str");
    binding4.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding4);
    IBinding binding5 = new Binding("String_Node_Str");
    binding5.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding5);
    FileArchiveWriter writter = new FileArchiveWriter(documentPath + "String_Node_Str");
    DataEngineContext context = DataEngineContext.newInstance(DataEngineContext.MODE_GENERATION, null, null, writter);
    context.setTmpdir(this.getTempDir());
    DataEngineImpl engine = (DataEngineImpl) DataEngine.newDataEngine(context);
    this.createCube(writter, engine);
    IPreparedCubeQuery pcq = engine.prepare(cqd, null);
    ICubeQueryResults queryResults = pcq.execute(null);
    CubeCursor cursor = queryResults.getCubeCursor();
    writter.flush();
    writter.finish();
    engine.shutdown();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    FileArchiveReader reader = new FileArchiveReader(documentPath + "String_Node_Str");
    ArchiveWriter writer = new ArchiveWriter(new ArchiveFile(documentPath + "String_Node_Str", "String_Node_Str"));
    ICubeQueryDefinition savedQuery = CubeQueryDefinitionIOUtil.load(queryResults.getID(), reader);
    engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.MODE_UPDATE, null, reader, writer));
    cqd.setQueryResultsID(queryResults.getID());
    CubeSortDefinition csd = new CubeSortDefinition();
    csd.setSortDirection(ISortDefinition.SORT_DESC);
    csd.setExpression(new ScriptExpression("String_Node_Str"));
    csd.setTargetLevel(dim2.getHierarchy().get(0).getLevels().get(0));
    cqd.addSort(csd);
    IncrementExecutionHint ieh = CubeQueryDefinitionUtil.getIncrementExecutionHint(savedQuery, cqd);
    assertTrue(ieh != null);
    assertEquals(0, ieh.getBindings().length);
    assertEquals(0, ieh.getFilters().length);
    assertEquals(1, ieh.getSorts().length);
    pcq = engine.prepare(cqd, null);
    queryResults = pcq.execute(null);
    cursor = queryResults.getCubeCursor();
    reader.close();
    writer.finish();
    engine.shutdown();
    reader = new FileArchiveReader(documentPath + "String_Node_Str");
    engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.MODE_PRESENTATION, null, reader, null));
    cqd.setQueryResultsID(queryResults.getID());
    pcq = engine.prepare(cqd, null);
    queryResults = pcq.execute(null);
    cursor = queryResults.getCubeCursor();
    this.printCube(cursor, columnEdgeBindingNames, "String_Node_Str", "String_Node_Str");
    reader.close();
    engine.shutdown();
}

Output:
     ArchiveWriter writer = new ArchiveWriter(new ArchiveFile(documentPath + "String_Node_Str", "String_Node_Str"));
-    ICubeQueryDefinition savedQuery = CubeQueryDefinitionIOUtil.load(queryResults.getID(), reader);
+    ICubeQueryDefinition savedQuery = CubeQueryDefinitionIOUtil.load(queryResults.getID(), DataEngineContext.newInstance(DataEngineContext.MODE_UPDATE, null, reader, writer));
     engine = (DataEngineImpl) DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.MODE_UPDATE, null, reader, writer));


Input:
public StructureSpawnContext generate() {
    StructureSpawnContext context = spawn();
    StructureInfo<S> structureInfo = structure();
    String structureID = structureID();
    boolean firstTime = context.isFirstTime();
    WorldServer world = context.environment.world;
    int[] sizeInts = sizeInts(context.boundingBox);
    int[] coordInts = coordInts(context.boundingBox);
    if (maturity() != StructureSpawnContext.GenerateMaturity.SUGGEST || (context.boundingBox.minY >= MIN_DIST_TO_LIMIT && context.boundingBox.maxY <= world.getHeight() - 1 - MIN_DIST_TO_LIMIT && (!RCConfig.avoidOverlappingGeneration || !memorize || StructureGenerationData.get(world).getEntriesAt(context.boundingBox).size() == 0) && !RCEventBus.INSTANCE.post(new StructureGenerationEvent.Suggest(structureInfo, context)) && !MinecraftForge.EVENT_BUS.post(new StructureGenerationEventLite.Suggest(world, structureID, coordInts, sizeInts, context.generationLayer)))) {
        if (firstTime) {
            RCEventBus.INSTANCE.post(new StructureGenerationEvent.Pre(structureInfo, context));
            MinecraftForge.EVENT_BUS.post(new StructureGenerationEventLite.Pre(world, structureID, coordInts, sizeInts, context.generationLayer));
        }
        boolean success = structureInfo.generate(context, instanceData());
        if (firstTime && success) {
            RecurrentComplex.logger.trace(String.format("String_Node_Str", name(structureID), context.boundingBox));
            RCEventBus.INSTANCE.post(new StructureGenerationEvent.Post(structureInfo, context));
            MinecraftForge.EVENT_BUS.post(new StructureGenerationEventLite.Post(world, structureID, coordInts, sizeInts, context.generationLayer));
            if (structureID != null && memorize)
                StructureGenerationData.get(world).addCompleteEntry(structureID, generationInfo.id(), context.lowerCoord(), context.transform);
        }
        return success ? context : null;
    } else
        RecurrentComplex.logger.trace(String.format("String_Node_Str", structureID, context.boundingBox));
    return null;
}

Output:
             if (structureID != null && memorize)
-                StructureGenerationData.get(world).addCompleteEntry(structureID, generationInfo.id(), context.lowerCoord(), context.transform);
+                StructureGenerationData.get(world).addCompleteEntry(structureID, generationInfo != null ? generationInfo.id() : null, context.lowerCoord(), context.transform);
         }