Input:
public int calculateRelevance() {
    String commonPrefix = getCommonPrefix(subwordsMatchingRegion.toLowerCase(), prefix.toLowerCase());
    int score = commonPrefix.length() > 0 ? 200 + commonPrefix.length() : 0;
    int relevance = jdtProposal.getRelevance() + score + bestSubsequenceScore;
    return relevance;
}

Output:
     String commonPrefix = getCommonPrefix(subwordsMatchingRegion.toLowerCase(), prefix.toLowerCase());
-    int score = commonPrefix.length() > 0 ? 200 + commonPrefix.length() : 0;
+    int score = 0;
+    if (commonPrefix.length() == prefix.length()) {
+        score += 200;
+    }
     int relevance = jdtProposal.getRelevance() + score + bestSubsequenceScore;


Input:
public void testAddTestCaseResultUntested() {
    Assume.assumeTrue(TestIntegrationSuite.destructiveTestsOk);
    Assume.assumeTrue(TestIntegrationSuite.testInstance != null);
    TestResult result = new TestResult();
    result.setTestId(TestIntegrationSuite.testInstance.getId());
    result.setVerdict("String_Node_Str");
    result.setAssignedtoId(TestIntegrationSuite.assignedToId);
    result.setComment("String_Node_Str");
    try {
        TestIntegrationSuite.getService().addTestResult(TestIntegrationSuite.testInstance.getId(), result);
    } catch (IOException e) {
        Assert.fail("String_Node_Str" + e);
    }
}

Output:
     result.setComment("String_Node_Str");
-    try {
-        TestIntegrationSuite.getService().addTestResult(TestIntegrationSuite.testInstance.getId(), result);
-    } catch (IOException e) {
-        Assert.fail("String_Node_Str" + e);
+    TestResult returnedResult = TestIntegrationSuite.getService().addTestResult(TestIntegrationSuite.testInstance.getId(), result);
+    if (returnedResult == null) {
+        Assert.fail("String_Node_Str");
     }


Input:
private Set getTypesForContext(Context context) {
    XMLReflectionReader spec = (XMLReflectionReader) userSpec;
    if (spec != null && context instanceof CallerSiteContext) {
        CallerSiteContext site = (CallerSiteContext) context;
        MemberReference m = site.getCaller().getMethod().getReference();
        ReflectionSummary summary = spec.getSummary(m);
        if (summary != null) {
            Set types = summary.getTypesForProgramLocation(site.getSite().getProgramCounter());
            if (types != null) {
                return types;
            }
        }
    }
    Set types = map.get(context);
    return types;
}

Output:
         if (summary != null) {
-            Set types = summary.getTypesForProgramLocation(site.getSite().getProgramCounter());
+            Set types = summary.getTypesForProgramLocation(site.getCallSite().getProgramCounter());
             if (types != null) {


Input:
private void setHeader(ObaRouteResponse routeInfo, boolean addToDb) {
    mRouteInfo = routeInfo;
    if (routeInfo.getCode() == ObaApi.OBA_OK) {
        TextView text1 = (TextView) findViewById(R.id.short_name);
        TextView text2 = (TextView) findViewById(R.id.long_name);
        TextView agencyText = (TextView) findViewById(R.id.agency);
        String url = mRouteInfo.getUrl();
        final String shortName = routeInfo.getShortName();
        final String longName = routeInfo.getLongName();
        if (!TextUtils.isEmpty(shortName)) {
            text1.setText(shortName);
            text2.setText(longName);
        } else {
            text1.setText(longName);
            text2.setText("String_Node_Str");
        }
        agencyText.setText(mRouteInfo.getAgency().getName());
        if (addToDb) {
            ContentValues values = new ContentValues();
            values.put(ObaContract.Routes.SHORTNAME, shortName);
            values.put(ObaContract.Routes.LONGNAME, longName);
            values.put(ObaContract.Routes.URL, url);
            ObaContract.Routes.insertOrUpdate(this, mRouteInfo.getId(), values, true);
        }
    } else {
        mEmptyText.setText(UIHelp.getRouteErrorString(routeInfo.getCode()));
    }
    mRouteInfoTask = null;
}

Output:
     if (routeInfo.getCode() == ObaApi.OBA_OK) {
-        TextView text1 = (TextView) findViewById(R.id.short_name);
-        TextView text2 = (TextView) findViewById(R.id.long_name);
+        TextView shortNameText = (TextView) findViewById(R.id.short_name);
+        TextView longNameText = (TextView) findViewById(R.id.long_name);
         TextView agencyText = (TextView) findViewById(R.id.agency);


Input:
protected void onDialogClosed(boolean positiveResult) {
    super.onDialogClosed(positiveResult);
    if (positiveResult) {
        setEnabled(false);
        Context context = getContext();
        if (BrowserSettings.PREF_CLEAR_CACHE.equals(getKey())) {
            BrowserSettings.getInstance().clearCache(context);
            BrowserSettings.getInstance().clearDatabases(context);
        } else if (BrowserSettings.PREF_CLEAR_COOKIES.equals(getKey())) {
            BrowserSettings.getInstance().clearCookies(context);
        } else if (BrowserSettings.PREF_CLEAR_HISTORY.equals(getKey())) {
            BrowserSettings.getInstance().clearHistory(context);
        } else if (BrowserSettings.PREF_CLEAR_FORM_DATA.equals(getKey())) {
            BrowserSettings.getInstance().clearFormData(context);
        } else if (BrowserSettings.PREF_CLEAR_PASSWORDS.equals(getKey())) {
            BrowserSettings.getInstance().clearPasswords(context);
        } else if (BrowserSettings.PREF_EXTRAS_RESET_DEFAULTS.equals(getKey())) {
            BrowserSettings.getInstance().resetDefaultPreferences(context);
            setEnabled(true);
        } else if (BrowserSettings.PREF_CLEAR_LOCATION_ACCESS.equals(getKey())) {
            BrowserSettings.getInstance().clearLocationAccess(context);
        }
    }
}

Output:
             setEnabled(true);
-        } else if (BrowserSettings.PREF_CLEAR_LOCATION_ACCESS.equals(getKey())) {
+        } else if (BrowserSettings.PREF_CLEAR_GEOLOCATION_ACCESS.equals(getKey())) {
             BrowserSettings.getInstance().clearLocationAccess(context);


Input:
public void exportSpecifiedResources() throws InterruptedException {
    for (ExportFileResource fileResource : resourcesListToExport) {
        String rootName = fileResource.getDirectoryName();
        Set<String> paths = fileResource.getRelativePathList();
        for (Iterator iter = paths.iterator(); iter.hasNext(); ) {
            String relativePath = (String) iter.next();
            Set<URL> resource = fileResource.getResourcesByRelativePath(relativePath);
            for (URL url : resource) {
                String currentResource = url.getPath();
                exportResource(rootName, relativePath, currentResource, 1);
            }
        }
    }
}

Output:
         Set<String> paths = fileResource.getRelativePathList();
-        for (Iterator iter = paths.iterator(); iter.hasNext(); ) {
-            String relativePath = (String) iter.next();
+        for (Object element : paths) {
+            String relativePath = (String) element;
             Set<URL> resource = fileResource.getResourcesByRelativePath(relativePath);


Input:
private void processConfirmEditCollection(Context context, HttpServletRequest request, HttpServletResponse response, Community community, Collection collection) throws ServletException, IOException, SQLException, AuthorizeException {
    if (request.getParameter("String_Node_Str").equals("String_Node_Str")) {
        collection = community.createCollection();
        request.setAttribute("String_Node_Str", collection);
    }
    collection.setMetadata("String_Node_Str", request.getParameter("String_Node_Str"));
    collection.setMetadata("String_Node_Str", request.getParameter("String_Node_Str"));
    String intro = request.getParameter("String_Node_Str");
    if (intro.equals("String_Node_Str")) {
        intro = null;
    }
    String copy = request.getParameter("String_Node_Str");
    if (copy.equals("String_Node_Str")) {
        copy = null;
    }
    String side = request.getParameter("String_Node_Str");
    if (side.equals("String_Node_Str")) {
        side = null;
    }
    String license = request.getParameter("String_Node_Str");
    if (license.equals("String_Node_Str")) {
        license = null;
    }
    String provenance = request.getParameter("String_Node_Str");
    if (provenance.equals("String_Node_Str")) {
        provenance = null;
    }
    collection.setMetadata("String_Node_Str", intro);
    collection.setMetadata("String_Node_Str", copy);
    collection.setMetadata("String_Node_Str", side);
    collection.setMetadata("String_Node_Str", license);
    collection.setMetadata("String_Node_Str", license);
    String button = UIUtil.getSubmitButton(request, "String_Node_Str");
    if (button.equals("String_Node_Str")) {
        collection.setLogo(null);
        JSPManager.showJSP(request, response, "String_Node_Str");
    } else if (button.equals("String_Node_Str")) {
        collection.setLogo(null);
        JSPManager.showJSP(request, response, "String_Node_Str");
    } else if (button.startsWith("String_Node_Str")) {
        int step = Integer.parseInt(button.substring(17));
        Group newGroup = Group.create(context);
        newGroup.setName("String_Node_Str" + collection.getID() + "String_Node_Str" + step);
        newGroup.update();
        collection.setWorkflowGroup(step, newGroup);
        collection.update();
        response.sendRedirect(response.encodeRedirectURL(request.getContextPath() + "String_Node_Str" + newGroup.getID()));
    } else if (button.startsWith("String_Node_Str")) {
        int step = Integer.parseInt(button.substring(15));
        Group g = collection.getWorkflowGroup(step);
        response.sendRedirect(response.encodeRedirectURL(request.getContextPath() + "String_Node_Str" + g.getID()));
    } else if (button.startsWith("String_Node_Str")) {
        int step = Integer.parseInt(button.substring(17));
        Group g = collection.getWorkflowGroup(step);
        collection.setWorkflowGroup(step, null);
        collection.update();
        g.delete();
        JSPManager.showJSP(request, response, "String_Node_Str");
    } else if (button.equals("String_Node_Str")) {
        collection.createTemplateItem();
        Item i = collection.getTemplateItem();
        response.sendRedirect(response.encodeRedirectURL(request.getContextPath() + "String_Node_Str" + i.getID()));
    } else if (button.equals("String_Node_Str")) {
        Item i = collection.getTemplateItem();
        response.sendRedirect(response.encodeRedirectURL(request.getContextPath() + "String_Node_Str" + i.getID()));
    } else if (button.equals("String_Node_Str")) {
        collection.removeTemplateItem();
        JSPManager.showJSP(request, response, "String_Node_Str");
    } else {
        showControls(context, request, response);
    }
    collection.update();
    context.complete();
}

Output:
     collection.setMetadata("String_Node_Str", license);
-    collection.setMetadata("String_Node_Str", license);
+    collection.setMetadata("String_Node_Str", provenance);
     String button = UIUtil.getSubmitButton(request, "String_Node_Str");


Input:
public static org.hl7.fhir.dstu2016may.model.Conformance convertConformance(org.hl7.fhir.dstu3.model.Conformance src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.Conformance tgt = new org.hl7.fhir.dstu2016may.model.Conformance();
    copyDomainResource(src, tgt);
    tgt.setUrl(src.getUrl());
    tgt.setVersion(src.getVersion());
    tgt.setName(src.getName());
    tgt.setStatus(convertConformanceResourceStatus(src.getStatus()));
    tgt.setExperimental(src.getExperimental());
    tgt.setDate(src.getDate());
    tgt.setPublisher(src.getPublisher());
    for (org.hl7.fhir.dstu3.model.Conformance.ConformanceContactComponent t : src.getContact()) tgt.addContact(convertConformanceContactComponent(t));
    tgt.setDescription(src.getDescription());
    for (org.hl7.fhir.dstu3.model.CodeableConcept t : src.getUseContext()) tgt.addUseContext(convertCodeableConcept(t));
    tgt.setRequirements(src.getRequirements());
    tgt.setCopyright(src.getCopyright());
    tgt.setKind(convertConformanceStatementKind(src.getKind()));
    tgt.setSoftware(convertConformanceSoftwareComponent(src.getSoftware()));
    tgt.setImplementation(convertConformanceImplementationComponent(src.getImplementation()));
    tgt.setFhirVersion(src.getFhirVersion());
    tgt.setAcceptUnknown(convertUnknownContentCode(src.getAcceptUnknown()));
    for (org.hl7.fhir.dstu3.model.CodeType t : src.getFormat()) tgt.addFormat(t.getValue());
    for (org.hl7.fhir.dstu3.model.Reference t : src.getProfile()) tgt.addProfile(convertReference(t));
    for (org.hl7.fhir.dstu3.model.Conformance.ConformanceRestComponent t : src.getRest()) tgt.addRest(convertConformanceRestComponent(t));
    for (org.hl7.fhir.dstu3.model.Conformance.ConformanceMessagingComponent t : src.getMessaging()) tgt.addMessaging(convertConformanceMessagingComponent(t));
    for (org.hl7.fhir.dstu3.model.Conformance.ConformanceDocumentComponent t : src.getDocument()) tgt.addDocument(convertConformanceDocumentComponent(t));
    return tgt;
}

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


Input:
public TransactionManager getTransactionManager() {
    if (testTransactionManager != null)
        return testTransactionManager;
    if (transactionManager == null) {
        try {
            transactionManager = (TransactionManager) new InitialContext().lookup("String_Node_Str");
        } catch (NamingException e) {
            e.printStackTrace();
        }
    }
    return transactionManager;
}

Output:
         try {
-            transactionManager = (TransactionManager) new InitialContext().lookup("String_Node_Str");
+            synchronized (TransactionalInterceptorBase.class) {
+                if (transactionManager == null)
+                    transactionManager = (TransactionManager) new InitialContext().lookup("String_Node_Str");
+            }
         } catch (NamingException e) {


Input:
public byte[][] imageTransferInitiate(GXDLMSClient client, String imageIdentifier, long imageSize) {
    if (ImageBlockSize == 0) {
        throw new RuntimeException("String_Node_Str");
    }
    ByteArrayOutputStream data = new ByteArrayOutputStream();
    data.write((byte) DataType.STRUCTURE.getValue());
    data.write(2);
    try {
        GXCommon.setData(data, DataType.OCTET_STRING, imageIdentifier.getBytes("String_Node_Str"));
        GXCommon.setData(data, DataType.UINT32, imageSize);
    } catch (Exception ex) {
        throw new RuntimeException(ex.getMessage());
    }
    return client.method(this, 1, data.toByteArray(), DataType.ARRAY);
}

Output:
     try {
-        GXCommon.setData(data, DataType.OCTET_STRING, imageIdentifier.getBytes("String_Node_Str"));
+        GXCommon.setData(data, DataType.OCTET_STRING, GXCommon.getBytes(imageIdentifier));
         GXCommon.setData(data, DataType.UINT32, imageSize);


Input:
public static void print() {
    final long c = count.get();
    if (c == 0)
        return;
    String status = MessageFormat.format("String_Node_Str", c, (durations.get() / c), registered.get(), daemonThreadCount(), (elapse.get() / c));
    System.out.println(status);
}

Output:
     String status = MessageFormat.format("String_Node_Str", c, (durations.get() / c), registered.get(), daemonThreadCount(), (elapse.get() / c));
-    System.out.println(status);
+    println(status);
 }


Input:
public String getReferenceText() {
    CSharpNamespaceDeclStub stub = getGreenStub();
    if (stub != null) {
        return stub.getReferenceTextRef();
    }
    CSharpReferenceExpression childByClass = findChildByClass(CSharpReferenceExpression.class);
    return childByClass != null ? StringUtil.strip(childByClass.getText(), CharFilter.NOT_WHITESPACE_FILTER) : null;
}

Output:
     CSharpReferenceExpression childByClass = findChildByClass(CSharpReferenceExpression.class);
-    return childByClass != null ? StringUtil.strip(childByClass.getText(), CharFilter.NOT_WHITESPACE_FILTER) : null;
+    return childByClass != null ? StringUtil.strip(childByClass.getText(), CSharpReferenceExpression.DEFAULT_REF_FILTER) : null;
 }


Input:
public void clearTopicIndex() {
    if (!useTopicIndex)
        return;
    synchronized (indexLock) {
        topicIndex = new HashMap<Locator, LayeredTopic>();
    }
}

Output:
     synchronized (indexLock) {
-        topicIndex = new HashMap<Locator, LayeredTopic>();
+        topicIndex = new LinkedHashMap<Locator, LayeredTopic>();
     }


Input:
private void findConrefDependencies(BoundedObjectSet bos, XmlBosMember member, Set<BosMember> newMembers) throws Exception {
    NodeList conrefs;
    try {
        conrefs = (NodeList) DitaUtil.allConrefs.evaluate(member.getElement(), XPathConstants.NODESET);
    } catch (XPathExpressionException e) {
        throw new BosException("String_Node_Str" + DitaUtil.allTopicrefs);
    }
    for (int i = 0; i < conrefs.getLength(); i++) {
        Element conref = (Element) conrefs.item(i);
        Document targetDoc = null;
        String href = null;
        try {
            if (conref.hasAttribute("String_Node_Str")) {
                targetDoc = resolveKeyrefToDoc(conref.getAttribute("String_Node_Str"));
            }
            if (targetDoc == null && conref.hasAttribute("String_Node_Str")) {
                href = conref.getAttribute("String_Node_Str");
                if (!href.startsWith("String_Node_Str"))
                    targetDoc = AddressingUtil.resolveHrefToDoc(conref, href, bosConstructionOptions, this.failOnAddressResolutionFailure);
            }
        } catch (AddressingException e) {
            if (this.failOnAddressResolutionFailure) {
                throw new BosException("String_Node_Str" + conref.getAttribute("String_Node_Str") + "String_Node_Str", e);
            }
        }
        if (targetDoc != null && targetDoc != member.getDocument()) {
            BosMember childMember = bos.constructBosMember(member, targetDoc);
            newMembers.add(childMember);
            if (href != null) {
                member.registerDependency(href, childMember, Constants.CONREF_DEPENDENCY);
            }
        }
    }
}

Output:
             if (href != null) {
-                member.registerDependency(href, childMember, Constants.CONREF_DEPENDENCY);
+                bos.addMemberAsDependency(href, Constants.CONREF_DEPENDENCY, member, childMember);
+            } else {
+                bos.addMember(childMember);
             }


Input:
public String getTopNQuery(String query, int n) {
    Matcher m = SELECT_PATTERN.matcher(query);
    return m.replaceFirst("String_Node_Str" + n + "String_Node_Str");
}

Output:
     Matcher m = SELECT_PATTERN.matcher(query);
-    return m.replaceFirst("String_Node_Str" + n + "String_Node_Str");
+    return m.replaceFirst("String_Node_Str" + n + PluginConstant.SPACE_STRING);
 }


Input:
public void embeddedCollectionTest() {
    entityManager.getTransaction().begin();
    Hike hike = new Hike("String_Node_Str", "String_Node_Str");
    hike.sections.add(new Section("String_Node_Str", "String_Node_Str"));
    hike.sections.add(new Section("String_Node_Str", "String_Node_Str"));
    entityManager.persist(hike);
    entityManager.getTransaction().commit();
    entityManager.getTransaction().begin();
    hike = entityManager.find(Hike.class, hike.id);
    assertThat(hike.sections).hasSize(2);
    assertThat(hike.sections.get(0).from).isEqualTo("String_Node_Str");
    assertThat(hike.sections.get(1).from).isEqualTo("String_Node_Str");
    entityManager.getTransaction().commit();
}

Output:
     entityManager.persist(hike);
-    entityManager.getTransaction().commit();
-    entityManager.getTransaction().begin();
+    entityManager.flush();
+    entityManager.clear();
     hike = entityManager.find(Hike.class, hike.id);


Input:
public void listSubscribedCartridgeInfo(final boolean full, String alias) throws CommandException {
    DefaultHttpClient httpClient = new DefaultHttpClient();
    try {
        HttpResponse response = restClientService.doGet(httpClient, restClientService.getUrl() + listSubscribedCartridgeInfoRestEndpoint + "String_Node_Str" + alias, restClientService.getUsername(), restClientService.getPassword());
        String responseCode = "String_Node_Str" + response.getStatusLine().getStatusCode();
        if (!responseCode.equals(CliConstants.RESPONSE_OK)) {
            System.out.println("String_Node_Str");
            return;
        }
        String resultString = getHttpResponseString(response);
        GsonBuilder gsonBuilder = new GsonBuilder();
        Gson gson = gsonBuilder.create();
        Cartridge cartridge = gson.fromJson(resultString, Cartridge.class);
        if (cartridge == null) {
            System.out.println("String_Node_Str");
            return;
        }
        final Set<String> lbIpList = getLbIpList(cartridge, httpClient);
        Cartridge[] cartridges = new Cartridge[1];
        cartridges[0] = cartridge;
        RowMapper<Cartridge> cartridgeMapper = new RowMapper<Cartridge>() {
            public String[] getData(Cartridge cartridge) {
                String[] data = full ? new String[10] : new String[7];
                data[0] = cartridge.getCartridgeType();
                data[1] = cartridge.getDisplayName();
                data[2] = cartridge.getVersion();
                data[3] = cartridge.isMultiTenant() ? "String_Node_Str" : "String_Node_Str";
                data[4] = cartridge.getCartridgeAlias();
                data[5] = cartridge.getStatus();
                data[6] = cartridge.isMultiTenant() ? "String_Node_Str" : String.valueOf(cartridge.getActiveInstances());
                if (full) {
                    data[7] = getAccessURLs(cartridge);
                    data[8] = cartridge.getRepoURL() != null ? cartridge.getRepoURL() : "String_Node_Str";
                }
                data[9] = lbIpList.toString();
                return data;
            }
        };
        List<String> headers = new ArrayList<String>();
        headers.add("String_Node_Str");
        headers.add("String_Node_Str");
        headers.add("String_Node_Str");
        headers.add("String_Node_Str");
        headers.add("String_Node_Str");
        headers.add("String_Node_Str");
        headers.add("String_Node_Str");
        if (full) {
            headers.add("String_Node_Str");
            headers.add("String_Node_Str");
        }
        headers.add("String_Node_Str");
        System.out.println("String_Node_Str");
        CommandLineUtils.printTable(cartridges, cartridgeMapper, headers.toArray(new String[headers.size()]));
        System.out.println();
    } catch (Exception e) {
        handleException("String_Node_Str", e);
    } finally {
        httpClient.getConnectionManager().shutdown();
    }
}

Output:
     try {
-        HttpResponse response = restClientService.doGet(httpClient, restClientService.getUrl() + listSubscribedCartridgeInfoRestEndpoint + "String_Node_Str" + alias, restClientService.getUsername(), restClientService.getPassword());
+        HttpResponse response = restClientService.doGet(httpClient, restClientService.getUrl() + listSubscribedCartridgeInfoRestEndpoint + alias, restClientService.getUsername(), restClientService.getPassword());
         String responseCode = "String_Node_Str" + response.getStatusLine().getStatusCode();


Input:
public void testBackupPutWhenOwnerNodeDead() throws InterruptedException {
    final TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
    final String name = MAP_NAME;
    final HazelcastInstance hz = nodeFactory.newHazelcastInstance();
    final HazelcastInstance hz2 = nodeFactory.newHazelcastInstance();
    final IMap<Object, Object> map = hz2.getMap(name);
    final int size = 100000;
    final byte[] data = new byte[250];
    final int threads = 100;
    final int l = size / threads;
    final CountDownLatch latch = new CountDownLatch(threads);
    ExecutorService ex = Executors.newFixedThreadPool(threads);
    new Thread() {
        public void run() {
            while (hz.getMap(name).size() < size / 2) {
                try {
                    sleep(5);
                } catch (InterruptedException ignored) {
                    return;
                }
            }
            TestUtil.terminateInstance(hz);
        }
    }.start();
    for (int i = 0; i < threads; i++) {
        final int n = i;
        ex.execute(new Runnable() {
            public void run() {
                for (int j = (n * l); j < (n + 1) * l; j++) {
                    map.put(j, data);
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException ignored) {
                        return;
                    }
                }
                latch.countDown();
            }
        });
    }
    try {
        assertTrue(latch.await(5, TimeUnit.MINUTES));
        assertEquals("String_Node_Str", size, map.size());
    } finally {
        ex.shutdownNow();
    }
}

Output:
     final HazelcastInstance hz2 = nodeFactory.newHazelcastInstance();
-    final IMap<Object, Object> map = hz2.getMap(name);
+    final IMap<Integer, byte[]> map = hz2.getMap(name);
     final int size = 100000;


Input:
public String publicTenantIdPart(String tenantId) throws Exception {
    if (tenantId == null || tenantId.isEmpty()) {
        throw new Exception(String.format("String_Node_Str", tenantId));
    }
    return "String_Node_Str" + "String_Node_Str" + sanitize(tenantId) + "String_Node_Str";
}

Output:
     if (tenantId == null || tenantId.isEmpty()) {
-        throw new Exception(String.format("String_Node_Str", tenantId));
+        throw new IllegalArgumentException(String.format("String_Node_Str", tenantId));
     }


Input:
private void setupSyncopeConf() {
    WebMarkupContainer parameters = new WebMarkupContainer("String_Node_Str");
    add(parameters);
    MetaDataRoleAuthorizationStrategy.authorize(parameters, ENABLE, xmlRolesReader.getAllAllowedRoles("String_Node_Str", "String_Node_Str"));
    final ConfTO conf = confRestClient.list();
    for (Iterator<AttributeTO> it = conf.getAttrs().iterator(); it.hasNext(); ) {
        AttributeTO attr = it.next();
        for (LayoutType type : LayoutType.values()) {
            if (type.getParameter().equals(attr.getSchema())) {
                it.remove();
            }
        }
    }
    final Form<?> form = new Form<Void>("String_Node_Str");
    form.setModel(new CompoundPropertyModel(conf));
    parameters.add(form);
    form.add(new AttributesPanel("String_Node_Str", conf, form, Mode.ADMIN));
    IndicatingAjaxLink<Void> save = new IndicatingAjaxLink<Void>("String_Node_Str") {
        private static final long serialVersionUID = -7978723352517770644L;
        public void onClick(final AjaxRequestTarget target) {
            final ConfTO updatedConf = (ConfTO) form.getModelObject();
            try {
                for (AttributeTO attr : updatedConf.getAttrs()) {
                    if (attr.getValues().isEmpty() || attr.getValues().equals(Collections.singletonList(StringUtils.EMPTY))) {
                        confRestClient.delete(attr.getSchema());
                    } else {
                        confRestClient.set(attr);
                    }
                }
                info(getString(Constants.OPERATION_SUCCEEDED));
                feedbackPanel.refresh(target);
            } catch (Exception e) {
                LOG.error("String_Node_Str", e);
                error(getString(Constants.ERROR) + "String_Node_Str" + e.getMessage());
                feedbackPanel.refresh(target);
            }
        }
    };
    MetaDataRoleAuthorizationStrategy.authorize(save, ENABLE, xmlRolesReader.getAllAllowedRoles("String_Node_Str", "String_Node_Str"));
    form.add(save);
    Link<Void> dbExportLink = new Link<Void>("String_Node_Str") {
        private static final long serialVersionUID = -4331619903296515985L;
        public void onClick() {
            try {
                HttpResourceStream stream = new HttpResourceStream(confRestClient.dbExport());
                ResourceStreamRequestHandler rsrh = new ResourceStreamRequestHandler(stream);
                rsrh.setFileName(stream.getFilename() == null ? "String_Node_Str" : stream.getFilename());
                rsrh.setContentDisposition(ContentDisposition.ATTACHMENT);
                getRequestCycle().scheduleRequestHandlerAfterCurrent(rsrh);
            } catch (Exception e) {
                error(getString(Constants.ERROR) + "String_Node_Str" + e.getMessage());
            }
        }
    };
    MetaDataRoleAuthorizationStrategy.authorize(dbExportLink, ENABLE, xmlRolesReader.getAllAllowedRoles("String_Node_Str", "String_Node_Str"));
    add(dbExportLink);
}

Output:
         AttributeTO attr = it.next();
-        for (LayoutType type : LayoutType.values()) {
-            if (type.getParameter().equals(attr.getSchema())) {
+        for (AttrLayoutType type : AttrLayoutType.values()) {
+            if (type.getConfKey().equals(attr.getSchema())) {
                 it.remove();


Input:
public void createCube(String name, String[][] factTableJointColumnNames, String[][] DimJointColumnNames, IDimension[] dimensions, IDatasetIterator factTable, String[] measureColumns, String[] measureAggrFunctionNames, long cacheSize, StopSign stopSign) throws IOException, BirtException {
    if (dimensions.length == 0) {
        throw new DataException(ResourceConstants.MISSING_DIMENSION_IN_CUBE, name);
    }
    Cube cube = new Cube(name, documentManager);
    cube.create(factTableJointColumnNames, DimJointColumnNames, dimensions, factTable, measureColumns, measureAggrFunctionNames, cacheSize, stopSign);
    cube.close();
    documentManager.flush();
}

Output:
     Cube cube = new Cube(name, documentManager);
-    cube.create(factTableJointColumnNames, DimJointColumnNames, dimensions, factTable, measureColumns, measureAggrFunctionNames, cacheSize, stopSign);
+    cube.create(factTableJointColumnNames, DimJointColumnNames, dimensions, factTable, measureColumns, calculatedMeasure, measureAggrFunctionNames, cacheSize, stopSign);
     cube.close();


Input:
public void receiveTxBroadcast() throws Exception {
    peerGroup.startAndWait();
    peerGroup.addWallet(wallet);
    FakeChannel p1 = connectPeer(1);
    FakeChannel p2 = connectPeer(2);
    assertEquals(2, peerGroup.numConnectedPeers());
    Set<Peer> tmp = new HashSet<Peer>(peerGroup.getConnectedPeers());
    Set<Peer> expectedPeers = new HashSet<Peer>();
    expectedPeers.add(peerOf(p1));
    expectedPeers.add(peerOf(p2));
    assertEquals(tmp, expectedPeers);
    BigInteger value = Utils.toNanoCoins(1, 0);
    Transaction t1 = TestUtils.createFakeTx(unitTestParams, value, address);
    InventoryMessage inv = new InventoryMessage(unitTestParams);
    inv.addTransaction(t1);
    inbound(p1, inv);
    assertTrue(outbound(p1) instanceof BloomFilter);
    assertTrue(outbound(p1) instanceof GetDataMessage);
    inbound(p2, inv);
    assertTrue(outbound(p2) instanceof BloomFilter);
    assertNull(outbound(p2));
    inbound(p1, t1);
    assertNull(outbound(p2));
    GetDataMessage getdata = (GetDataMessage) outbound(p1);
    inbound(p1, new NotFoundMessage(unitTestParams, getdata.getItems()));
    assertEquals(value, wallet.getBalance(Wallet.BalanceType.ESTIMATED));
    peerGroup.stop();
}

Output:
     assertEquals(value, wallet.getBalance(Wallet.BalanceType.ESTIMATED));
-    peerGroup.stop();
+    peerGroup.stopAndWait();
 }


Input:
private static DmvCkyParserPrm getDmvCkyParserPrm(boolean usePredArgSupervision) {
    CkyPcfgParserPrm ckyPrm = new CkyPcfgParserPrm();
    ckyPrm.loopOrder = LoopOrder.LEFT_CHILD;
    ckyPrm.parseType = ParseType.VITERBI;
    ckyPrm.cacheChart = true;
    if (usePredArgSupervision) {
        ckyPrm.cellType = ChartCellType.CONSTRAINED_FULL;
    } else {
        ckyPrm.cellType = ChartCellType.FULL;
    }
    DmvCkyParserPrm prm = new DmvCkyParserPrm();
    prm.objPrm = getDmvObjectivePrm();
    prm.ckyPrm = ckyPrm;
    return prm;
}

Output:
     } else {
-        ckyPrm.cellType = ChartCellType.FULL;
+        ckyPrm.cellType = ChartCellType.FULL_BREAK_TIES;
     }


Input:
public void testSortWithComparator() {
    Comparator x = new Comparator() {
        public int compare(Object o1, Object o2) {
            String s1 = (String) o1;
            String s2 = (String) o2;
            return s2.compareTo(s1);
        }
    };
    List a = createSortedList();
    Collections.sort(a, x);
    Object[] expected = { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    assertEquals(expected, a);
}

Output:
     };
-    List a = createSortedList();
+    List<String> a = createSortedList();
     Collections.sort(a, x);


Input:
public void invokeAsync() {
    if (n > threshold) {
        int nSubTasks = 1 + n / threshold;
        subTasks = new ArrayList<>(nSubTasks);
        int taskSize = n / nSubTasks;
        int soFar = 0;
        for (int i = 0; i < nSubTasks; i++) {
            int nInTask;
            if (i == nSubTasks - 1) {
                nInTask = n - soFar;
            } else {
                nInTask = taskSize;
            }
            int offsetXNew = offsetX + soFar * incrX;
            int offsetYNew = offsetY + soFar * incrY;
            Task<Pair<Double, Integer>> t = new CPUIndexAccumulationTask(op, threshold, nInTask, offsetXNew, offsetYNew, incrX, incrY, soFar, false);
            t.invokeAsync();
            subTasks.add(t);
            soFar += nInTask;
        }
    } else {
        future = TaskExecutorProvider.getTaskExecutor().executeAsync(this);
    }
}

Output:
             int offsetYNew = offsetY + soFar * incrY;
-            Task<Pair<Double, Integer>> t = new CPUIndexAccumulationTask(op, threshold, nInTask, offsetXNew, offsetYNew, incrX, incrY, soFar, false);
+            Task<Pair<Double, Integer>> t = new CPUIndexAccumulationTask(op, threshold, nInTask, offsetXNew, offsetYNew, incrX, incrY, elementOffset + soFar, false);
             t.invokeAsync();


Input:
public void computeLegend(ChartData<?> data) {
    List<String> labels = new ArrayList<String>();
    List<Integer> colors = new ArrayList<Integer>();
    for (int i = 0; i < data.getDataSetCount(); i++) {
        DataSet<? extends Entry> dataSet = data.getDataSetByIndex(i);
        List<Integer> clrs = dataSet.getColors();
        int entryCount = dataSet.getEntryCount();
        if (dataSet instanceof BarDataSet && ((BarDataSet) dataSet).getStackSize() > 1) {
            BarDataSet bds = (BarDataSet) dataSet;
            String[] sLabels = bds.getStackLabels();
            for (int j = 0; j < clrs.size() && j < bds.getStackSize(); j++) {
                labels.add(sLabels[j % sLabels.length]);
                colors.add(clrs.get(j));
            }
            colors.add(-2);
            labels.add(bds.getLabel());
        } else if (dataSet instanceof PieDataSet) {
            List<String> xVals = data.getXVals();
            PieDataSet pds = (PieDataSet) dataSet;
            for (int j = 0; j < clrs.size() && j < entryCount && j < xVals.size(); j++) {
                labels.add(xVals.get(j));
                colors.add(clrs.get(j));
            }
            colors.add(-2);
            labels.add(pds.getLabel());
        } else {
            for (int j = 0; j < clrs.size() && j < entryCount; j++) {
                if (j < clrs.size() - 1 && j < entryCount - 1) {
                    labels.add(null);
                } else {
                    String label = data.getDataSetByIndex(i).getLabel();
                    labels.add(label);
                }
                colors.add(clrs.get(j));
            }
        }
    }
    mLegend.setColors(colors);
    mLegend.setLabels(labels);
    Typeface tf = mLegend.getTypeface();
    if (tf != null)
        mLegendLabelPaint.setTypeface(tf);
    mLegendLabelPaint.setTextSize(mLegend.getTextSize());
    mLegendLabelPaint.setColor(mLegend.getTextColor());
    mLegend.calculateDimensions(mLegendLabelPaint);
}

Output:
         int entryCount = dataSet.getEntryCount();
-        if (dataSet instanceof BarDataSet && ((BarDataSet) dataSet).getStackSize() > 1) {
+        if (dataSet instanceof BarDataSet && ((BarDataSet) dataSet).isStacked()) {
             BarDataSet bds = (BarDataSet) dataSet;


Input:
public void execute() {
    metadataChanges.clear();
    if (newSource != null) {
        INodeConnector connector = oldSource.getConnectorFromName(connectorName);
        if (connector != null) {
            connector.setCurLinkNbOutput(connector.getCurLinkNbOutput() - 1);
            connector = newSource.getConnectorFromName(connectorName);
            if (connector != null) {
                connector.setCurLinkNbOutput(connector.getCurLinkNbOutput() + 1);
            }
        }
        if (connection.getLineStyle().hasConnectionCategory(IConnectionCategory.FLOW)) {
            newSourceSchemaType = (String) newSource.getPropertyValue(EParameterName.SCHEMA_TYPE.getName());
            boolean builtInNewSource = newSource.getConnectorFromName(connectorName).isMultiSchema();
            boolean builtInOldSource = oldSource.getConnectorFromName(connectorName).isMultiSchema();
            if ((!builtInNewSource) && (!builtInOldSource)) {
                setSchemaToNotBuiltInNode(oldSource, newSource, oldMetadataTable);
                connection.setMetaName(newSource.getUniqueName());
            } else {
                if (!builtInNewSource) {
                    int num = 0;
                    for (int i = 0; i < oldSource.getMetadataList().size(); i++) {
                        IMetadataTable meta = oldSource.getMetadataList().get(i);
                        if (meta.getTableName().equals(oldMetadataTable.getTableName())) {
                            num = i;
                        }
                    }
                    oldSource.getMetadataList().remove(num);
                    setSchemaToNotBuiltInNode(oldSource, newSource, oldMetadataTable);
                    connection.setMetaName(newSource.getUniqueName());
                }
                if (!builtInOldSource) {
                    IMetadataTable meta = oldMetadataTable.clone();
                    meta.setTableName(connection.getUniqueName());
                    newSource.getMetadataList().add(meta);
                    connection.setMetaName(meta.getTableName());
                }
                if ((builtInOldSource) && (builtInNewSource)) {
                    int num = 0;
                    for (int i = 0; i < oldSource.getMetadataList().size(); i++) {
                        IMetadataTable meta = oldSource.getMetadataList().get(i);
                        if (meta.getTableName().equals(oldMetadataTable.getTableName())) {
                            num = i;
                        }
                    }
                    oldSource.getMetadataList().remove(num);
                    newSource.getMetadataList().add(oldMetadataTable);
                }
            }
            if (newSourceSchemaType != null) {
                newSource.setPropertyValue(EParameterName.SCHEMA_TYPE.getName(), EmfComponent.BUILTIN);
            }
            if (oldSourceSchemaType != null) {
                oldSource.setPropertyValue(EParameterName.SCHEMA_TYPE.getName(), EmfComponent.BUILTIN);
            }
        } else {
            connection.setMetaName(newSource.getUniqueName());
        }
        connection.reconnect(newSource, oldTarget, newLineStyle);
        connection.updateName();
        if (newSourceSchemaType != null && connection.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA) && connector != null) {
            IMetadataTable sourceMetadataTable = newSource.getMetadataFromConnector(connector.getName());
            if (oldMetadataTable != null && sourceMetadataTable != null) {
                boolean sameFlag = oldMetadataTable.sameMetadataAs(sourceMetadataTable, IMetadataColumn.OPTIONS_NONE);
                if (!sameFlag && oldTarget.getComponent().isSchemaAutoPropagated() && (oldMetadataTable.getListColumns().isEmpty() || getPropagateDialog())) {
                    ChangeMetadataCommand changeMetadataCmd = new ChangeMetadataCommand(oldTarget, null, null, sourceMetadataTable);
                    changeMetadataCmd.execute(true);
                    metadataChanges.add(changeMetadataCmd);
                }
            }
        }
    } else if (newTarget != null) {
        newTargetSchemaType = (String) newTarget.getPropertyValue(EParameterName.SCHEMA_TYPE.getName());
        INodeConnector connector = oldTarget.getConnectorFromType(oldLineStyle);
        connector.setCurLinkNbInput(connector.getCurLinkNbInput() - 1);
        connector = newTarget.getConnectorFromType(newLineStyle);
        connector.setCurLinkNbInput(connector.getCurLinkNbInput() + 1);
        connection.reconnect(oldSource, newTarget, newLineStyle);
        connection.updateName();
        if (newTargetSchemaType != null) {
            if (connection.getLineStyle().hasConnectionCategory(IConnectionCategory.DATA) && !connection.getLineStyle().equals(EConnectionType.FLOW_REF)) {
                IMetadataTable targetOldMetadataTable = newTarget.getMetadataFromConnector(connector.getName());
                if (oldMetadataTable != null && targetOldMetadataTable != null) {
                    boolean sameFlag = oldMetadataTable.sameMetadataAs(targetOldMetadataTable, IMetadataColumn.OPTIONS_NONE);
                    if (!sameFlag && newTarget.getComponent().isSchemaAutoPropagated() && (targetOldMetadataTable.getListColumns().isEmpty() || getPropagateDialog())) {
                        ChangeMetadataCommand changeMetadataCmd = new ChangeMetadataCommand(newTarget, null, null, oldMetadataTable);
                        changeMetadataCmd.execute(true);
                        metadataChanges.add(changeMetadataCmd);
                    }
                }
            }
            newTarget.setPropertyValue(EParameterName.SCHEMA_TYPE.getName(), EmfComponent.BUILTIN);
        }
    } else {
        throw new IllegalStateException("String_Node_Str");
    }
}

Output:
                     boolean sameFlag = oldMetadataTable.sameMetadataAs(targetOldMetadataTable, IMetadataColumn.OPTIONS_NONE);
-                    if (!sameFlag && newTarget.getComponent().isSchemaAutoPropagated() && (targetOldMetadataTable.getListColumns().isEmpty() || getPropagateDialog())) {
-                        ChangeMetadataCommand changeMetadataCmd = new ChangeMetadataCommand(newTarget, null, null, oldMetadataTable);
-                        changeMetadataCmd.execute(true);
-                        metadataChanges.add(changeMetadataCmd);
+                    IProcess2 jobletProcess = (IProcess2) newTarget.getJobletNode().getComponent().getProcess();
+                    ERepositoryStatus status = ProxyRepositoryFactory.getInstance().getStatus(jobletProcess.getProperty().getItem());
+                    if (!status.equals(ERepositoryStatus.READ_ONLY)) {
+                        if (!sameFlag && newTarget.getComponent().isSchemaAutoPropagated() && (targetOldMetadataTable.getListColumns().isEmpty() || getPropagateDialog())) {
+                            ChangeMetadataCommand changeMetadataCmd = new ChangeMetadataCommand(newTarget, null, null, oldMetadataTable);
+                            changeMetadataCmd.execute(true);
+                            metadataChanges.add(changeMetadataCmd);
+                        }
                     }


Input:
public void initialize(Rect windowRect, Rect taskStackBounds, StackState state) {
    SystemServicesProxy ssp = Recents.getSystemServices();
    Rect lastStackRect = new Rect(mStackRect);
    Rect displayRect = ssp.getDisplayRect();
    int topMargin = getScaleForExtent(windowRect, displayRect, mBaseTopMargin, mMinMargin, HEIGHT);
    int bottomMargin = getScaleForExtent(windowRect, displayRect, mBaseBottomMargin, mMinMargin, HEIGHT);
    mInitialTopOffset = getScaleForExtent(windowRect, displayRect, mBaseInitialTopOffset, mMinMargin, HEIGHT);
    mInitialBottomOffset = mBaseInitialBottomOffset;
    mState = state;
    mStackBottomOffset = mSystemInsets.bottom + bottomMargin;
    state.computeRects(mFreeformRect, mStackRect, taskStackBounds, topMargin, mFreeformStackGap, mStackBottomOffset);
    mStackActionButtonRect.set(mStackRect.left, mStackRect.top - topMargin, mStackRect.right, mStackRect.top + mFocusedTopPeekHeight);
    float aspect = (float) (windowRect.width() - (mSystemInsets.left + mSystemInsets.right)) / (windowRect.height() - (mSystemInsets.top + mSystemInsets.bottom));
    int minHeight = mStackRect.height() - mInitialTopOffset - mStackBottomOffset;
    int height = (int) Math.min(mStackRect.width() / aspect, minHeight);
    mTaskRect.set(mStackRect.left, mStackRect.top, mStackRect.right, mStackRect.top + height);
    if (!lastStackRect.equals(mStackRect)) {
        mUnfocusedCurve = constructUnfocusedCurve();
        mUnfocusedCurveInterpolator = new FreePathInterpolator(mUnfocusedCurve);
        mFocusedCurve = constructFocusedCurve();
        mFocusedCurveInterpolator = new FreePathInterpolator(mFocusedCurve);
        mUnfocusedDimCurve = constructUnfocusedDimCurve();
        mUnfocusedDimCurveInterpolator = new FreePathInterpolator(mUnfocusedDimCurve);
        mFocusedDimCurve = constructFocusedDimCurve();
        mFocusedDimCurveInterpolator = new FreePathInterpolator(mFocusedDimCurve);
        updateFrontBackTransforms();
    }
}

Output:
     mStackActionButtonRect.set(mStackRect.left, mStackRect.top - topMargin, mStackRect.right, mStackRect.top + mFocusedTopPeekHeight);
-    float aspect = (float) (windowRect.width() - (mSystemInsets.left + mSystemInsets.right)) / (windowRect.height() - (mSystemInsets.top + mSystemInsets.bottom));
-    int minHeight = mStackRect.height() - mInitialTopOffset - mStackBottomOffset;
-    int height = (int) Math.min(mStackRect.width() / aspect, minHeight);
+    int height = mStackRect.height() - mInitialTopOffset - mStackBottomOffset;
     mTaskRect.set(mStackRect.left, mStackRect.top, mStackRect.right, mStackRect.top + height);


Input:
public static <T> T gmock(Class<T> classToMock) {
    return Mockito.mock(classToMock, new GroovyAnswer(Mockito.RETURNS_DEFAULTS));
}

Output:
 public static <T> T gmock(Class<T> classToMock) {
-    return Mockito.mock(classToMock, new GroovyAnswer(Mockito.RETURNS_DEFAULTS));
+    MockSettingsImpl mockSettings = (MockSettingsImpl) Mockito.withSettings().defaultAnswer(new GroovyAnswer(Mockito.RETURNS_DEFAULTS));
+    T mock = Mockito.mock(classToMock, mockSettings);
+    injectGroovyInterceptor((Factory) mock, mockSettings);
+    return mock;
 }


Input:
public ServiceOfferingVO createServiceOffering(long userId, String name, int cpu, int ramSize, int speed, String displayText, boolean localStorageRequired, boolean offerHA, boolean useVirtualNetwork, String tags, Long domainId) {
    String networkRateStr = _configDao.getValue("String_Node_Str");
    String multicastRateStr = _configDao.getValue("String_Node_Str");
    int networkRate = ((networkRateStr == null) ? 200 : Integer.parseInt(networkRateStr));
    int multicastRate = ((multicastRateStr == null) ? 10 : Integer.parseInt(multicastRateStr));
    NetworkOffering.GuestIpType guestIpType = useVirtualNetwork ? NetworkOffering.GuestIpType.Virtual : NetworkOffering.GuestIpType.Direct;
    tags = cleanupTags(tags);
    ServiceOfferingVO offering = new ServiceOfferingVO(name, cpu, ramSize, speed, networkRate, multicastRate, offerHA, displayText, guestIpType, localStorageRequired, false, tags, false, domainId);
    if ((offering = _serviceOfferingDao.persist(offering)) != null) {
        saveConfigurationEvent(userId, null, EventTypes.EVENT_SERVICE_OFFERING_CREATE, "String_Node_Str" + name + "String_Node_Str", "String_Node_Str" + offering.getId(), "String_Node_Str" + name, "String_Node_Str" + cpu, "String_Node_Str" + ramSize, "String_Node_Str" + speed, "String_Node_Str" + displayText, "String_Node_Str" + guestIpType, "String_Node_Str" + localStorageRequired, "String_Node_Str" + offerHA, "String_Node_Str" + useVirtualNetwork, "String_Node_Str" + tags);
        return offering;
    } else {
        return null;
    }
}

Output:
     int multicastRate = ((multicastRateStr == null) ? 10 : Integer.parseInt(multicastRateStr));
-    NetworkOffering.GuestIpType guestIpType = useVirtualNetwork ? NetworkOffering.GuestIpType.Virtual : NetworkOffering.GuestIpType.Direct;
+    Network.GuestIpType guestIpType = useVirtualNetwork ? Network.GuestIpType.Virtual : Network.GuestIpType.Direct;
     tags = cleanupTags(tags);


Input:
protected void createTableInfo(Composite parent) {
    Composite tableInfoComposite = new Composite(parent, SWT.NONE);
    tableInfoComposite.setLayout(new GridLayout(4, false));
    tableInfoComposite.setLayoutData(new GridData(SWT.RIGHT, SWT.FILL, false, true, 2, 1));
    tableInfoLabel = new Label(tableInfoComposite, SWT.NONE);
    GridData gd = new GridData(SWT.FILL, SWT.FILL, false, true);
    gd.widthHint = 100;
    tableInfoLabel.setLayoutData(gd);
    Label separator = new Label(tableInfoComposite, SWT.SEPARATOR | SWT.VERTICAL);
    GridData separatorGridData = new GridData(SWT.CENTER, SWT.CENTER, false, false);
    separatorGridData.heightHint = 16;
    separator.setLayoutData(separatorGridData);
    showAllColumnsButton = new Button(tableInfoComposite, SWT.CHECK);
    showAllColumnsButton.setSelection(false);
    showAllColumnsButton.setEnabled(false);
    showAllColumnsButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            showAllColumns = showAllColumnsButton.getSelection();
            previewTableManager.createDataPreviewTableFromDataMatrix(dataMatrix, showAllColumns ? totalNumberOfColumns : MAX_PREVIEW_TABLE_COLUMNS);
            selectedColumnButtons = previewTableManager.getSelectedColumnButtons();
            determineRowIDType();
            previewTableManager.updateTableColors(groupingParseSpecification.getNumberOfHeaderLines(), -1, groupingParseSpecification.getColumnOfRowIds() + 1);
            updateWidgetsAccordingToTableChanges();
            showAllColumnsButton.setSelection(showAllColumns);
        }
    });
    Label showAllColumnsLabel = new Label(tableInfoComposite, SWT.NONE);
    showAllColumnsLabel.setText("String_Node_Str");
}

Output:
     tableInfoLabel = new Label(tableInfoComposite, SWT.NONE);
-    GridData gd = new GridData(SWT.FILL, SWT.FILL, false, true);
-    gd.widthHint = 100;
-    tableInfoLabel.setLayoutData(gd);
+    tableInfoLabel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
     Label separator = new Label(tableInfoComposite, SWT.SEPARATOR | SWT.VERTICAL);


Input:
public boolean createDQStructure() {
    Shell shell = PlatformUI.getWorkbench().getDisplay().getActiveShell();
    try {
        IProject project = this.createNewProject(DATA_PROFILING, shell);
        this.createNewFoler(project, ANALYSIS);
        this.createNewFoler(project, REPORTS);
        project = this.createNewProject(LIBRARIES, shell);
        IFolder patternFolder = this.createNewFoler(project, PATTERNS);
        this.createNewFoler(project, SQL_PATTERNS);
        this.copyFilesToFolder(PATTERN_PATH, true, patternFolder);
        IFolder sqlSourceFolder = this.createNewFoler(project, SOURCE_FILES);
        this.copyFilesToFolder(DEMO_PATH, true, sqlSourceFolder);
        project = this.createNewProject(METADATA, shell);
        this.createNewFoler(project, DB_CONNECTIONS);
    } catch (Exception ex) {
        ExceptionHandler.process(ex);
        return false;
    }
    return true;
}

Output:
         IProject project = this.createNewProject(DATA_PROFILING, shell);
-        this.createNewFoler(project, ANALYSIS);
-        this.createNewFoler(project, REPORTS);
+        IFolder createNewFoler = this.createNewFoler(project, ANALYSIS);
+        createNewFoler.setPersistentProperty(FOLDER_CLASSIFY_KEY, ANALYSIS_FOLDER_PROPERTY);
+        createNewFoler = this.createNewFoler(project, REPORTS);
+        createNewFoler.setPersistentProperty(FOLDER_CLASSIFY_KEY, REPORT_FOLDER_PROPERTY);
         project = this.createNewProject(LIBRARIES, shell);


Input:
public Call createCall(String uri, String calleeResource, CallConference conference) throws OperationFailedException {
    CallJabberImpl call = new CallJabberImpl(jabberTelephony);
    if (conference != null)
        call.setConference(conference);
    String fullCalleeUri = (!StringUtils.isNullOrEmpty(calleeResource)) ? uri + "String_Node_Str" + calleeResource : uri;
    CallPeer callPeer = jabberTelephony.createOutgoingCall(call, uri, fullCalleeUri, null);
    if (callPeer == null) {
        throw new OperationFailedException("String_Node_Str" + "String_Node_Str", OperationFailedException.INTERNAL_ERROR);
    }
    Call callOfCallPeer = callPeer.getCall();
    if (callOfCallPeer == call)
        return call;
    else {
        if (conference != null)
            callOfCallPeer.setConference(conference);
        return callOfCallPeer;
    }
}

Output:
         call.setConference(conference);
-    String fullCalleeUri = (!StringUtils.isNullOrEmpty(calleeResource)) ? uri + "String_Node_Str" + calleeResource : uri;
+    String fullCalleeUri = StringUtils.isNullOrEmpty(calleeResource) ? uri : uri + "String_Node_Str" + calleeResource;
     CallPeer callPeer = jabberTelephony.createOutgoingCall(call, uri, fullCalleeUri, null);


Input:
public SerialMessage getNameMessage() {
    logger.debug("String_Node_Str", this.getNode().getNodeId());
    SerialMessage result = new SerialMessage(this.getNode().getNodeId(), SerialMessageClass.SendData, SerialMessageType.Request, SerialMessageClass.ApplicationCommandHandler, SerialMessagePriority.Get);
    byte[] newPayload = { (byte) getNode().getNodeId(), 2, (byte) getCommandClass().getKey(), (byte) NAME_GET };
    result.setMessagePayload(newPayload);
    return result;
}

Output:
 public SerialMessage getNameMessage() {
-    logger.debug("String_Node_Str", this.getNode().getNodeId());
-    SerialMessage result = new SerialMessage(this.getNode().getNodeId(), SerialMessageClass.SendData, SerialMessageType.Request, SerialMessageClass.ApplicationCommandHandler, SerialMessagePriority.Get);
+    logger.debug("String_Node_Str", getNode().getNodeId());
+    SerialMessage result = new SerialMessage(getNode().getNodeId(), SerialMessageClass.SendData, SerialMessageType.Request, SerialMessageClass.ApplicationCommandHandler, SerialMessagePriority.Get);
     byte[] newPayload = { (byte) getNode().getNodeId(), 2, (byte) getCommandClass().getKey(), (byte) NAME_GET };


Input:
public void testDesignIncludeLibrary() throws Exception {
    openDesign(fileName);
    designHandle.includeLibrary(inputLibrary, "String_Node_Str");
    LibraryHandle libAHandle = designHandle.getLibrary("String_Node_Str");
    TextItemHandle textLibA = (TextItemHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", textLibA);
    TableHandle tableLibA = (TableHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", tableLibA);
    ParameterHandle parameterLibA = (ParameterHandle) libAHandle.findParameter("String_Node_Str");
    assertNotNull("String_Node_Str", parameterLibA);
    LabelHandle labelLibA = (LabelHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", labelLibA);
    ImageHandle imageLibA = (ImageHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", imageLibA);
    DataItemHandle dataLibA = (DataItemHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", dataLibA);
    DataSourceHandle dataSourceLibA = (DataSourceHandle) libAHandle.findDataSource("String_Node_Str");
    assertNotNull("String_Node_Str", dataSourceLibA);
    DataSetHandle dataSetLibA = (DataSetHandle) libAHandle.findDataSet("String_Node_Str");
    assertNotNull("String_Node_Str", dataSetLibA);
    ListHandle listLibA = (ListHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", listLibA);
    GridHandle gridLibA = (GridHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", gridLibA);
    TextItemHandle textLibAHandle = (TextItemHandle) designHandle.getElementFactory().newElementFrom(textLibA, "String_Node_Str");
    TableHandle tableLibAHandle = (TableHandle) designHandle.getElementFactory().newElementFrom(tableLibA, "String_Node_Str");
    ParameterHandle parameterLibAHandle = (ParameterHandle) designHandle.getElementFactory().newElementFrom(parameterLibA, "String_Node_Str");
    LabelHandle labelLibAHandle = (LabelHandle) designHandle.getElementFactory().newElementFrom(labelLibA, "String_Node_Str");
    ImageHandle imageLibAHandle = (ImageHandle) designHandle.getElementFactory().newElementFrom(imageLibA, "String_Node_Str");
    DataItemHandle dataLibAHandle = (DataItemHandle) designHandle.getElementFactory().newElementFrom(dataLibA, "String_Node_Str");
    DataSourceHandle dataSourceLibAHandle = (DataSourceHandle) designHandle.getElementFactory().newOdaDataSource("String_Node_Str");
    DataSetHandle dataSetLibAHandle = (DataSetHandle) designHandle.getElementFactory().newOdaDataSet("String_Node_Str");
    ListHandle listLibAHandle = (ListHandle) designHandle.getElementFactory().newElementFrom(listLibA, "String_Node_Str");
    GridHandle gridLibAHandle = (GridHandle) designHandle.getElementFactory().newElementFrom(gridLibA, "String_Node_Str");
    designHandle.getDataSources().add(dataSourceLibAHandle);
    designHandle.getDataSets().add(dataSetLibAHandle);
    designHandle.getBody().add(dataLibAHandle);
    designHandle.getParameters().add(parameterLibAHandle);
    designHandle.getBody().add(textLibAHandle);
    designHandle.getBody().add(labelLibAHandle);
    designHandle.getBody().add(tableLibAHandle);
    designHandle.getBody().add(imageLibAHandle);
    designHandle.getBody().add(listLibAHandle);
    designHandle.getBody().add(gridLibAHandle);
    assertEquals("String_Node_Str", dataSourceLibAHandle.getName());
    assertEquals("String_Node_Str", dataSetLibAHandle.getName());
    assertEquals("String_Node_Str", dataLibAHandle.getName());
    assertEquals("String_Node_Str", parameterLibAHandle.getName());
    assertEquals("String_Node_Str", textLibAHandle.getName());
    assertEquals("String_Node_Str", labelLibAHandle.getName());
    assertEquals("String_Node_Str", tableLibAHandle.getName());
    assertEquals("String_Node_Str", imageLibAHandle.getName());
    assertEquals("String_Node_Str", listLibAHandle.getName());
    assertEquals("String_Node_Str", gridLibAHandle.getName());
    LabelHandle labelDesignHandle = (LabelHandle) designHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", labelDesignHandle);
    assertEquals("String_Node_Str", labelDesignHandle.getStringProperty("String_Node_Str"));
    assertEquals("String_Node_Str", labelDesignHandle.getStringProperty("String_Node_Str"));
    StyleHandle styleLibA = (StyleHandle) libAHandle.findStyle("String_Node_Str");
    assertNotNull("String_Node_Str", styleLibA);
    StyleHandle styleLibAHandle = (StyleHandle) designHandle.getElementFactory().newStyle("String_Node_Str");
    designHandle.getStyles().add(styleLibAHandle);
    assertEquals("String_Node_Str", labelDesignHandle.getStringProperty("String_Node_Str"));
    assertEquals("String_Node_Str", labelDesignHandle.getStringProperty("String_Node_Str"));
    StyleHandle styleDesignHandle = (StyleHandle) designHandle.findStyle("String_Node_Str");
    assertNotNull("String_Node_Str", styleDesignHandle);
    styleDesignHandle.drop();
    assertEquals("String_Node_Str", labelDesignHandle.getStringProperty("String_Node_Str"));
    assertEquals(null, labelDesignHandle.getStringProperty("String_Node_Str"));
    designHandle.saveAs(outFileName);
}

Output:
     openDesign(fileName);
-    designHandle.includeLibrary(inputLibrary, "String_Node_Str");
+    designHandle.includeLibrary(inputLibraryName, "String_Node_Str");
     LibraryHandle libAHandle = designHandle.getLibrary("String_Node_Str");


Input:
private void prepareCppApp() throws CommandException {
    if (!TMPDIR.isDirectory())
        throw exceptionMaker("String_Node_Str", Strings.get("String_Node_Str", TMPDIR));
    if (!FileUtils.deleteFileMaybe(CPP_APP))
        throw exceptionMaker("String_Node_Str", CPP_APP);
    finer("String_Node_Str", CPP_APP);
    CPP_APP.deleteOnExit();
    InputStream in = null;
    FileOutputStream out = null;
    try {
        in = getClass().getResourceAsStream("String_Node_Str" + CPP_APP_FILENAME);
        out = new FileOutputStream(CPP_APP);
        copyStream(in, out);
    } catch (IOException ex) {
        throw exceptionMaker("String_Node_Str", CPP_APP, ex);
    } finally {
        if (out != null) {
            try {
                out.close();
            } catch (Exception e) {
            }
        }
        if (in != null) {
            try {
                in.close();
            } catch (Exception e) {
            }
        }
    }
    if (!CPP_APP.canExecute())
        throw exceptionMaker("String_Node_Str", CPP_APP);
}

Output:
         throw exceptionMaker("String_Node_Str", CPP_APP);
-    finer("String_Node_Str", CPP_APP);
+    if (logger.isLoggable(Level.FINER))
+        logger.finer(Strings.get("String_Node_Str", CPP_APP));
     CPP_APP.deleteOnExit();


Input:
public String setType(GameCharacter owner, EyeType type) {
    if (type == getType()) {
        if (owner.isPlayer()) {
            return "String_Node_Str";
        } else {
            return UtilText.parse(owner, "String_Node_Str");
        }
    }
    UtilText.transformationContentSB.setLength(0);
    if (owner.isPlayer()) {
        UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
    } else {
        UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
    }
    String s = UtilText.parse(owner, UtilText.transformationContentSB.toString());
    UtilText.transformationContentSB.setLength(0);
    UtilText.transformationContentSB.append(s);
    this.type = type;
    switch(type) {
        case HUMAN:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case DEMON_COMMON:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case IMP:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case COW_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case DOG_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case LYCAN:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case CAT_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case SQUIRREL_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case RAT_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case RABBIT_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case BAT_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case ALLIGATOR_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case HORSE_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case REINDEER_MORPH:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case HARPY:
            if (owner.isPlayer()) {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            } else {
                UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            }
            break;
        case ANGEL:
            break;
    }
    if (owner.isPlayer()) {
        UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
    } else {
        UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
    }
    return UtilText.parse(owner, UtilText.transformationContentSB.toString()) + "String_Node_Str" + owner.postTransformationCalculation() + "String_Node_Str";
}

Output:
     }
-    if (owner.isPlayer()) {
-        UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
-    } else {
-        UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
-    }
+    UtilText.transformationContentSB.append("String_Node_Str" + "String_Node_Str");
     return UtilText.parse(owner, UtilText.transformationContentSB.toString()) + "String_Node_Str" + owner.postTransformationCalculation() + "String_Node_Str";


Input:
public void onParentScalingEvent(ScalingEvent scalingEvent) {
    log.info("String_Node_Str" + this.getId() + "String_Node_Str" + scalingEvent.getNetworkPartitionId() + "String_Node_Str" + scalingEvent.getId() + "String_Node_Str" + scalingEvent.getInstanceId() + "String_Node_Str" + scalingEvent.getFactor());
    String networkPartitionId = scalingEvent.getNetworkPartitionId();
    final String parentInstanceId = scalingEvent.getInstanceId();
    final NetworkPartitionContext networkPartitionContext = this.networkPartitionCtxts.get(networkPartitionId);
    float factor = scalingEvent.getFactor();
    int currentInstances = networkPartitionContext.getNonTerminatedInstancesCount();
    float requiredInstances = factor * ((GroupLevelNetworkPartitionContext) networkPartitionContext).getMinInstanceCount();
    float additionalInstances = requiredInstances - currentInstances;
    if (additionalInstances >= 1) {
        createGroupInstanceOnScaling(networkPartitionContext, parentInstanceId);
    } else {
        if (networkPartitionContext.getPendingInstancesCount() != 0) {
            ApplicationBuilder.handleGroupTerminatingEvent(appId, this.id, networkPartitionContext.getPendingInstances().get(0).getId());
        } else {
            List<InstanceContext> activeInstances = networkPartitionContext.getActiveInstances();
            ApplicationBuilder.handleGroupTerminatingEvent(appId, this.id, activeInstances.get(activeInstances.size() - 1).toString());
        }
    }
}

Output:
     float requiredInstances = factor * ((GroupLevelNetworkPartitionContext) networkPartitionContext).getMinInstanceCount();
-    float additionalInstances = requiredInstances - currentInstances;
-    if (additionalInstances >= 1) {
-        createGroupInstanceOnScaling(networkPartitionContext, parentInstanceId);
-    } else {
-        if (networkPartitionContext.getPendingInstancesCount() != 0) {
-            ApplicationBuilder.handleGroupTerminatingEvent(appId, this.id, networkPartitionContext.getPendingInstances().get(0).getId());
-        } else {
-            List<InstanceContext> activeInstances = networkPartitionContext.getActiveInstances();
-            ApplicationBuilder.handleGroupTerminatingEvent(appId, this.id, activeInstances.get(activeInstances.size() - 1).toString());
+    int ceilingRequiredInstances = (int) Math.ceil(requiredInstances);
+    if (ceilingRequiredInstances > currentInstances) {
+        int instancesToBeCreated = ceilingRequiredInstances - currentInstances;
+        for (int count = 0; count < instancesToBeCreated; count++) {
+            createGroupInstanceOnScaling(networkPartitionContext, parentInstanceId);
+        }
+    } else if (ceilingRequiredInstances < currentInstances) {
+        int instancesToBeTerminated = currentInstances - ceilingRequiredInstances;
+        for (int count = 0; count < instancesToBeTerminated; count++) {
+            if (networkPartitionContext.getPendingInstancesCount() != 0) {
+                ApplicationBuilder.handleGroupTerminatingEvent(appId, this.id, networkPartitionContext.getPendingInstances().get(0).getId());
+            } else {
+                List<InstanceContext> activeInstances = networkPartitionContext.getActiveInstances();
+                ApplicationBuilder.handleGroupTerminatingEvent(appId, this.id, activeInstances.get(activeInstances.size() - 1).toString());
+            }
         }


Input:
protected File getMetadataFile() {
    return new File(getMetadataDir(), MetadataFileWriter.getMetadataArchiveFileName(Long.toString(jobId)));
}

Output:
 protected File getMetadataFile() {
-    return new File(getMetadataDir(), MetadataFileWriter.getMetadataArchiveFileName(Long.toString(jobId)));
+    return new File(getMetadataDir(), MetadataFileWriter.getMetadataArchiveFileName(Long.toString(jobId), harvestId));
 }


Input:
public boolean authenticate(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    Subject callerSubject = subjectManager.getCallerSubject();
    if (!subjectHelper.isUnauthenticated(callerSubject)) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "String_Node_Str");
        return true;
    }
    WebReply webReply = PERMIT_REPLY;
    boolean result = true;
    WebRequest webRequest = new WebRequestImpl(req, resp, getSecurityMetadata(), webAppSecConfig);
    AuthenticationResult authResult = null;
    if (isJaspiEnabled && ((JaspiService) webAuthenticatorRef.getService("String_Node_Str")).isAnyProviderRegistered(webRequest)) {
        authResult = providerAuthenticatorProxy.handleJaspi(webRequest, null);
    }
    if (authResult == null || authResult.getStatus() == AuthResult.CONTINUE) {
        authResult = authenticateRequest(webRequest);
    }
    if (authResult.getStatus() == AuthResult.SUCCESS) {
        getAuthenticateApi().postProgrammaticAuthenticate(req, resp, authResult);
    } else {
        String realm = authResult.realm;
        if (realm == null) {
            realm = collabUtils.getUserRegistryRealm(securityServiceRef);
        }
        webReply = createReplyForAuthnFailure(authResult, realm);
        result = false;
    }
    authResult.setTargetRealm(authResult.realm != null ? authResult.realm : collabUtils.getUserRegistryRealm(securityServiceRef));
    webReply.writeResponse(resp);
    Audit.audit(Audit.EventID.SECURITY_AUTHN_01, webRequest, authResult, Integer.valueOf(webReply.getStatusCode()));
    return result;
}

Output:
     authResult.setTargetRealm(authResult.realm != null ? authResult.realm : collabUtils.getUserRegistryRealm(securityServiceRef));
-    webReply.writeResponse(resp);
+    if (!resp.isCommitted()) {
+        webReply.writeResponse(resp);
+    }
     Audit.audit(Audit.EventID.SECURITY_AUTHN_01, webRequest, authResult, Integer.valueOf(webReply.getStatusCode()));


Input:
public RenderedImage create(ParameterBlock args, RenderingHints renderHints) {
    RenderedImage src = args.getRenderedSource(0);
    Integer datatype = (Integer) args.getObjectParameter(0);
    int type = datatype.intValue();
    ImageLayout layout = RIFUtil.getImageLayoutHint(renderHints);
    if (layout == null && type == src.getSampleModel().getDataType()) {
        return src;
    }
    if (layout == null) {
        layout = new ImageLayout(src);
    } else {
        layout = (ImageLayout) layout.clone();
    }
    boolean isDataTypeChange = false;
    SampleModel sampleModel = layout.getSampleModel(src);
    if (sampleModel.getDataType() != type) {
        int tileWidth = layout.getTileWidth(src);
        int tileHeight = layout.getTileHeight(src);
        int numBands = src.getSampleModel().getNumBands();
        SampleModel csm = RasterFactory.createComponentSampleModel(sampleModel, type, tileWidth, tileHeight, numBands);
        layout.setSampleModel(csm);
        isDataTypeChange = true;
    }
    ColorModel colorModel = layout.getColorModel(null);
    if (colorModel != null && !JDKWorkarounds.areCompatibleDataModels(layout.getSampleModel(src), colorModel)) {
        layout.unsetValid(ImageLayout.COLOR_MODEL_MASK);
    }
    if (layout.getSampleModel(src) == src.getSampleModel() && layout.getMinX(src) == src.getMinX() && layout.getMinY(src) == src.getMinY() && layout.getWidth(src) == src.getWidth() && layout.getHeight(src) == src.getHeight() && layout.getTileWidth(src) == src.getTileWidth() && layout.getTileHeight(src) == src.getTileHeight() && layout.getTileGridXOffset(src) == src.getTileGridXOffset() && layout.getTileGridYOffset(src) == src.getTileGridYOffset()) {
        if (layout.getColorModel(src) == src.getColorModel()) {
            return src;
        } else {
            RenderingHints hints = renderHints;
            if (hints != null && hints.containsKey(JAI.KEY_TILE_CACHE)) {
                hints = new RenderingHints(renderHints);
                hints.remove(JAI.KEY_TILE_CACHE);
            }
            return new NullOpImage(src, layout, hints, OpImage.OP_IO_BOUND);
        }
    }
    if (isDataTypeChange == true) {
        if (renderHints == null) {
            renderHints = new RenderingHints(JAI.KEY_REPLACE_INDEX_COLOR_MODEL, Boolean.TRUE);
        } else if (!renderHints.containsKey(JAI.KEY_REPLACE_INDEX_COLOR_MODEL)) {
            renderHints.put(JAI.KEY_REPLACE_INDEX_COLOR_MODEL, Boolean.TRUE);
        }
    }
    return new CopyOpImage(src, renderHints, layout);
}

Output:
             if (hints != null && hints.containsKey(JAI.KEY_TILE_CACHE)) {
-                hints = new RenderingHints(renderHints);
+                hints = new RenderingHints((Map) renderHints);
                 hints.remove(JAI.KEY_TILE_CACHE);


Input:
private Map<Locale, String> getTranslations() {
    return translations;
}

Output:
 private Map<Locale, String> getTranslations() {
-    return translations;
+    return immutableCopyOf(translations);
 }


Input:
public NamedList<Property> getCellProperties() {
    final ArrayNamedListImpl<Property> list = new ArrayNamedListImpl<Property>() {
        protected String getName(Property property) {
            return property.getName();
        }
    };
    for (Property.StandardCellProperty property : Property.StandardCellProperty.values()) {
        if (query.hasCellProperty(property.getName())) {
            list.add(property);
        }
    }
    return list;
}

Output:
     };
-    for (Property.StandardCellProperty property : Property.StandardCellProperty.values()) {
+    for (Property property : Property.StandardCellProperty.values()) {
+        if (query.hasCellProperty(property.getName())) {
+            list.add(property);
+        }
+    }
+    for (Property property : MondrianOlap4jProperty.CELL_EXTENSIONS.values()) {
         if (query.hasCellProperty(property.getName())) {


Input:
public static Chart parseSentence(int[] sent, CnfGrammar grammar) {
    Chart chart = new Chart(sent, grammar);
    for (int i = 0; i <= sent.length - 1; i++) {
        for (Rule r : grammar.getLexicalRulesWithChild(sent[i])) {
            double score = r.getScore();
            chart.updateCell(i, i + 1, r, score);
        }
    }
    for (int width = 1; width <= sent.length; width++) {
        for (int start = 0; start <= sent.length - width; start++) {
            int end = start + width;
            for (int mid = start + 1; mid <= end - 1; mid++) {
                for (final int leftChildNt : chart.getNonTerminals(start, mid)) {
                    for (final int rightChildNt : chart.getNonTerminals(mid, end)) {
                        for (final Rule r : grammar.getBinaryRulesWithChildren(leftChildNt, rightChildNt)) {
                            double score = r.getScore() + chart.getMaxScore(start, mid, r.getLeftChild()) + chart.getMaxScore(mid, end, r.getRightChild());
                            chart.updateCell(start, mid, end, r, score);
                        }
                    }
                }
            }
            for (final int parentNt : chart.getNonTerminals(start, end)) {
                for (Rule r : grammar.getUnaryRulesWithChild(parentNt)) {
                    double score = r.getScore();
                    chart.updateCell(start, end, r, score);
                }
            }
        }
    }
    return chart;
}

Output:
                 for (Rule r : grammar.getUnaryRulesWithChild(parentNt)) {
-                    double score = r.getScore();
+                    double score = r.getScore() + chart.getMaxScore(start, end, r.getLeftChild());
                     chart.updateCell(start, end, r, score);


Input:
private void update() {
    String[] names;
    tc = Prephase2Activity.dba.getAllRows();
    names = new String[tc.size()];
    for (int i = 0; i < tc.size(); i++) {
        names[i] = tc.get(i).getName();
    }
    listView.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_multiple_choice, names));
    listView.setItemsCanFocus(false);
    listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
}

Output:
     tc = Prephase2Activity.dba.getAllRows();
-    names = new String[tc.size()];
-    for (int i = 0; i < tc.size(); i++) {
-        names[i] = tc.get(i).getName();
+    if (tc != null) {
+        names = new String[tc.size()];
+        for (int i = 0; i < tc.size(); i++) {
+            names[i] = tc.get(i).getName();
+        }
+        listView.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_multiple_choice, names));
+        listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
+    } else {
+        names = new String[] { "String_Node_Str" };
+        listView.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, names));
     }


Input:
public boolean emptyCollection(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, boolean openGrouping) {
    if (marshaller.isMarshalEmptyCollections()) {
        super.emptyCollection(xPathFragment, namespaceResolver, true);
        startCollection();
        if (xPathFragment != null && !xPathFragment.isSelfFragment()) {
            openStartElement(xPathFragment, namespaceResolver);
            if (!levels.isEmpty()) {
                Level position = levels.peek();
                position.setNeedToCloseComplex(false);
                position.setNeedToOpenComplex(false);
            }
            endElement(xPathFragment, namespaceResolver);
        }
        endEmptyCollection();
        return true;
    } else {
        return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
    }
}

Output:
         super.emptyCollection(xPathFragment, namespaceResolver, true);
-        startCollection();
-        if (xPathFragment != null && !xPathFragment.isSelfFragment()) {
-            openStartElement(xPathFragment, namespaceResolver);
-            if (!levels.isEmpty()) {
-                Level position = levels.peek();
-                position.setNeedToCloseComplex(false);
-                position.setNeedToOpenComplex(false);
+        if (null != xPathFragment) {
+            startCollection();
+            if (!xPathFragment.isSelfFragment()) {
+                openStartElement(xPathFragment, namespaceResolver);
+                if (!levels.isEmpty()) {
+                    Level position = levels.peek();
+                    position.setNeedToCloseComplex(false);
+                    position.setNeedToOpenComplex(false);
+                }
+                endElement(xPathFragment, namespaceResolver);
             }


Input:
private InputStream renderHtml(String contextPath, CacheEntry cacheEntry, ProxyDirContext proxyDirContext) throws IOException, ServletException {
    String name = cacheEntry.name;
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    OutputStreamWriter osWriter = null;
    try {
        osWriter = new OutputStreamWriter(stream, "String_Node_Str");
    } catch (Exception e) {
        osWriter = new OutputStreamWriter(stream);
    }
    PrintWriter writer = new PrintWriter(osWriter);
    StringBuilder sb = new StringBuilder();
    String rewrittenContextPath = rewriteUrl(contextPath);
    String dirTitle = MessageFormat.format(rb.getString(DIR_TITLE_INFO), name);
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(dirTitle);
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(org.apache.catalina.util.TomcatCSS.TOMCAT_CSS);
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(dirTitle);
    String parentDirectory = name;
    if (parentDirectory.endsWith("String_Node_Str")) {
        parentDirectory = parentDirectory.substring(0, parentDirectory.length() - 1);
    }
    int slash = parentDirectory.lastIndexOf('/');
    if (slash >= 0) {
        String parent = name.substring(0, slash);
        String dirParent = MessageFormat.format(rb.getString(DIR_PARENT_INFO), parent);
        sb.append("String_Node_Str");
        sb.append(rewrittenContextPath);
        if (parent.equals("String_Node_Str"))
            parent = "String_Node_Str";
        sb.append(rewriteUrl(parent));
        if (!parent.endsWith("String_Node_Str"))
            sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append(dirParent);
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str" + "String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(rb.getString(DIR_FILENAME_INFO));
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(rb.getString(DIR_SIZE_INFO));
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(rb.getString(DIR_LAST_MODIFIED_INFO));
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    try {
        Enumeration<NameClassPair> enumeration = proxyDirContext.list(cacheEntry.name);
        if (sortedBy.equals(SortedBy.LAST_MODIFIED)) {
            ArrayList<NameClassPair> list = Collections.list(enumeration);
            Comparator<NameClassPair> c = new LastModifiedComparator(proxyDirContext, cacheEntry.name);
            Collections.sort(list, c);
            enumeration = Collections.enumeration(list);
        } else if (sortedBy.equals(SortedBy.SIZE)) {
            ArrayList<NameClassPair> list = Collections.list(enumeration);
            Comparator<NameClassPair> c = new SizeComparator(proxyDirContext, cacheEntry.name);
            Collections.sort(list, c);
            enumeration = Collections.enumeration(list);
        }
        boolean shade = false;
        while (enumeration.hasMoreElements()) {
            NameClassPair ncPair = enumeration.nextElement();
            String resourceName = ncPair.getName();
            String trimmed = resourceName;
            if (trimmed.equalsIgnoreCase("String_Node_Str") || trimmed.equalsIgnoreCase("String_Node_Str"))
                continue;
            CacheEntry childCacheEntry = proxyDirContext.lookupCache(cacheEntry.name + resourceName);
            if (!childCacheEntry.exists) {
                continue;
            }
            sb.append("String_Node_Str");
            if (shade)
                sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            shade = !shade;
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(rewrittenContextPath);
            resourceName = rewriteUrl(name + resourceName);
            sb.append(resourceName);
            if (childCacheEntry.context != null)
                sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(RequestUtil.filter(trimmed));
            if (childCacheEntry.context != null)
                sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            if (childCacheEntry.context != null)
                sb.append("String_Node_Str");
            else
                sb.append(renderSize(childCacheEntry.attributes.getContentLength()));
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(childCacheEntry.attributes.getLastModifiedHttp());
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        }
    } catch (NamingException e) {
        throw new ServletException("String_Node_Str", e);
    }
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    String readme = getReadme(cacheEntry.context);
    if (readme != null) {
        sb.append(readme);
        sb.append("String_Node_Str");
    }
    String serverInfo = ServerInfo.getPublicServerInfo();
    if (serverInfo != null && !serverInfo.isEmpty()) {
        sb.append("String_Node_Str").append(serverInfo).append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    writer.write(sb.toString());
    writer.flush();
    return (new ByteArrayInputStream(stream.toByteArray()));
}

Output:
             sb.append("String_Node_Str");
-            sb.append(RequestUtil.filter(trimmed));
+            sb.append(htmlEntityEncoder.encode(trimmed));
             if (childCacheEntry.context != null)


Input:
private AggregateLinkingScoreRecord aggregateScores(ImmutableList<LinkingScoreDocRecord> docRecords) {
    double precision = 0.0;
    double recall = 0.0;
    double f1 = 0.0;
    double linkNormalizerSum = 0.0;
    final ImmutableListMultimap.Builder<String, Double> f1sB = ImmutableListMultimap.builder();
    final ImmutableListMultimap.Builder<String, Double> precisionsB = ImmutableListMultimap.builder();
    final ImmutableListMultimap.Builder<String, Double> recallsB = ImmutableListMultimap.builder();
    for (final LinkingScoreDocRecord docRecord : docRecords) {
        precision += docRecord.fMeasureInfo().precision() * docRecord.predictedCounts();
        recall += docRecord.fMeasureInfo().recall() * docRecord.actualCounts();
        f1 += docRecord.fMeasureInfo().f1() * docRecord.actualCounts();
        linkNormalizerSum += docRecord.linkingArgCounts();
    }
    f1sB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? f1 / linkNormalizerSum : 0.0);
    precisionsB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? precision / linkNormalizerSum : 0.0);
    recallsB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? recall / linkNormalizerSum : 0.0);
    return new AggregateLinkingScoreRecord.Builder().f1s(f1sB.build()).precisions(precisionsB.build()).recalls(recallsB.build()).build();
}

Output:
     }
-    f1sB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? f1 / linkNormalizerSum : 0.0);
-    precisionsB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? precision / linkNormalizerSum : 0.0);
-    recallsB.put("String_Node_Str", (linkNormalizerSum > 0.0) ? recall / linkNormalizerSum : 0.0);
-    return new AggregateLinkingScoreRecord.Builder().f1s(f1sB.build()).precisions(precisionsB.build()).recalls(recallsB.build()).build();
+    f1 = (linkNormalizerSum > 0.0) ? f1 / linkNormalizerSum : 0.0;
+    precision = (linkNormalizerSum > 0.0) ? precision / linkNormalizerSum : 0.0;
+    recall = (linkNormalizerSum > 0.0) ? recall / linkNormalizerSum : 0.0;
+    return new AggregateLinkingScoreRecord.Builder().f1(f1).precision(precision).recall(recall).build();
 }


Input:
public static String getUsages(String select, Object victim, Object... args) {
    Connection c = DBConnect.getDBConnection();
    PreparedStatement s = null;
    try {
        s = prepareStatement(c, select, args);
        ResultSet res = s.executeQuery();
        if (res.next()) {
            List<String> used_in = new ArrayList<String>();
            do {
                used_in.add(res.getString(1));
            } while (res.next());
            return used_in.toString();
        }
        return null;
    } catch (SQLException e) {
        final String message = "String_Node_Str" + victim;
        log.warn(message, e);
        throw new IOFailure(message, e);
    } finally {
        closeStatementIfOpen(s);
    }
}

Output:
         if (res.next()) {
-            List<String> used_in = new ArrayList<String>();
+            List<String> usedIn = new ArrayList<String>();
             do {


Input:
public int hashCode() {
    int result;
    result = otherAccountId.hashCode();
    result = 31 * result + groupName.hashCode();
    return result;
}

Output:
     int result;
-    result = otherAccountId.hashCode();
-    result = 31 * result + groupName.hashCode();
+    result = this.otherAccountId.hashCode();
+    result = 31 * result + this.groupName.hashCode();
     return result;


Input:
void split(String full, int start, int end, LinkedList<String> buffer, List<String> results, boolean findSingle) {
    while (end <= full.length()) {
        String sub = full.substring(start, end);
        if (check(sub)) {
            if (end == full.length()) {
                if (buffer.size() < maxTokenCount) {
                    results.add(Joiner.on("String_Node_Str").join(buffer) + "String_Node_Str" + sub);
                    if (findSingle) {
                        return;
                    }
                }
            } else {
                buffer.add(sub);
                start = end;
                end = start + 1;
                break;
            }
        }
        end++;
    }
    if (end > full.length()) {
        if (buffer.size() == 0 || start == 0)
            return;
        String last = buffer.removeLast();
        start = start - last.length();
        end = start + last.length() + 1;
    }
    split(full, start, end, buffer, results, findSingle);
}

Output:
                 if (buffer.size() < maxTokenCount) {
-                    results.add(Joiner.on("String_Node_Str").join(buffer) + "String_Node_Str" + sub);
+                    if (buffer.size() == 0)
+                        results.add(sub);
+                    else
+                        results.add(Joiner.on("String_Node_Str").join(buffer) + "String_Node_Str" + sub);
                     if (findSingle) {


Input:
protected synchronized void onServerPoolMemberChanged(Entity member) {
    if (log.isTraceEnabled())
        log.trace("String_Node_Str", new Object[] { this, member, member.getLocations() });
    Map<Entity, String> nodes = getAttribute(RIAK_CLUSTER_NODES);
    if (belongsInServerPool(member)) {
        if (nodes == null) {
            nodes = Maps.newLinkedHashMap();
        }
        String riakName = getRiakName(member);
        Preconditions.checkNotNull(riakName);
        if (!isFirstNodeSet.getAndSet(true)) {
            nodes.put(member, riakName);
            setAttribute(RIAK_CLUSTER_NODES, nodes);
            ((EntityInternal) member).setAttribute(RiakNode.RIAK_NODE_HAS_JOINED_CLUSTER, Boolean.TRUE);
            log.info("String_Node_Str", new Object[] { this, member, getRiakName(member) });
        } else {
            Optional<Entity> anyNodeInCluster = Iterables.tryFind(nodes.keySet(), new Predicate<Entity>() {
                public boolean apply(Entity node) {
                    return (node instanceof RiakNode && hasMemberJoinedCluster(node));
                }
            });
            if (anyNodeInCluster.isPresent()) {
                if (!nodes.containsKey(member) && !hasMemberJoinedCluster(member)) {
                    String anyNodeName = anyNodeInCluster.get().getAttribute(RiakNode.RIAK_NODE_NAME);
                    Entities.invokeEffectorWithArgs(this, member, RiakNode.JOIN_RIAK_CLUSTER, anyNodeName);
                    if (getAttribute(IS_CLUSTER_INIT)) {
                        Entities.invokeEffector(RiakClusterImpl.this, anyNodeInCluster.get(), RiakNode.COMMIT_RIAK_CLUSTER);
                    }
                    nodes.put(member, riakName);
                    setAttribute(RIAK_CLUSTER_NODES, nodes);
                    log.info("String_Node_Str", new Object[] { this, member, getRiakName(member) });
                }
            } else {
                log.error("String_Node_Str", member.getId());
            }
        }
    } else {
        if (nodes != null && nodes.containsKey(member)) {
            final Entity memberToBeRemoved = member;
            Optional<Entity> anyNodeInCluster = Iterables.tryFind(nodes.keySet(), new Predicate<Entity>() {
                public boolean apply(Entity node) {
                    return (node instanceof RiakNode && hasMemberJoinedCluster(node) && !node.equals(memberToBeRemoved));
                }
            });
            if (anyNodeInCluster.isPresent()) {
                Entities.invokeEffectorWithArgs(this, anyNodeInCluster.get(), RiakNode.LEAVE_RIAK_CLUSTER, getRiakName(memberToBeRemoved));
            }
            nodes.remove(member);
            setAttribute(RIAK_CLUSTER_NODES, nodes);
            log.info("String_Node_Str", new Object[] { this, member, getRiakName(member) });
        }
    }
    ServiceNotUpLogic.updateNotUpIndicatorRequiringNonEmptyMap(this, RIAK_CLUSTER_NODES);
    if (log.isTraceEnabled())
        log.trace("String_Node_Str", this, member);
    calculateClusterAddresses();
}

Output:
             Optional<Entity> anyNodeInCluster = Iterables.tryFind(nodes.keySet(), new Predicate<Entity>() {
-                public boolean apply(Entity node) {
-                    return (node instanceof RiakNode && hasMemberJoinedCluster(node));
-                }
-            });
-            if (anyNodeInCluster.isPresent()) {
-                if (!nodes.containsKey(member) && !hasMemberJoinedCluster(member)) {
-                    String anyNodeName = anyNodeInCluster.get().getAttribute(RiakNode.RIAK_NODE_NAME);
-                    Entities.invokeEffectorWithArgs(this, member, RiakNode.JOIN_RIAK_CLUSTER, anyNodeName);
-                    if (getAttribute(IS_CLUSTER_INIT)) {
-                        Entities.invokeEffector(RiakClusterImpl.this, anyNodeInCluster.get(), RiakNode.COMMIT_RIAK_CLUSTER);
+public boolean apply(Entity node) {
+    return (node instanceof RiakNode && hasMemberJoinedCluster(node));
                     }


Input:
protected boolean bindServiceToCaldecottApp(String serviceName, CloudFoundryOperations client, SubMonitor monitor) throws CoreException {
    CloudApplication caldecottApp = getCaldecottApp(client);
    List<String> updateCaldecottServices = new ArrayList<String>();
    List<String> existingServices = caldecottApp.getServices();
    if (existingServices != null) {
        updateCaldecottServices.addAll(existingServices);
    }
    IModule caldecottModule = getCaldecottModule(monitor.newChild(1));
    if (!updateCaldecottServices.contains(serviceName)) {
        monitor.setTaskName("String_Node_Str" + serviceName + "String_Node_Str");
        updateCaldecottServices.add(serviceName);
        CloudFoundryServerBehaviour behaviour = cloudServer.getBehaviour();
        behaviour.stopModule(new IModule[] { caldecottModule }, monitor.newChild(1));
        behaviour.updateServices(TunnelHelper.getTunnelAppName(), updateCaldecottServices, monitor.newChild(1));
        setDeploymentServices(serviceName, monitor.newChild(1));
        return caldecottApp.getServices().contains(serviceName);
    } else {
        return true;
    }
}

Output:
     if (existingServices != null) {
-        updateCaldecottServices.addAll(existingServices);
+        for (String existing : existingServices) {
+            if (existing != null) {
+                updateCaldecottServices.add(existing);
+            }
+        }
     }