Input:
public static String getPattern(ERepositoryObjectType type) {
    if (type == ERepositoryObjectType.FOLDER) {
        return FOLDER_PATTERN;
    } else if (type == ERepositoryObjectType.PROCESS || ERepositoryObjectType.getAllTypesOfProcess().contains(type)) {
        return CODE_ITEM_PATTERN;
    } else if (type == ERepositoryObjectType.ROUTINES || type == ERepositoryObjectType.PIG_UDF || "String_Node_Str".equals(type.getType())) {
        return ROUTINES_ITEM_PATTERN;
    } else if (type == ERepositoryObjectType.TDQ_JRAXML_ELEMENT || type == ERepositoryObjectType.TDQ_DATA_PROFILING || type == ERepositoryObjectType.TDQ_ANALYSIS_ELEMENT || type == ERepositoryObjectType.TDQ_REPORT_ELEMENT || type == ERepositoryObjectType.TDQ_LIBRARIES || type == ERepositoryObjectType.TDQ_PATTERN_ELEMENT || type == ERepositoryObjectType.TDQ_PATTERN_REGEX || type == ERepositoryObjectType.TDQ_PATTERN_SQL || type == ERepositoryObjectType.TDQ_SOURCE_FILE_ELEMENT || type == ERepositoryObjectType.TDQ_RULES || type == ERepositoryObjectType.TDQ_RULES_SQL || type == ERepositoryObjectType.TDQ_INDICATOR_ELEMENT) {
        return TDQ_ALL_ITEM_PATTERN;
    } else if (type == ERepositoryObjectType.METADATA_CONNECTIONS || type == ERepositoryObjectType.METADATA_FILE_DELIMITED || type == ERepositoryObjectType.METADATA_FILE_POSITIONAL || type == ERepositoryObjectType.METADATA_FILE_REGEXP || type == ERepositoryObjectType.METADATA_FILE_XML || type == ERepositoryObjectType.METADATA_FILE_EXCEL || type == ERepositoryObjectType.METADATA_FILE_LDIF || type == ERepositoryObjectType.METADATA_LDAP_SCHEMA || type == ERepositoryObjectType.METADATA_SALESFORCE_SCHEMA || type == ERepositoryObjectType.METADATA_GENERIC_SCHEMA || type == ERepositoryObjectType.METADATA_MDMCONNECTION || type == ERepositoryObjectType.METADATA_FILE_HL7 || type == ERepositoryObjectType.METADATA_FILE_RULES || type == ERepositoryObjectType.METADATA_FILE_EBCDIC || type == ERepositoryObjectType.METADATA_WSDL_SCHEMA || type == ERepositoryObjectType.METADATA_VALIDATION_RULES || type == ERepositoryObjectType.METADATA_FILE_FTP || type == ERepositoryObjectType.METADATA_EDIFACT) {
        return METADATA_NAME_PATTERN;
    } else if (type != null && "String_Node_Str".equals(type.getType())) {
        return SERVICES_NAME_PATTERN;
    } else if (type != null && "String_Node_Str".equals(type.getType())) {
        return CODE_ITEM_PATTERN;
    } else if (type != null && type.getType() != null && type.getType().startsWith("String_Node_Str")) {
        return MDM_ITEM_PATTERN;
    } else {
        return TDQ_ALL_ITEM_PATTERN;
    }
}

Output:
         return FOLDER_PATTERN;
-    } else if (type == ERepositoryObjectType.PROCESS || ERepositoryObjectType.getAllTypesOfProcess().contains(type)) {
+    } else if (ERepositoryObjectType.getAllTypesOfProcess().contains(type) || type == ERepositoryObjectType.JOBLET) {
         return CODE_ITEM_PATTERN;


Input:
public String getByKey(final String pathArg) {
    final Map<String, String> m = this.getMetadataMap();
    String path = (pathArg != null) ? pathArg : "String_Node_Str";
    LOG.debug("String_Node_Str" + path + "String_Node_Str" + m.get(path));
    if (m.containsKey(path + "String_Node_Str"))
        path += "String_Node_Str";
    return m.get(path).replaceAll("String_Node_Str", "String_Node_Str");
}

Output:
         path += "String_Node_Str";
-    return m.get(path).replaceAll("String_Node_Str", "String_Node_Str");
+    if (!m.containsKey(path)) {
+        throw new NoSuchElementException("String_Node_Str" + path);
+    } else {
+        return m.get(path).replaceAll("String_Node_Str", "String_Node_Str");
+    }
 }


Input:
private boolean sendLog() {
    if (retries > 20) {
        close();
    }
    connection.write();
    log("String_Node_Str" + logVersionToSend);
    if (!buffer.hasRemaining()) {
        buffer.clear();
        try {
            if (logToSend.read(buffer) <= 0) {
                releaseWriteBuffer();
                setStatus(Status.GET_MESSAGE);
                logLength = -1;
                logVersionToSend = -1;
                logToSend = null;
                if (logVersionToSend >= slaveVersion) {
                    slaveVersion = logVersionToSend + 1;
                }
                return true;
            }
            buffer.flip();
        } catch (IOException e) {
            log("String_Node_Str", e);
            close();
            return true;
        }
    }
    retries++;
    return false;
}

Output:
                 releaseWriteBuffer();
-                setStatus(Status.GET_MESSAGE);
+                if (nextLogVersion != -1) {
+                    logToSend = master.getLog(xaDsName, nextLogVersion);
+                    logLength = master.getLogLength(xaDsName, nextLogVersion);
+                    logVersionToSend = nextLogVersion;
+                    nextLogVersion = -1;
+                    setStatus(Status.SETUP_OFFER_LOG);
+                } else {
+                    setStatus(Status.GET_MESSAGE);
+                }
                 logLength = -1;


Input:
public Calendar cast(String src, Class<?> toType, String... args) {
    Calendar c = Calendar.getInstance();
    try {
        c.setTime(dateTimeFormat.parse(src));
    } catch (ParseException e) {
        throw Lang.wrapThrow(e);
    }
    return c;
}

Output:
     try {
-        c.setTime(dateTimeFormat.parse(src));
+        c.setTime(((DateFormat) dateTimeFormat.clone()).parse(src));
     } catch (ParseException e) {


Input:
public ProtocolProviderService signin(String userName, String password) throws OperationFailedException {
    if (firstWizardPage == null) {
        firstWizardPage = new FirstWizardPage(this);
        AccountPanel accPanel = (AccountPanel) firstWizardPage.getSimpleForm();
        accPanel.setUsername(userName);
        accPanel.setPassword(password);
        accPanel.setRememberPassword(true);
    }
    if (!firstWizardPage.isCommitted())
        firstWizardPage.commitPage();
    if (!firstWizardPage.isCommitted())
        throw new OperationFailedException("String_Node_Str", OperationFailedException.GENERAL_ERROR);
    ProtocolProviderFactory factory = JabberAccRegWizzActivator.getJabberProtocolProviderFactory();
    return this.installAccount(factory, registration.getUserID(), password);
}

Output:
 public ProtocolProviderService signin(String userName, String password) throws OperationFailedException {
-    if (firstWizardPage == null) {
-        firstWizardPage = new FirstWizardPage(this);
-        AccountPanel accPanel = (AccountPanel) firstWizardPage.getSimpleForm();
-        accPanel.setUsername(userName);
-        accPanel.setPassword(password);
-        accPanel.setRememberPassword(true);
-    }
+    AccountPanel accPanel = (AccountPanel) firstWizardPage.getSimpleForm();
+    accPanel.setUsername(userName);
+    accPanel.setPassword(password);
+    accPanel.setRememberPassword(password != null);
     if (!firstWizardPage.isCommitted())


Input:
public static Account createAccount(boolean hasAdministrativePrivilege, String accountName, String password, String email) throws AuthException {
    if (!hasAdministrativePrivilege) {
        throw new AuthException(AuthException.ACCESS_DENIED);
    }
    Account newAccount = Accounts.addAccount(accountName);
    Map<String, String> info = null;
    if (email != null) {
        info = Maps.newHashMap();
        info.put(User.EMAIL, email);
    }
    User admin = newAccount.addUser(User.ACCOUNT_ADMIN, "String_Node_Str", true, true, info);
    admin.resetToken();
    admin.createConfirmationCode();
    if (password != null) {
        admin.setPassword(Crypto.generateHashedPassword(password));
        admin.setPasswordExpires(System.currentTimeMillis() + User.PASSWORD_LIFETIME);
    }
    return newAccount;
}

Output:
     }
-    User admin = newAccount.addUser(User.ACCOUNT_ADMIN, "String_Node_Str", true, true, info);
+    User admin = newAccount.addUser(User.ACCOUNT_ADMIN, "String_Node_Str", skipRegistration, true, info);
     admin.resetToken();


Input:
private static long getMapValue(Map<?, Long> map, long ssrc) {
    Long res = map.get(ssrc);
    return res == null ? 0 : res;
}

Output:
 private static long getMapValue(Map<?, Long> map, long ssrc) {
-    Long res = map.get(ssrc);
-    return res == null ? 0 : res;
+    synchronized (map) {
+        Long res = map.get(ssrc);
+        return res == null ? 0 : res;
+    }
 }


Input:
protected void setEntity(final T entity) {
    if (null != _entry) {
        detachEntry(_entry, false);
    }
    if (null == entity) {
        _entry = null;
    } else {
        _entry = createEntityEntry(entity, reference -> detachEntry(reference, false));
    }
}

Output:
     } else {
-        _entry = createEntityEntry(entity, reference -> detachEntry(reference, false));
+        _entry = createEntityEntry(entity, reference -> setEntity(null));
     }


Input:
public Service findService(String name) {
    if (name == null) {
        return (null);
    }
    synchronized (services) {
        for (int i = 0; i < services.length; i++) {
            if (name.equals(services[i].getName())) {
                return (services[i]);
            }
        }
    }
    return (null);
}

Output:
     }
-    synchronized (services) {
+    synchronized (servicesMonitor) {
         for (int i = 0; i < services.length; i++) {


Input:
private void appendSelectDeselectAllButtons(final StringOutput target, final Translator translator, Table table, String formName, int rows, int resultsPerPage) {
    if (table.isMultiSelect()) {
        target.append("String_Node_Str");
        target.append("String_Node_Str");
        target.append("String_Node_Str").append(formName).append("String_Node_Str");
        target.append("String_Node_Str");
        target.append(translator.translate("String_Node_Str"));
        target.append("String_Node_Str");
        target.append("String_Node_Str").append(formName).append("String_Node_Str");
        target.append("String_Node_Str");
        target.append(translator.translate("String_Node_Str"));
        target.append("String_Node_Str");
        target.append("String_Node_Str");
    }
    if (table.isShowAllSelected() && (rows > resultsPerPage)) {
        target.append("String_Node_Str");
        target.append(A_CLASS).append("String_Node_Str").append(HREF_JAVA_SCRIPT_TABLE_FORM_INJECT_COMMAND_AND_SUBMIT);
        target.append(formName).append(SINGLE_COMMA_SINGLE).append(Table.COMMAND_PAGEACTION).append(SINGLE_COMMA_SINGLE).append(Table.COMMAND_SHOW_PAGES).append(CLOSE_AND_O2CLICK);
        target.append(translator.translate("String_Node_Str")).append("String_Node_Str");
        target.append("String_Node_Str");
    }
}

Output:
     if (table.isMultiSelect()) {
-        target.append("String_Node_Str");
-        target.append("String_Node_Str");
-        target.append("String_Node_Str").append(formName).append("String_Node_Str");
-        target.append("String_Node_Str");
-        target.append(translator.translate("String_Node_Str"));
-        target.append("String_Node_Str");
-        target.append("String_Node_Str").append(formName).append("String_Node_Str");
-        target.append("String_Node_Str");
-        target.append(translator.translate("String_Node_Str"));
-        target.append("String_Node_Str");
-        target.append("String_Node_Str");
+        target.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(formName).append("String_Node_Str").append("String_Node_Str").append(translator.translate("String_Node_Str")).append("String_Node_Str");
+        target.append("String_Node_Str").append(formName).append("String_Node_Str").append("String_Node_Str").append(translator.translate("String_Node_Str")).append("String_Node_Str").append("String_Node_Str");
     }


Input:
public void updateEffects() {
    for (Iterator<Effect> it = effects.iterator(); it.hasNext(); ) {
        Effect e = it.next();
        e.reduceDuration(0.05f);
        if (e.getDuration() <= 0)
            it.remove();
    }
}

Output:
         e.reduceDuration(0.05f);
-        if (e.getDuration() <= 0)
+        if (e.getDuration() <= 0) {
+            e.onEnd(this);
             it.remove();


Input:
private void ensurePropertyDefined(Node getprop, JSType rightType) {
    String propName = getprop.getLastChild().getString();
    Node obj = getprop.getFirstChild();
    JSType nodeType = getJSType(obj);
    ObjectType objectType = ObjectType.cast(nodeType.restrictByNotNullOrUndefined());
    if (objectType == null) {
        registry.registerPropertyOnType(propName, nodeType);
    } else {
        if (nodeType.isStruct() && !objectType.hasProperty(propName)) {
            if (!(obj.isThis() && getJSType(syntacticScope.getRootNode()).isConstructor())) {
                return;
            }
        }
        if (ensurePropertyDeclaredHelper(getprop, objectType)) {
            return;
        }
        if (!objectType.isPropertyTypeDeclared(propName)) {
            if (objectType.hasProperty(propName) || !objectType.isInstanceType()) {
                if ("String_Node_Str".equals(propName)) {
                    objectType.defineDeclaredProperty(propName, rightType, getprop);
                } else {
                    objectType.defineInferredProperty(propName, rightType, getprop);
                }
            } else if (obj.isThis() && getJSType(syntacticScope.getRootNode()).isConstructor()) {
                objectType.defineInferredProperty(propName, rightType, getprop);
            } else {
                registry.registerPropertyOnType(propName, objectType);
            }
        }
    }
}

Output:
         if (nodeType.isStruct() && !objectType.hasProperty(propName)) {
-            if (!(obj.isThis() && getJSType(syntacticScope.getRootNode()).isConstructor())) {
+            boolean staticPropCreation = false;
+            Node maybeAssignStm = getprop.getParent().getParent();
+            if (syntacticScope.isGlobal() && NodeUtil.isPrototypePropertyDeclaration(maybeAssignStm)) {
+                String propCreationFilename = maybeAssignStm.getSourceFileName();
+                Node ctor = objectType.getOwnerFunction().getSource();
+                if (ctor != null && ctor.getSourceFileName().equals(propCreationFilename)) {
+                    staticPropCreation = true;
+                }
+            }
+            if (!propCreationInConstructor && !staticPropCreation) {
                 return;


Input:
public void recordCount(String name, int count) {
    recordWithTime(name, count, now);
}

Output:
 public void recordCount(String name, int count) {
-    recordWithTime(name, count, now);
+    recordCountWithTime(name, count, now);
 }


Input:
private void addEditHeaders(HttpServletResponse resp, IHostedSite site, IPath path) {
    resp.addHeader("String_Node_Str", site.getEditServerUrl() + "String_Node_Str");
    resp.addHeader("String_Node_Str", path.toString());
}

Output:
     resp.addHeader("String_Node_Str", site.getEditServerUrl() + "String_Node_Str");
-    resp.addHeader("String_Node_Str", path.toString());
+    resp.addHeader("String_Node_Str", FILE_SERVLET_ALIAS + path.toString());
 }


Input:
public Object signWithPrivateKey(Object input, PrivateKey privateKey, String signAlgorithm) throws IllegalActionException {
    try {
        Signature signer = Signature.getInstance(signAlgorithm);
        signer.initSign(privateKey);
        signer.update(_toJavaBytes(input));
        return _toJSArray(signer.sign());
    } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
        throw new IllegalArgumentException("String_Node_Str" + e.getMessage());
    }
}

Output:
     } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
-        throw new IllegalArgumentException("String_Node_Str" + e.getMessage());
+        throw new IllegalArgumentException("String_Node_Str", e);
     }


Input:
public static int getKeyboardModifiers(Event event) {
    return (DOM.eventGetShiftKey(event) ? KeyboardListener.MODIFIER_SHIFT : 0) | (DOM.eventGetCtrlKey(event) ? KeyboardListener.MODIFIER_CTRL : 0) | (DOM.eventGetAltKey(event) ? KeyboardListener.MODIFIER_ALT : 0);
}

Output:
 public static int getKeyboardModifiers(Event event) {
-    return (DOM.eventGetShiftKey(event) ? KeyboardListener.MODIFIER_SHIFT : 0) | (DOM.eventGetCtrlKey(event) ? KeyboardListener.MODIFIER_CTRL : 0) | (DOM.eventGetAltKey(event) ? KeyboardListener.MODIFIER_ALT : 0);
+    return (DOM.eventGetShiftKey(event) ? KeyboardListener.MODIFIER_SHIFT : 0) | (DOM.eventGetMetaKey(event) ? KeyboardListener.MODIFIER_META : 0) | (DOM.eventGetCtrlKey(event) ? KeyboardListener.MODIFIER_CTRL : 0) | (DOM.eventGetAltKey(event) ? KeyboardListener.MODIFIER_ALT : 0);
 }


Input:
public static Object getElement(HttpResponse response, String elementName) throws IllegalStateException, IOException {
    JSONParser parser = new JSONParser();
    InputStream stream = response.getEntity().getContent();
    InputStreamReader is = new InputStreamReader(stream);
    ContainerFactory containerFactory = new ContainerFactory() {
        public List creatArrayContainer() {
            return new LinkedList();
        }
        public Map createObjectContainer() {
            return new LinkedHashMap();
        }
    };
    try {
        Map json = (Map) parser.parse(is, containerFactory);
        return json.get(elementName);
    } catch (ParseException pe) {
        System.err.println(pe.getMessage());
    } finally {
        stream.close();
        is.close();
    }
    return null;
}

Output:
     };
-    try {
-        Map json = (Map) parser.parse(is, containerFactory);
-        return json.get(elementName);
-    } catch (ParseException pe) {
-        System.err.println(pe.getMessage());
-    } finally {
-        stream.close();
-        is.close();
-    }
-    return null;
+    Map json = (Map) parser.parse(is, containerFactory);
+    return json.get(elementName);
 }


Input:
public boolean retainAll(final Collection<?> objects) {
    if (!useStack || objects.isEmpty()) {
        return false;
    }
    final List<String> list = stack.get();
    if (list == null || list.isEmpty()) {
        return false;
    }
    final List<String> copy = new ArrayList<String>(list);
    final boolean result = copy.retainAll(objects);
    stack.set(Collections.unmodifiableList(copy));
    return result;
}

Output:
     }
-    final List<String> list = stack.get();
-    if (list == null || list.isEmpty()) {
+    final MutableThreadContextStack values = stack.get();
+    if (values == null || values.isEmpty()) {
         return false;


Input:
public void testAddTestCaseResultsList() {
    Assume.assumeTrue(TestIntegrationSuite.destructiveTestsOk);
    Assume.assumeTrue(TestIntegrationSuite.testInstance != null);
    TestResults results = new TestResults();
    TestResult result1 = new TestResult();
    result1.setVerdict("String_Node_Str");
    result1.setTestId(TestIntegrationSuite.testInstance.getId());
    result1.setAssignedtoId(TestIntegrationSuite.assignedToId);
    result1.setComment("String_Node_Str");
    results.addResult(result1);
    TestResult result2 = new TestResult();
    result2.setTestId(TestIntegrationSuite.testInstance.getId());
    result2.setVerdict("String_Node_Str");
    result2.setAssignedtoId(TestIntegrationSuite.assignedToId);
    result2.setComment("String_Node_Str");
    results.addResult(result2);
    TestResult result3 = new TestResult();
    result3.setTestId(TestIntegrationSuite.testInstance.getId());
    result3.setVerdict("String_Node_Str");
    result3.setAssignedtoId(TestIntegrationSuite.assignedToId);
    result3.setComment("String_Node_Str");
    results.addResult(result3);
    try {
        TestIntegrationSuite.getService().addTestResults(TestIntegrationSuite.testRun.getId(), results);
    } catch (IOException e) {
        Assert.fail("String_Node_Str" + e);
    }
}

Output:
     results.addResult(result3);
-    try {
-        TestIntegrationSuite.getService().addTestResults(TestIntegrationSuite.testRun.getId(), results);
-    } catch (IOException e) {
-        Assert.fail("String_Node_Str" + e);
+    TestResults returnedResults = TestIntegrationSuite.getService().addTestResults(TestIntegrationSuite.testRun.getId(), results);
+    if (returnedResults == null) {
+        Assert.fail("String_Node_Str");
     }


Input:
public void easyShouldConquerVeryEasy() throws MapLoadException {
    holdBattleBetween(EPlayerType.AI_EASY, EPlayerType.AI_VERY_EASY, 125 * MINUTES);
}

Output:
 public void easyShouldConquerVeryEasy() throws MapLoadException {
-    holdBattleBetween(EPlayerType.AI_EASY, EPlayerType.AI_VERY_EASY, 125 * MINUTES);
+    holdBattleBetween(EPlayerType.AI_EASY, EPlayerType.AI_VERY_EASY, 100 * MINUTES);
 }


Input:
public boolean equals(Object obj) {
    if (obj == this)
        return true;
    if (obj instanceof GitModelWorkingTree) {
        GitModelCache left = (GitModelCache) obj;
        return left.getParent().equals(getParent());
    }
    return false;
}

Output:
         return true;
-    if (obj instanceof GitModelWorkingTree) {
-        GitModelCache left = (GitModelCache) obj;
-        return left.getParent().equals(getParent());
-    }
-    return false;
+    if (obj == null)
+        return false;
+    if (obj.getClass() != getClass())
+        return false;
+    GitModelCache left = (GitModelCache) obj;
+    return left.getParent().equals(getParent());
 }


Input:
private void copySearchParameters(ResourceDefn resource) {
    for (SearchParameterDefn sps : template.getSearchParams().values()) {
        if (hasPath(resource, sps.getPaths().get(0))) {
            SearchParameterDefn spt = new SearchParameterDefn(sps, template.getName(), resource.getName(), templateTitle);
            resource.getSearchParams().put(spt.getCode(), spt);
        }
    }
}

Output:
     for (SearchParameterDefn sps : template.getSearchParams().values()) {
-        if (hasPath(resource, sps.getPaths().get(0))) {
+        if (sps.getPaths().size() > 0 && hasPath(resource, sps.getPaths().get(0))) {
             SearchParameterDefn spt = new SearchParameterDefn(sps, template.getName(), resource.getName(), templateTitle);


Input:
void handleNoneRedoResponse(Invocation inv) {
    if (request.operation == OP_B_OFFER && inv.responseType == ResponseTypes.RESPONSE_SUCCESS) {
        if (!zeroBackup) {
            if (getPreviousMemberBefore(thisAddress, true, 1).getAddress().equals(inv.conn.getEndPoint())) {
                int itemIndex = (int) inv.longValue;
                if (itemIndex != -1) {
                    Q q = getQ(request.name);
                    if (request.value == null || request.value.size() == 0) {
                        throw new RuntimeException("String_Node_Str" + request.value);
                    }
                    q.doBackup(true, request.value, request.blockId, (int) inv.longValue);
                }
            }
        }
    }
    super.handleNoneRedoResponse(inv);
}

Output:
 void handleNoneRedoResponse(Invocation inv) {
-    if (request.operation == OP_B_OFFER && inv.responseType == ResponseTypes.RESPONSE_SUCCESS) {
+    if (request.operation == OP_B_POLL && inv.responseType == ResponseTypes.RESPONSE_SUCCESS) {
         if (!zeroBackup) {


Input:
public void setAllowSelectionLock(boolean lock) {
    this.allowSelectionLock = lock;
    this.timelineMouseListener.setAllowSelectionLock(lock);
    for (TimePlotInfo info : getAllTimePlots()) {
        info.getTimelineMouseListener().setAllowSelectionLock(lock);
    }
}

Output:
 public void setAllowSelectionLock(boolean lock) {
-    this.allowSelectionLock = lock;
-    this.timelineMouseListener.setAllowSelectionLock(lock);
-    for (TimePlotInfo info : getAllTimePlots()) {
-        info.getTimelineMouseListener().setAllowSelectionLock(lock);
+    this.lock.lock();
+    try {
+        this.allowSelectionLock = lock;
+        this.timelineMouseListener.setAllowSelectionLock(lock);
+        for (TimePlotInfo info : getAllTimePlots()) {
+            info.getTimelineMouseListener().setAllowSelectionLock(lock);
+        }
+    } finally {
+        this.lock.unlock();
     }


Input:
public boolean isIrreflexive(OWLObjectProperty property) {
    String query = "String_Node_Str" + property + "String_Node_Str" + OWL2.IrreflexiveProperty.getURI() + "String_Node_Str";
    return qef.createQueryExecution(query).execAsk();
}

Output:
 public boolean isIrreflexive(OWLObjectProperty property) {
-    String query = "String_Node_Str" + property + "String_Node_Str" + OWL2.IrreflexiveProperty.getURI() + "String_Node_Str";
+    String query = "String_Node_Str" + property.toStringID() + "String_Node_Str" + OWL2.IrreflexiveProperty.getURI() + "String_Node_Str";
     return qef.createQueryExecution(query).execAsk();


Input:
public boolean onTouchEvent(MotionEvent ev) {
    try {
        mScaleGestureDetector.onTouchEvent(ev);
    } catch (IllegalArgumentException e) {
    } catch (ArrayIndexOutOfBoundsException e) {
    }
    return super.onTouchEvent(ev);
}

Output:
     }
-    return super.onTouchEvent(ev);
+    if (ev.getPointerCount() == 1 && ev.getPointerId(0) == mSingleFingerEventPointerId)
+        return super.onTouchEvent(ev);
+    else
+        return false;
 }


Input:
public boolean apply(Game game, Ability source) {
    Spell spell = game.getStack().getSpell(source.getFirstTarget());
    if (spell != null) {
        Targets targets = spell.getSpellAbility().getTargets();
        if (targets.size() == 1 && targets.get(0).getTargets().size() == 1) {
            Target target = targets.get(0);
            if (target.canTarget(source.getSourceId(), game)) {
                target.clearChosen();
                target.add(source.getSourceId(), game);
            }
        } else {
            Player player = game.getPlayer(source.getControllerId());
            for (Target target : targets) {
                for (UUID targetId : target.getTargets()) {
                    MageObject object = game.getObject(targetId);
                    String name = null;
                    if (object == null) {
                        Player targetPlayer = game.getPlayer(targetId);
                        name = targetPlayer.getName();
                    } else {
                        name = object.getName();
                    }
                    if (name != null && player.chooseUse(Outcome.Neutral, "String_Node_Str" + name + "String_Node_Str", game)) {
                        if (target.canTarget(source.getSourceId(), game)) {
                            target.remove(targetId);
                            target.addTarget(source.getSourceId(), source, game);
                            break;
                        }
                    }
                }
            }
        }
    }
    return false;
}

Output:
 public boolean apply(Game game, Ability source) {
-    Spell spell = game.getStack().getSpell(source.getFirstTarget());
-    if (spell != null) {
-        Targets targets = spell.getSpellAbility().getTargets();
+    StackObject stackObject = game.getStack().getStackObject(source.getFirstTarget());
+    MageObject sourceObject = game.getObject(source.getSourceId());
+    if (stackObject != null && sourceObject != null) {
+        Targets targets;
+        MageObject oldTarget = null;
+        if (stackObject instanceof Spell) {
+            Spell spell = (Spell) stackObject;
+            targets = spell.getSpellAbility().getTargets();
+        } else if (stackObject instanceof StackAbility) {
+            StackAbility stackAbility = (StackAbility) stackObject;
+            targets = stackAbility.getTargets();
+        } else {
+            return false;
+        }
         if (targets.size() == 1 && targets.get(0).getTargets().size() == 1) {


Input:
public void applyLog(ReadableByteChannel byteChannel) throws IOException {
    logApplied = true;
    xaContainer.getLogicalLog().applyLog(byteChannel);
}

Output:
     logApplied = true;
-    xaContainer.getLogicalLog().applyLog(byteChannel);
+    super.applyLog(byteChannel);
 }


Input:
private String className(final Class<?> cls) {
    String className = cls.getName();
    checkClassNameIsInWhitelistedPackage(className);
    return className;
}

Output:
 private String className(final Class<?> cls) {
-    String className = cls.getName();
+    final String className = cls.getName();
     checkClassNameIsInWhitelistedPackage(className);


Input:
public static CheckForUpdateWorkflow forExistingFile(DownloadedFile existing, UpdateListener... listeners) {
    ArrayList<UpdateListener> listenerList = new ArrayList<>();
    listenerList.add(existing);
    for (UpdateListener l : listeners) {
        listenerList.add(l);
    }
    return new CheckForUpdateWorkflow(existing.getNewestFileName(), existing.getPageUrl(), existing.getUpdatedOn(), existing.getNewestFileName(), listenerList.toArray(new UpdateListener[listenerList.size()]));
}

Output:
     }
-    return new CheckForUpdateWorkflow(existing.getNewestFileName(), existing.getPageUrl(), existing.getUpdatedOn(), existing.getNewestFileName(), listenerList.toArray(new UpdateListener[listenerList.size()]));
+    return new CheckForUpdateWorkflow(existing.getNewestFileName(), existing.getPageUrl(), existing.getUpdatedOn(), existing.getNewestFileName(), onlyUpdateIfNewer, listenerList.toArray(new UpdateListener[listenerList.size()]));
 }


Input:
void parseResponse(JSONObject response) throws JSONException {
    GeoviewsModel model = new GeoviewsModel("String_Node_Str", response);
    assertEquals(model.getOtherViews(), 17);
    assertEquals(model.getTotalViews(), 55);
    assertNotNull(model.getCountries());
    assertEquals(model.getCountries().size(), 10);
    GeoviewModel first = model.getCountries().get(0);
    assertEquals(first.getCountryFullName(), "String_Node_Str");
    assertEquals(first.getFlagIconURL(), "String_Node_Str");
    assertEquals(first.getFlatFlagIconURL(), "String_Node_Str");
    assertEquals(first.getViews(), 8);
    GeoviewModel second = model.getCountries().get(1);
    assertEquals(second.getCountryFullName(), "String_Node_Str");
    assertEquals(second.getFlagIconURL(), "String_Node_Str");
    assertEquals(second.getFlatFlagIconURL(), "String_Node_Str");
    assertEquals(second.getViews(), 6);
}

Output:
 void parseResponse(JSONObject response) throws JSONException {
-    GeoviewsModel model = new GeoviewsModel("String_Node_Str", response);
+    GeoviewsModel model = new GeoviewsModel(123456, response);
     assertEquals(model.getOtherViews(), 17);


Input:
public AccountingSituation updateAccountingSituationCustomerAccount(AccountingSituation accountingSituation, boolean updateCustAccount, boolean updateDueCustAccount, boolean updateDueReminderCustAccount) {
    Partner partner = accountingSituation.getPartner();
    Company company = accountingSituation.getCompany();
    LOG.debug("String_Node_Str", partner.getName(), company.getName(), updateCustAccount, updateDueReminderCustAccount);
    if (updateCustAccount) {
        accountingSituation.setBalanceCustAccount(this.getBalance(partner, company));
    }
    if (updateDueCustAccount) {
        accountingSituation.setBalanceDueCustAccount(this.getBalanceDue(partner, company));
    }
    if (updateDueReminderCustAccount) {
        accountingSituation.setBalanceDueReminderCustAccount(this.getBalanceDueReminder(partner, company));
    }
    accountingSituation.setCustAccountMustBeUpdateOk(false);
    accountingSituationRepo.save(accountingSituation);
    return accountingSituation;
}

Output:
     accountingSituation.setCustAccountMustBeUpdateOk(false);
-    accountingSituationRepo.save(accountingSituation);
+    accountingSituationService.save(accountingSituation);
     return accountingSituation;


Input:
public boolean pathToGoal(Pawn pawn) {
    assert (pawns.contains(pawn));
    HashSet<Square> seen = new HashSet<Square>();
    int goalRow;
    if (pawn.getOwner().goalEnd() == Player.BOTTOM) {
        goalRow = 0;
    } else {
        goalRow = Board.ROWS - 1;
    }
    return localPathToGoal(pawn.getSquare(), seen, goalRow);
}

Output:
     int goalRow;
-    if (pawn.getOwner().goalEnd() == Player.BOTTOM) {
+    if (pawn.getOwner().goalEnd() == Player.TOP) {
         goalRow = 0;


Input:
public int size() {
    return proxy.size();
}

Output:
 public int size() {
-    return proxy.size();
+    return entrySet.size();
 }


Input:
public static boolean performDrop(AbstractTestCaseEditor targetEditor, IStructuredSelection toDrop, INodePO dropTarget, int dropPosition) {
    if (targetEditor.getEditorHelper().requestEditableState() != JBEditorHelper.EditableState.OK) {
        return false;
    }
    List<Object> selectedElements = toDrop.toList();
    Collections.reverse(selectedElements);
    Iterator iter = selectedElements.iterator();
    while (iter.hasNext()) {
        INodePO droppedNode = null;
        Object obj = iter.next();
        if (!(obj instanceof INodePO)) {
            return false;
        }
        INodePO node = (INodePO) obj;
        if (node instanceof ICapPO || node instanceof IExecTestCasePO) {
            INodePO target = dropTarget;
            if (target != node && (target instanceof ICapPO || target instanceof IExecTestCasePO)) {
                droppedNode = moveNode(node, target);
            }
        }
        if (node instanceof ISpecTestCasePO) {
            INodePO target = dropTarget;
            if (target != node) {
                try {
                    if (target instanceof ICapPO || target instanceof IExecTestCasePO) {
                        dropOnCAPorExecTc(node, target, dropPosition);
                    } else if (target instanceof ISpecTestCasePO) {
                        dropOnSpecTc(node, target);
                    } else if (node instanceof ISpecTestCasePO && target instanceof ITestSuitePO) {
                        dropOnTestsuite((ITestSuitePO) target, (ISpecTestCasePO) node);
                    }
                } catch (PMException e) {
                    NodeEditorInput inp = (NodeEditorInput) targetEditor.getAdapter(NodeEditorInput.class);
                    INodePO inpNode = inp.getNode();
                    PMExceptionHandler.handlePMExceptionForMasterSession(e);
                    if (!(e instanceof PMAlreadyLockedException && ((PMAlreadyLockedException) e).getLockedObject() != null && !((PMAlreadyLockedException) e).getLockedObject().equals(inpNode)) || !targetEditor.isDirty()) {
                        try {
                            targetEditor.reOpenEditor(inpNode);
                        } catch (PMException e1) {
                            PMExceptionHandler.handlePMExceptionForEditor(e, targetEditor);
                        }
                    }
                    return false;
                }
            }
        }
        postDropAction(droppedNode, targetEditor);
    }
    return true;
}

Output:
             }
-        }
-        if (node instanceof ISpecTestCasePO) {
-            INodePO target = dropTarget;
-            if (target != node) {
+        } catch (PMException e) {
+            NodeEditorInput inp = (NodeEditorInput) targetEditor.getAdapter(NodeEditorInput.class);
+            INodePO inpNode = inp.getNode();
+            PMExceptionHandler.handlePMExceptionForMasterSession(e);
+            if (!(e instanceof PMAlreadyLockedException && ((PMAlreadyLockedException) e).getLockedObject() != null && !((PMAlreadyLockedException) e).getLockedObject().equals(inpNode)) || !targetEditor.isDirty()) {
                 try {


Input:
public void setValue(Object value) {
    this.value = value;
}

Output:
 public void setValue(Object value) {
-    this.value = value;
+    setAttribute(VALUE_ATTR_NAME, value);
 }


Input:
static boolean compare(TemplateModel leftValue, Expression leftExp, int operator, String operatorString, TemplateModel rightValue, Expression rightExp, Expression defaultBlamed, boolean typeMismatchMeansNotEqual, boolean leftNullReturnsFalse, boolean rightNullReturnsFalse, Environment env) throws TemplateException {
    if (leftValue == null) {
        if (env != null && env.isClassicCompatible()) {
            leftValue = TemplateScalarModel.EMPTY_STRING;
        } else {
            if (leftNullReturnsFalse) {
                return false;
            } else {
                if (leftExp != null) {
                    leftExp.assertNonNull(leftValue);
                } else {
                    String desc = "String_Node_Str";
                    if (defaultBlamed != null) {
                        throw defaultBlamed.newTemplateException(desc);
                    } else {
                        throw new TemplateException(desc, env);
                    }
                }
            }
        }
    }
    if (rightValue == null) {
        if (env != null && env.isClassicCompatible()) {
            rightValue = TemplateScalarModel.EMPTY_STRING;
        } else {
            if (rightNullReturnsFalse) {
                return false;
            } else {
                if (rightExp != null) {
                    throw rightExp.newInvalidReferenceException();
                } else {
                    String msg = "String_Node_Str";
                    if (defaultBlamed != null) {
                        throw defaultBlamed.newTemplateException(msg);
                    } else {
                        throw new TemplateException(msg, env);
                    }
                }
            }
        }
    }
    final int cmpResult;
    if (leftValue instanceof TemplateNumberModel && rightValue instanceof TemplateNumberModel) {
        Number leftNum = EvaluationUtil.getNumber((TemplateNumberModel) leftValue, leftExp, env);
        Number rightNum = EvaluationUtil.getNumber((TemplateNumberModel) rightValue, rightExp, env);
        ArithmeticEngine ae = env != null ? env.getArithmeticEngine() : (leftExp != null ? leftExp.getTemplate().getArithmeticEngine() : ArithmeticEngine.BIGDECIMAL_ENGINE);
        try {
            cmpResult = ae.compareNumbers(leftNum, rightNum);
        } catch (RuntimeException e) {
            String desc = "String_Node_Str" + e;
            if (defaultBlamed != null) {
                throw defaultBlamed.newTemplateModelException(desc, e);
            } else {
                throw new TemplateModelException(desc, e);
            }
        }
    } else if (leftValue instanceof TemplateDateModel && rightValue instanceof TemplateDateModel) {
        TemplateDateModel leftDateModel = (TemplateDateModel) leftValue;
        TemplateDateModel rightDateModel = (TemplateDateModel) rightValue;
        int leftDateType = leftDateModel.getDateType();
        int rightDateType = rightDateModel.getDateType();
        if (leftDateType == TemplateDateModel.UNKNOWN || rightDateType == TemplateDateModel.UNKNOWN) {
            String sideName;
            Expression sideExp;
            if (leftDateType == TemplateDateModel.UNKNOWN) {
                sideName = "String_Node_Str";
                sideExp = leftExp;
            } else {
                sideName = "String_Node_Str";
                sideExp = rightExp;
            }
            String desc = "String_Node_Str" + sideName + "String_Node_Str" + DATE_OF_THE_COMPARISON_IS_OF_TYPE_UNKNOWN;
            if (sideExp != null) {
                throw sideExp.newTemplateException(desc, MessageUtil.UNKNOWN_DATE_TYPE_ERROR_TIPS);
            } else if (defaultBlamed != null) {
                throw defaultBlamed.newTemplateModelException(desc, MessageUtil.UNKNOWN_DATE_TYPE_ERROR_TIPS);
            } else {
                throw new TemplateException(desc, env);
            }
        }
        if (leftDateType != rightDateType) {
            String desc = "String_Node_Str" + TemplateDateModel.TYPE_NAMES.get(leftDateType) + "String_Node_Str" + TemplateDateModel.TYPE_NAMES.get(rightDateType) + "String_Node_Str";
            if (defaultBlamed != null) {
                throw defaultBlamed.newTemplateModelException(desc);
            } else {
                throw new TemplateException(desc, env);
            }
        }
        Date leftDate = EvaluationUtil.getDate(leftDateModel, leftExp, env);
        Date rightDate = EvaluationUtil.getDate(rightDateModel, rightExp, env);
        cmpResult = leftDate.compareTo(rightDate);
    } else if (leftValue instanceof TemplateScalarModel && rightValue instanceof TemplateScalarModel) {
        if (operator != CMP_OP_EQUALS && operator != CMP_OP_NOT_EQUALS) {
            String desc = "String_Node_Str" + cmpOpToString(operator, operatorString) + "String_Node_Str";
            if (defaultBlamed != null) {
                throw defaultBlamed.newTemplateModelException(desc);
            } else {
                throw new TemplateException(desc, env);
            }
        }
        String leftString = EvaluationUtil.getString((TemplateScalarModel) leftValue, leftExp, env);
        String rightString = EvaluationUtil.getString((TemplateScalarModel) rightValue, rightExp, env);
        cmpResult = env.getCollator().compare(leftString, rightString);
    } else if (leftValue instanceof TemplateBooleanModel && rightValue instanceof TemplateBooleanModel) {
        if (operator != CMP_OP_EQUALS && operator != CMP_OP_NOT_EQUALS) {
            String desc = "String_Node_Str" + cmpOpToString(operator, operatorString) + "String_Node_Str";
            if (defaultBlamed != null) {
                throw defaultBlamed.newTemplateModelException(desc);
            } else {
                throw new TemplateException(desc, env);
            }
        }
        boolean leftBool = ((TemplateBooleanModel) leftValue).getAsBoolean();
        boolean rightBool = ((TemplateBooleanModel) rightValue).getAsBoolean();
        cmpResult = (leftBool ? 1 : 0) - (rightBool ? 1 : 0);
    } else if (env.isClassicCompatible()) {
        String leftSting = leftExp.getStringValue(env);
        String rightString = rightExp.getStringValue(env);
        cmpResult = env.getCollator().compare(leftSting, rightString);
    } else {
        if (typeMismatchMeansNotEqual) {
            if (operator == CMP_OP_EQUALS) {
                return false;
            } else if (operator == CMP_OP_NOT_EQUALS) {
                return true;
            }
        }
        String desc = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + ClassUtil.getFTLTypeDescription(leftValue) + "String_Node_Str" + "String_Node_Str" + ClassUtil.getFTLTypeDescription(rightValue) + "String_Node_Str";
        if (defaultBlamed != null) {
            throw defaultBlamed.newTemplateModelException(desc);
        } else {
            throw new TemplateException(desc, env);
        }
    }
    switch(operator) {
        case CMP_OP_EQUALS:
            return cmpResult == 0;
        case CMP_OP_NOT_EQUALS:
            return cmpResult != 0;
        case CMP_OP_LESS_THAN:
            return cmpResult < 0;
        case CMP_OP_GREATER_THAN:
            return cmpResult > 0;
        case CMP_OP_LESS_THAN_EQUALS:
            return cmpResult <= 0;
        case CMP_OP_GREATER_THAN_EQUALS:
            return cmpResult >= 0;
        default:
            throw new RuntimeException("String_Node_Str" + operator);
    }
}

Output:
     } else if (env.isClassicCompatible()) {
-        String leftSting = leftExp.getStringValue(env);
-        String rightString = rightExp.getStringValue(env);
+        String leftSting = leftExp.getCoercedStringValue(env);
+        String rightString = rightExp.getCoercedStringValue(env);
         cmpResult = env.getCollator().compare(leftSting, rightString);


Input:
private static Date parseXSDateTime_parseMatcher(String dateTimeStr, Matcher m, TimeZone defaultTZ, CalendarFieldsToDateConverter calToDateConverter) throws DateParseException {
    try {
        try {
            int year = parseXS_groupToInt(m.group(1), "String_Node_Str", Integer.MIN_VALUE, Integer.MAX_VALUE);
            int era;
            if (year <= 0) {
                era = GregorianCalendar.BC;
                year = -year;
            } else {
                era = GregorianCalendar.AD;
            }
            int month = parseXS_groupToInt(m.group(2), "String_Node_Str", 1, 12) - 1;
            int day = parseXS_groupToInt(m.group(3), "String_Node_Str", 1, 31);
            int hours = parseXS_groupToInt(m.group(4), "String_Node_Str", 0, 24);
            boolean hourWas24;
            if (hours == 24) {
                hours = 0;
                hourWas24 = true;
            } else {
                hourWas24 = false;
            }
            int minutes = parseXS_groupToInt(m.group(5), "String_Node_Str", 0, 59);
            int secs = parseXS_groupToInt(m.group(6), "String_Node_Str", 0, 60);
            int millisecs = parseXS_groupToMillisecond(m.group(7));
            TimeZone tz = parseXS_parseTimeZone(m.group(8), defaultTZ);
            if (hourWas24) {
                if (minutes == 0 && secs == 0) {
                    day++;
                } else {
                    throw new DatePartParseException("String_Node_Str" + "String_Node_Str");
                }
            }
            return calToDateConverter.calculate(era, year, month, day, hours, minutes, secs, millisecs, tz);
        } catch (IllegalArgumentException e) {
            throw new DatePartParseException("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
        }
    } catch (DatePartParseException e) {
        throw parseXSDateTime_newExc(dateTimeStr, e.getMessage());
    }
}

Output:
             int era;
-            if (year <= 0) {
+            if (year == 0) {
+                throw new DateParseException(MSG_YEAR_0_NOT_ALLOWED);
+            }
+            if (year < 0) {
                 era = GregorianCalendar.BC;


Input:
public void testUpload64Attachment() throws IOException, URISyntaxException {
    RestConnection conn = new RestConnection();
    assertTrue(conn.login(id1.getName(), "String_Node_Str"));
    URI uri = getForumUriBuilder().path("String_Node_Str").path(m1.getKey().toString()).queryParam("String_Node_Str", id1.getKey()).queryParam("String_Node_Str", "String_Node_Str").queryParam("String_Node_Str", "String_Node_Str").build();
    HttpPut method = conn.createPut(uri, MediaType.APPLICATION_JSON, true);
    HttpResponse response = conn.execute(method);
    assertEquals(200, response.getStatusLine().getStatusCode());
    MessageVO message = conn.parse(response, MessageVO.class);
    assertNotNull(message);
    InputStream portraitStream = CoursesElementsTest.class.getResourceAsStream("String_Node_Str");
    assertNotNull(portraitStream);
    URI attachUri = getForumUriBuilder().path("String_Node_Str").path(message.getKey().toString()).path("String_Node_Str").build();
    byte[] portraitBytes = IOUtils.toByteArray(portraitStream);
    byte[] portrait64 = Base64.encodeBase64(portraitBytes, true);
    HttpPost attachMethod = conn.createPost(attachUri, MediaType.APPLICATION_JSON, true);
    attachMethod.addHeader("String_Node_Str", MediaType.APPLICATION_FORM_URLENCODED);
    conn.addEntity(attachMethod, new BasicNameValuePair("String_Node_Str", new String(portrait64)), new BasicNameValuePair("String_Node_Str", "String_Node_Str"));
    HttpResponse attachCode = conn.execute(attachMethod);
    assertEquals(200, attachCode.getStatusLine().getStatusCode());
    ForumManager fm = ForumManager.getInstance();
    VFSContainer container = fm.getMessageContainer(message.getForumKey(), message.getKey());
    VFSItem uploadedFile = container.resolve("String_Node_Str");
    assertNotNull(uploadedFile);
    assertTrue(uploadedFile instanceof VFSLeaf);
    VFSLeaf uploadedImage = (VFSLeaf) uploadedFile;
    InputStream uploadedStream = uploadedImage.getInputStream();
    BufferedImage image = ImageIO.read(uploadedStream);
    FileUtils.closeSafely(uploadedStream);
    assertNotNull(image);
    conn.shutdown();
}

Output:
     byte[] portrait64 = Base64.encodeBase64(portraitBytes, true);
-    HttpPost attachMethod = conn.createPost(attachUri, MediaType.APPLICATION_JSON, true);
+    HttpPost attachMethod = conn.createPost(attachUri, MediaType.APPLICATION_JSON);
     attachMethod.addHeader("String_Node_Str", MediaType.APPLICATION_FORM_URLENCODED);


Input:
private List<MetadataEntry> executeSearch(final String namespaceId, final String column, final String searchValue, final MetadataSearchTargetType type) {
    List<MetadataEntry> results = new LinkedList<>();
    Scanner scanner;
    String namespacedSearchValue = namespaceId + KEYVALUE_SEPARATOR + searchValue.toLowerCase();
    boolean modifiedTagsKVSearch = false;
    final String unmodifiedTagKeyValue = searchValue.toLowerCase();
    if (KEYVALUE_COLUMN.equals(column) && unmodifiedTagKeyValue.startsWith(TAGS_KEY + KEYVALUE_SEPARATOR)) {
        namespacedSearchValue = namespacedSearchValue.substring(0, namespacedSearchValue.lastIndexOf(KEYVALUE_SEPARATOR) + 1) + "String_Node_Str";
        modifiedTagsKVSearch = true;
    }
    if (namespacedSearchValue.endsWith("String_Node_Str")) {
        byte[] startKey = Bytes.toBytes(namespacedSearchValue.substring(0, namespacedSearchValue.lastIndexOf("String_Node_Str")));
        byte[] stopKey = Bytes.stopKeyForPrefix(startKey);
        scanner = indexedTable.scanByIndex(Bytes.toBytes(column), startKey, stopKey);
    } else {
        byte[] value = Bytes.toBytes(namespacedSearchValue);
        scanner = indexedTable.readByIndex(Bytes.toBytes(column), value);
    }
    try {
        Row next;
        while ((next = scanner.next()) != null) {
            String rowValue = next.getString(VALUE_COLUMN);
            if (rowValue == null) {
                continue;
            }
            final byte[] rowKey = next.getRow();
            String targetType = MdsValueKey.getTargetType(rowKey);
            if ((type != MetadataSearchTargetType.ALL) && (!targetType.equals(type.getInternalName()))) {
                continue;
            }
            if (modifiedTagsKVSearch) {
                boolean isMatch = false;
                if ((TAGS_KEY + KEYVALUE_SEPARATOR + "String_Node_Str").equals(unmodifiedTagKeyValue)) {
                    isMatch = true;
                } else {
                    Iterable<String> tagValues = Splitter.on(TAGS_SEPARATOR).omitEmptyStrings().trimResults().split(rowValue);
                    for (String tagValue : tagValues) {
                        String prefixedTagValue = TAGS_KEY + KEYVALUE_SEPARATOR + tagValue;
                        if (!unmodifiedTagKeyValue.endsWith("String_Node_Str")) {
                            if (prefixedTagValue.equals(unmodifiedTagKeyValue)) {
                                isMatch = true;
                                break;
                            }
                        } else {
                            int endAsteriskIndex = unmodifiedTagKeyValue.lastIndexOf("String_Node_Str");
                            if (prefixedTagValue.startsWith(unmodifiedTagKeyValue.substring(0, endAsteriskIndex))) {
                                isMatch = true;
                                break;
                            }
                        }
                    }
                }
                if (!isMatch) {
                    continue;
                }
            }
            Id.NamespacedId targetId = MdsValueKey.getNamespaceIdFromKey(targetType, new MDSKey(rowKey));
            String key = MdsValueKey.getMetadataKey(targetType, rowKey);
            String value = Bytes.toString(next.get(Bytes.toBytes(MetadataDataset.VALUE_COLUMN)));
            MetadataEntry entry = new MetadataEntry(targetId, key, value);
            results.add(entry);
        }
    } finally {
        scanner.close();
    }
    return results;
}

Output:
             }
-            Id.NamespacedId targetId = MdsValueKey.getNamespaceIdFromKey(targetType, new MDSKey(rowKey));
+            Id.NamespacedId targetId = MdsValueKey.getNamespaceIdFromKey(targetType, rowKey);
             String key = MdsValueKey.getMetadataKey(targetType, rowKey);


Input:
protected Liquibase createLiquibase() throws Exception {
    FileOpener antFO = new AntFileOpener(getProject(), classpath);
    FileOpener fsFO = new FileSystemFileOpener();
    Database database = createDatabaseObject(getDriver(), getUrl(), getUsername(), getPassword(), getDefaultSchemaName());
    Liquibase liquibase = new Liquibase(getChangeLogFile().trim(), new CompositeFileOpener(antFO, fsFO), database);
    liquibase.setCurrentDateTimeFunction(currentDateTimeFunction);
    return liquibase;
}

Output:
     Database database = createDatabaseObject(getDriver(), getUrl(), getUsername(), getPassword(), getDefaultSchemaName());
-    Liquibase liquibase = new Liquibase(getChangeLogFile().trim(), new CompositeFileOpener(antFO, fsFO), database);
+    String changeLogFile = null;
+    if (getChangeLogFile() != null) {
+        changeLogFile = getChangeLogFile().trim();
+    }
+    Liquibase liquibase = new Liquibase(changeLogFile, new CompositeFileOpener(antFO, fsFO), database);
     liquibase.setCurrentDateTimeFunction(currentDateTimeFunction);


Input:
public int calculate(Game game, Ability sourceAbility) {
    Card sourceCard = game.getCard(sourceAbility.getSourceId());
    if (sourceCard != null) {
        for (Object cost : sourceAbility.getCosts()) {
            if (cost instanceof SacrificeTargetCost) {
                Permanent p = (Permanent) game.getLastKnownInformation(((SacrificeTargetCost) cost).getPermanents().get(0).getId(), Constants.Zone.BATTLEFIELD);
                return -1 * p.getPower().getValue();
            }
        }
    }
    return 0;
}

Output:
             if (cost instanceof SacrificeTargetCost) {
-                Permanent p = (Permanent) game.getLastKnownInformation(((SacrificeTargetCost) cost).getPermanents().get(0).getId(), Constants.Zone.BATTLEFIELD);
+                Permanent p = (Permanent) game.getLastKnownInformation(((SacrificeTargetCost) cost).getPermanents().get(0).getId(), Zone.BATTLEFIELD);
                 return -1 * p.getPower().getValue();


Input:
public static ArrayToken map(FunctionToken function, ArrayToken array) {
    int num = function.getNumberOfArguments();
    ArrayToken result = null;
    if (BaseType.SCALAR.isCompatible(array.getElementType())) {
        if (num != 1) {
            throw new IllegalActionException("String_Node_Str");
        } else {
            for (int i = 0; i < array.length(); i++) {
                ScalarToken args = (ScalarToken) array.getElement(i);
                LinkedList arglist = new LinkedList();
                arglist.add(args);
                result.add(function.apply(arglist));
            }
        }
    } else {
        for (int i = 0; i < array.length(); i++) {
            ArrayToken args = (ArrayToken) array.getElement(i);
            LinkedList arglist = new LinkedList();
            if (args.length() != num) {
                throw new IllegalActionException("String_Node_Str");
            } else {
                for (int j = 1; j < num; j++) {
                    arglist.add(args.getElement(j));
                }
                result.add(function.apply(arglist));
            }
        }
    }
    return result;
}

Output:
     if (BaseType.SCALAR.isCompatible(array.getElementType())) {
-        if (num != 1) {
+        if (arity != 1) {
             throw new IllegalActionException("String_Node_Str");


Input:
private void generateSwitch(MethodWriter writer, boolean expr, Object frameType) throws BytecodeException {
    Label defaultLabel = null;
    int cases = 0;
    int low = Integer.MAX_VALUE;
    int high = Integer.MIN_VALUE;
    boolean switchVar = false;
    for (int i = 0; i < this.caseCount; i++) {
        MatchCase matchCase = this.cases[i];
        IPattern pattern = matchCase.pattern;
        Label label = matchCase.switchLabel = new Label();
        if (switchVar || pattern.switchCheck()) {
            switchVar = true;
        }
        if (pattern.isExhaustive()) {
            defaultLabel = label;
            continue;
        }
        int min = pattern.minValue();
        if (min < low) {
            low = min;
        }
        int max = pattern.maxValue();
        if (max > high) {
            high = max;
        }
        cases += pattern.switchCases();
    }
    Label endLabel = new Label();
    boolean matchError = false;
    if (defaultLabel == null) {
        if (!this.exhaustive) {
            switchVar = true;
            defaultLabel = new Label();
            matchError = true;
        } else {
            defaultLabel = endLabel;
        }
    }
    IType type = this.value.getType();
    this.value.writeExpression(writer, Types.INT);
    int varIndex = -1;
    if (switchVar) {
        varIndex = writer.localCount();
        writer.writeVarInsn(type.getStoreOpcode(), varIndex);
        writer.writeVarInsn(type.getLoadOpcode(), varIndex);
    }
    if (!type.isPrimitive()) {
        writer.writeInvokeInsn(Opcodes.INVOKEVIRTUAL, "String_Node_Str", "String_Node_Str", "String_Node_Str", false);
    }
    int localCount = writer.localCount();
    if (useTableSwitch(low, high, cases)) {
        this.writeTableSwitch(writer, defaultLabel, low, high);
    } else {
        this.writeLookupSwitch(writer, defaultLabel, cases);
    }
    for (int i = 0; i < this.caseCount; i++) {
        MatchCase matchCase = this.cases[i];
        writer.writeTargetLabel(matchCase.switchLabel);
        if (matchCase.condition != null) {
            matchCase.condition.writeInvJump(writer, defaultLabel);
        }
        if (matchCase.pattern.switchCheck()) {
            matchCase.pattern.writeInvJump(writer, varIndex, defaultLabel);
        }
        this.writeAction(writer, expr, frameType, matchCase.action);
        writer.resetLocals(localCount);
        writer.writeJumpInsn(Opcodes.GOTO, endLabel);
    }
    if (matchError) {
        writer.writeLabel(defaultLabel);
        this.writeMatchError(writer, varIndex, type);
    }
    writer.writeLabel(endLabel);
    if (switchVar) {
        writer.resetLocals(varIndex);
    }
}

Output:
     IType type = this.value.getType();
-    this.value.writeExpression(writer, Types.INT);
+    this.value.writeExpression(writer);
     int varIndex = -1;


Input:
public SocketAddress getSocketAddress() {
    if (conn instanceof TcpIpConnection) {
        return ((TcpIpConnection) conn).getSocketChannelWrapper().socket().getRemoteSocketAddress();
    }
    return null;
}

Output:
 public SocketAddress getSocketAddress() {
-    if (conn instanceof TcpIpConnection) {
-        return ((TcpIpConnection) conn).getSocketChannelWrapper().socket().getRemoteSocketAddress();
-    }
-    return null;
+    return socketAddress;
 }


Input:
public Object getValueAt(int rowIndex, int columnIndex) {
    Event event = getEventAt(rowIndex);
    Object value = null;
    switch(columnIndex) {
        case 0:
            value = TableUtils.getFormatedDateTime(event.getTimestamp());
            ;
            break;
        case 1:
            value = TableUtils.getInvokedBy(event);
            break;
        case 2:
            value = TableUtils.getService(event);
            break;
        case 3:
            value = event.getEventName();
            break;
        case 4:
            value = ResourceLookup.getResourceInfo(event).getTypes();
            break;
        case 5:
            value = ResourceLookup.getResourceInfo(event).getNames();
            break;
        case 6:
            value = event.getEventVersion();
            break;
        case 7:
            value = event.getAwsRegion();
            break;
        case 8:
            value = event.getSourceIPAddress();
            break;
        case 9:
            value = event.getUserAgent();
            break;
        case 10:
            value = event.getErrorCode();
            break;
        case 11:
            value = event.getErrorMessage();
            break;
        case 12:
            value = event.getRequestId();
            break;
        case 13:
            value = event.getEventId();
            break;
        case 14:
            value = event.getEventType();
            break;
        case 15:
            value = event.getApiVersion();
            break;
    }
    return value;
}

Output:
         case 9:
-            value = event.getUserAgent();
+            value = event.getEventSource();
             break;


Input:
private static Map<String, ExchangeRate> requestExchangeRates(final URL url, final String... fields) {
    final long start = System.currentTimeMillis();
    HttpURLConnection connection = null;
    Reader reader = null;
    try {
        Double btcRate = 0.0;
        boolean cryptsyValue = true;
        Object result = getCoinValueBTC();
        if (result == null) {
            result = getCoinValueBTC_BTER();
            cryptsyValue = false;
            if (result == null)
                return null;
        }
        btcRate = (Double) result;
        connection = (HttpURLConnection) url.openConnection();
        connection.setConnectTimeout(Constants.HTTP_TIMEOUT_MS);
        connection.setReadTimeout(Constants.HTTP_TIMEOUT_MS);
        connection.connect();
        final int responseCode = connection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            reader = new InputStreamReader(new BufferedInputStream(connection.getInputStream(), 1024), Constants.UTF_8);
            final StringBuilder content = new StringBuilder();
            Io.copy(reader, content);
            final Map<String, ExchangeRate> rates = new TreeMap<String, ExchangeRate>();
            final JSONObject head = new JSONObject(content.toString());
            for (final Iterator<String> i = head.keys(); i.hasNext(); ) {
                final String currencyCode = i.next();
                if (!"String_Node_Str".equals(currencyCode)) {
                    final JSONObject o = head.getJSONObject(currencyCode);
                    for (final String field : fields) {
                        String rateStr = o.optString(field, null);
                        if (rateStr != null) {
                            try {
                                double rateForBTC = Double.parseDouble(rateStr);
                                rateStr = String.format("String_Node_Str", rateForBTC * btcRate);
                                final BigInteger rate = GenericUtils.toNanoCoins(rateStr, 0);
                                if (rate.signum() > 0) {
                                    rates.put(currencyCode, new ExchangeRate(currencyCode, rate, url.getHost()));
                                    break;
                                }
                            } catch (final ArithmeticException x) {
                                log.warn("String_Node_Str", new Object[] { currencyCode, url, x.getMessage() });
                            }
                        }
                    }
                }
            }
            log.info("String_Node_Str", url, (System.currentTimeMillis() - start));
            if (rates.size() == 0) {
                int i = 0;
                i++;
            } else {
                rates.put(CoinDefinition.cryptsyMarketCurrency, new ExchangeRate(CoinDefinition.cryptsyMarketCurrency, GenericUtils.toNanoCoins(String.format("String_Node_Str", btcRate).replace("String_Node_Str", "String_Node_Str"), 0), cryptsyValue ? "String_Node_Str" : "String_Node_Str"));
                rates.put("String_Node_Str" + CoinDefinition.cryptsyMarketCurrency, new ExchangeRate("String_Node_Str" + CoinDefinition.cryptsyMarketCurrency, GenericUtils.toNanoCoins(String.format("String_Node_Str", btcRate * 1000).replace("String_Node_Str", "String_Node_Str"), 0), cryptsyValue ? "String_Node_Str" : "String_Node_Str"));
            }
            return rates;
        } else {
            log.warn("String_Node_Str", responseCode, url);
        }
    } catch (final Exception x) {
        log.warn("String_Node_Str" + url, x);
    } finally {
        if (reader != null) {
            try {
                reader.close();
            } catch (final IOException x) {
            }
        }
        if (connection != null)
            connection.disconnect();
    }
    return null;
}

Output:
                                 double rateForBTC = Double.parseDouble(rateStr);
-                                rateStr = String.format("String_Node_Str", rateForBTC * btcRate);
+                                rateStr = String.format("String_Node_Str", rateForBTC * btcRate).replace("String_Node_Str", "String_Node_Str");
                                 final BigInteger rate = GenericUtils.toNanoCoins(rateStr, 0);


Input:
public void close() throws SQLException {
    cols = null;
    colsMeta = null;
    meta = null;
    open = false;
    limitRows = 0;
    row = 0;
    lastCol = -1;
    columnNameToIndex = null;
    if (stmt == null) {
        return;
    }
    if (stmt != null && stmt.pointer != 0) {
        db.reset(stmt.pointer);
        if (closeStmt) {
            closeStmt = false;
            ((Statement) stmt).close();
        }
    }
}

Output:
     columnNameToIndex = null;
-    if (stmt == null) {
-        return;
-    }
-    if (stmt != null && stmt.pointer != 0) {
-        db.reset(stmt.pointer);
-        if (closeStmt) {
-            closeStmt = false;
-            ((Statement) stmt).close();
+    synchronized (db) {
+        if (stmt == null) {
+            return;
+        }
+        if (stmt != null && stmt.pointer != 0) {
+            db.reset(stmt.pointer);
+            if (closeStmt) {
+                closeStmt = false;
+                ((Statement) stmt).close();
+            }
         }


Input:
public void testAddAmendmentController() throws Exception {
    final ClientFactory clientFactory = new ClientFactoryMock();
    final AmendmentView amendmentView = new AmendmentViewImpl(null);
    final AmendmentView amendmentViewExtended = new AmendmentViewImpl(null);
    final OverlayWidget overlayWidget = new OverlayWidgetImpl();
    final AmendmentController amendmentController = new DefaultAmendmentController(amendmentView, amendmentViewExtended, null);
    overlayWidget.addAmendmentController(amendmentController);
    Assert.assertTrue(Arrays.asList(overlayWidget.getAmendmentControllers()).contains(amendmentController));
}

Output:
     final OverlayWidget overlayWidget = new OverlayWidgetImpl();
-    final AmendmentController amendmentController = new DefaultAmendmentController(amendmentView, amendmentViewExtended, null);
+    final AmendmentController amendmentController = new DefaultAmendmentController(amendmentView, amendmentViewExtended);
     overlayWidget.addAmendmentController(amendmentController);


Input:
public <T> T get(String name) {
    return sMap.get(makeKey(name));
}

Output:
 public <T> T get(String name) {
-    return sMap.get(makeKey(name));
+    return (T) sMap.get(makeKey(name));
 }


Input:
private void createNode() {
    this.Node = new ShapeObjectType(this.notationSubsystem.getSyntaxService(), NODE_UID, NODE_NAME);
    this.Node.setDescription(NODE_DESCN);
    this.Node.getDefaultAttributes().setShapeType(PrimitiveShapeType.ELLIPSE);
    this.Node.getDefaultAttributes().setFillColour(new RGB(255, 255, 255));
    this.Node.getDefaultAttributes().setSize(new Size(50, 50));
    this.Node.getDefaultAttributes().setLineColour(new RGB(0, 0, 0));
    this.Node.getDefaultAttributes().setLineStyle(LineStyle.SOLID);
    this.Node.getDefaultAttributes().setLineWidth(1);
    this.Node.getDefaultAttributes().setUrl("String_Node_Str");
    EnumSet<EditableShapeAttributes> editableAttributes = EnumSet.noneOf(EditableShapeAttributes.class);
    editableAttributes.add(EditableShapeAttributes.FILL_COLOUR);
    editableAttributes.add(EditableShapeAttributes.LINE_STYLE);
    editableAttributes.add(EditableShapeAttributes.LINE_WIDTH);
    editableAttributes.add(EditableShapeAttributes.LINE_COLOUR);
    this.Node.setEditableAttributes(editableAttributes);
}

Output:
 private void createNode() {
-    this.Node = new ShapeObjectType(this.notationSubsystem.getSyntaxService(), NODE_UID, NODE_NAME);
-    this.Node.setDescription(NODE_DESCN);
-    this.Node.getDefaultAttributes().setShapeType(PrimitiveShapeType.ELLIPSE);
-    this.Node.getDefaultAttributes().setFillColour(new RGB(255, 255, 255));
-    this.Node.getDefaultAttributes().setSize(new Size(50, 50));
-    this.Node.getDefaultAttributes().setLineColour(new RGB(0, 0, 0));
-    this.Node.getDefaultAttributes().setLineStyle(LineStyle.SOLID);
-    this.Node.getDefaultAttributes().setLineWidth(1);
-    this.Node.getDefaultAttributes().setUrl("String_Node_Str");
+    this.node = new ShapeObjectType(this, NODE_UID, NODE_NAME);
+    this.node.setDescription(NODE_DESCN);
+    this.node.getDefaultAttributes().setDescription("String_Node_Str");
+    this.node.getDefaultAttributes().setDetailedDescription("String_Node_Str");
+    this.node.getDefaultAttributes().setName("String_Node_Str");
+    this.node.getDefaultAttributes().setShapeType(PrimitiveShapeType.ELLIPSE);
+    this.node.getDefaultAttributes().setFillColour(new RGB(255, 255, 255));
+    this.node.getDefaultAttributes().setSize(new Size(50, 50));
+    this.node.getDefaultAttributes().setLineColour(new RGB(0, 0, 0));
+    this.node.getDefaultAttributes().setLineStyle(LineStyle.SOLID);
+    this.node.getDefaultAttributes().setLineWidth(1);
+    this.node.getDefaultAttributes().setUrl("String_Node_Str");
     EnumSet<EditableShapeAttributes> editableAttributes = EnumSet.noneOf(EditableShapeAttributes.class);


Input:
public void entityAdded(GameMap m, Entity e) {
    EntityWidget w = new EntityWidget(scene, e);
    scene.addChild(w);
    scene.repaint();
    scene.addObject(e, w);
}

Output:
     scene.addChild(w);
-    scene.repaint();
+    scene.validate();
     scene.addObject(e, w);


Input:
public boolean onCommand(CommandSender sender, Command parentCommand, String label, String[] args) {
    PermissionsHandler permissionsHandler = plugin.getPermissionsHandler();
    sender.sendMessage(ChatColor.GREEN + String.format("String_Node_Str", plugin.getDescription().getName(), plugin.getDescription().getVersion()));
    Collection<SubCommandExecutor> commands = ((PortCommandExecutor) this.parent).getSubCommands().values();
    for (SubCommandExecutor command : commands) {
        Permission permission = command.getRequiredPermission();
        if (permission == null || permissionsHandler.hasPermission(sender, permission)) {
            String helpLine = String.format("String_Node_Str", ChatColor.GRAY, command.getUsage().replace("String_Node_Str", label), ChatColor.WHITE, command.getDescription());
            sender.sendMessage(helpLine);
        }
    }
    sender.sendMessage("String_Node_Str");
    sender.sendMessage(ChatColor.WHITE + "String_Node_Str");
    return true;
}

Output:
     sender.sendMessage(ChatColor.GREEN + String.format("String_Node_Str", plugin.getDescription().getName(), plugin.getDescription().getVersion()));
-    Collection<SubCommandExecutor> commands = ((PortCommandExecutor) this.parent).getSubCommands().values();
-    for (SubCommandExecutor command : commands) {
-        Permission permission = command.getRequiredPermission();
+    Map<String, SubCommandExecutor> commandMap = ((PortCommandExecutor) this.parent).getSubCommands();
+    List<String> commands = new LinkedList<String>(commandMap.keySet());
+    Collections.sort(commands);
+    for (String command : commands) {
+        SubCommandExecutor commandExecutor = commandMap.get(command);
+        Permission permission = commandExecutor.getRequiredPermission();
         if (permission == null || permissionsHandler.hasPermission(sender, permission)) {


Input:
public boolean handleWithCloudProviderInterface(TemplatePlanContext context, AbstractNodeTemplate nodeTemplate) {
    AbstractNodeTemplate ubuntuNodeTemplate = this.findUbuntuNode(nodeTemplate);
    Variable ubuntuAMIIdVar = null;
    if (ubuntuNodeTemplate == null) {
        LOG.error("String_Node_Str");
        return false;
    }
    if (this.isUbuntuNodeTypeWithImplicitImage(ubuntuNodeTemplate.getType().getId())) {
        ubuntuAMIIdVar = context.createGlobalStringVariable("String_Node_Str", this.createUbuntuImageStringFromNodeType(ubuntuNodeTemplate.getType().getId()));
    }
    LOG.debug("String_Node_Str" + ubuntuNodeTemplate.getId() + "String_Node_Str" + ubuntuNodeTemplate.getType().getId().toString());
    Variable instanceIdPropWrapper = null;
    for (String instanceIdName : org.opentosca.model.tosca.conventions.Utils.getSupportedVirtualMachineInstanceIdPropertyNames()) {
        instanceIdPropWrapper = context.getPropertyVariable(ubuntuNodeTemplate, instanceIdName);
        if (instanceIdPropWrapper == null) {
            instanceIdPropWrapper = context.getPropertyVariable(instanceIdName, true);
        } else {
            break;
        }
    }
    if (instanceIdPropWrapper == null) {
        Handler.LOG.warn("String_Node_Str");
        return false;
    }
    Variable serverIpPropWrapper = null;
    for (String vmIpName : org.opentosca.model.tosca.conventions.Utils.getSupportedVirtualMachineIPPropertyNames()) {
        serverIpPropWrapper = context.getPropertyVariable(ubuntuNodeTemplate, vmIpName);
        if (serverIpPropWrapper == null) {
            serverIpPropWrapper = context.getPropertyVariable(vmIpName, true);
        } else {
            break;
        }
    }
    if (serverIpPropWrapper == null) {
        Handler.LOG.warn("String_Node_Str");
        return false;
    }
    Variable sshUserVariable = null;
    for (String userName : org.opentosca.model.tosca.conventions.Utils.getSupportedVirtualMachineLoginUserNamePropertyNames()) {
        sshUserVariable = context.getPropertyVariable(ubuntuNodeTemplate, userName);
        if (sshUserVariable == null) {
            sshUserVariable = context.getPropertyVariable(userName, true);
        } else {
            break;
        }
    }
    if (sshUserVariable == null) {
        return false;
    } else {
        if (Utils.isVariableValueEmpty(sshUserVariable, context)) {
            LOG.debug("String_Node_Str");
            context.addStringValueToPlanRequest(Properties.OPENTOSCA_DECLARATIVE_PROPERTYNAME_VMLOGINNAME);
            context.addAssignFromInput2VariableToMainAssign(Properties.OPENTOSCA_DECLARATIVE_PROPERTYNAME_VMLOGINNAME, sshUserVariable);
            sshUserVariable = null;
        }
    }
    Variable sshKeyVariable = null;
    for (String passwordName : org.opentosca.model.tosca.conventions.Utils.getSupportedVirtualMachineLoginPasswordPropertyNames()) {
        sshKeyVariable = context.getPropertyVariable(ubuntuNodeTemplate, passwordName);
        if (sshKeyVariable == null) {
            sshKeyVariable = context.getPropertyVariable(passwordName, true);
        } else {
            break;
        }
    }
    if (sshKeyVariable == null) {
        return false;
    } else {
        if (Utils.isVariableValueEmpty(sshKeyVariable, context)) {
            LOG.debug("String_Node_Str");
            context.addStringValueToPlanRequest(Properties.OPENTOSCA_DECLARATIVE_PROPERTYNAME_VMLOGINPASSWORD);
            context.addAssignFromInput2VariableToMainAssign(Properties.OPENTOSCA_DECLARATIVE_PROPERTYNAME_VMLOGINPASSWORD, sshKeyVariable);
            sshKeyVariable = null;
        }
    }
    LOG.debug("String_Node_Str");
    context.addStringValueToPlanRequest("String_Node_Str");
    LOG.debug("String_Node_Str");
    context.addStringValueToPlanRequest("String_Node_Str");
    Map<String, Variable> createEC2InternalExternalPropsInput = new HashMap<String, Variable>();
    for (String externalParameter : Handler.createVMInstanceExternalInputParams) {
        Variable variable = context.getPropertyVariable(ubuntuNodeTemplate, externalParameter);
        if (variable == null) {
            variable = context.getPropertyVariable(externalParameter, true);
        }
        if (externalParameter.equals("String_Node_Str") && ubuntuAMIIdVar != null) {
            createEC2InternalExternalPropsInput.put(externalParameter, ubuntuAMIIdVar);
            continue;
        }
        if (variable == null) {
            Handler.LOG.warn("String_Node_Str" + externalParameter);
            return false;
        } else {
            Handler.LOG.debug("String_Node_Str" + externalParameter);
        }
        if (Utils.isVariableValueEmpty(variable, context)) {
            Handler.LOG.debug("String_Node_Str");
            createEC2InternalExternalPropsInput.put(externalParameter, null);
        } else {
            createEC2InternalExternalPropsInput.put(externalParameter, variable);
        }
    }
    Map<String, Variable> createEC2InternalExternalPropsOutput = new HashMap<String, Variable>();
    createEC2InternalExternalPropsOutput.put(Properties.OPENTOSCA_DECLARATIVE_PROPERTYNAME_VMINSTANCEID, instanceIdPropWrapper);
    createEC2InternalExternalPropsOutput.put(Properties.OPENTOSCA_DECLARATIVE_PROPERTYNAME_VMIP, serverIpPropWrapper);
    context.addStringValueToPlanRequest("String_Node_Str");
    this.invokerOpPlugin.handle(context, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_CLOUDPROVIDER_CREATEVM, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_CLOUDPROVIDER, "String_Node_Str", createEC2InternalExternalPropsInput, createEC2InternalExternalPropsOutput);
    Map<String, Variable> startRequestInputParams = new HashMap<String, Variable>();
    Map<String, Variable> startRequestOutputParams = new HashMap<String, Variable>();
    startRequestInputParams.put("String_Node_Str", serverIpPropWrapper);
    startRequestInputParams.put("String_Node_Str", sshUserVariable);
    startRequestInputParams.put("String_Node_Str", sshKeyVariable);
    startRequestOutputParams.put("String_Node_Str", context.createGlobalStringVariable("String_Node_Str", "String_Node_Str"));
    this.invokerOpPlugin.handle(context, ubuntuNodeTemplate.getId(), true, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_OPERATINGSYSTEM_WAITFORAVAIL, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_OPERATINGSYSTEM, "String_Node_Str", startRequestInputParams, startRequestOutputParams, false);
    return true;
}

Output:
     context.addStringValueToPlanRequest("String_Node_Str");
-    this.invokerOpPlugin.handle(context, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_CLOUDPROVIDER_CREATEVM, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_CLOUDPROVIDER, "String_Node_Str", createEC2InternalExternalPropsInput, createEC2InternalExternalPropsOutput);
+    this.invokerOpPlugin.handle(context, cloudProviderNodeTemplate.getId(), true, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_CLOUDPROVIDER_CREATEVM, Interfaces.OPENTOSCA_DECLARATIVE_INTERFACE_CLOUDPROVIDER, "String_Node_Str", createEC2InternalExternalPropsInput, createEC2InternalExternalPropsOutput, false);
     Map<String, Variable> startRequestInputParams = new HashMap<String, Variable>();