Input:
private void visit(IMethodModel m, String path) {
    boolean hasPath = m.hasAnnotation(PATH);
    if (hasPath) {
        String localPath = m.getAnnotationValue(PATH);
        if (path.endsWith("String_Node_Str")) {
            if (localPath.startsWith("String_Node_Str")) {
                localPath = localPath.substring(1);
            }
        }
        path += localPath;
    }
    boolean isWs = hasPath;
    for (ActionType q : ActionType.values()) {
        boolean hasAnnotation = m.hasAnnotation(q.name());
        isWs |= hasAnnotation;
    }
    if (isWs) {
        Resource res = new Resource();
        IDocInfo documentation = getDocumentation(m);
        String returnName = null;
        String parameterName = null;
        ITypeModel returnedType = m.getReturnedType();
        if (returnedType != null) {
            if (returnedType.hasAnnotation(XML_ROOT_ELEMENT)) {
                generateXMLSchema(returnedType, null);
                returnName = returnedType.getName().toLowerCase();
            }
            if (hasPath) {
                if (consumedTypes.add(returnedType)) {
                    ResourceVisitor resourceVisitor = createResourceVisitor();
                    resourceVisitor.consumedTypes.addAll(this.consumedTypes);
                    resourceVisitor.basePath = path;
                    resourceVisitor.spec = this.spec;
                    resourceVisitor.visit(returnedType);
                }
            }
        }
        ITypeModel bodyType = m.getBodyType();
        if (bodyType != null) {
            if (bodyType.hasAnnotation(XML_ROOT_ELEMENT)) {
                generateXMLSchema(bodyType, null);
                parameterName = bodyType.getName().toLowerCase();
            }
        }
        if (path.endsWith("String_Node_Str")) {
            res.setRelativeUri(path.substring(0, path.length() - 1));
        } else {
            res.setRelativeUri(path);
        }
        for (ActionType q : ActionType.values()) {
            boolean hasAnnotation = m.hasAnnotation(q.name());
            if (hasAnnotation) {
                addMethod(q, res, m, documentation, returnName, parameterName);
            }
        }
        spec.addResource(res);
    }
}

Output:
             if (returnedType.hasAnnotation(XML_ROOT_ELEMENT)) {
-                generateXMLSchema(returnedType, null);
+                gotBodySchemesAndExamples |= generateXMLSchema(returnedType, null);
                 returnName = returnedType.getName().toLowerCase();


Input:
public static boolean assertSameHtml(String actualString, String expectedString) throws SAXException, IOException, TransformerException {
    actualString = preProcessHtml(actualString);
    expectedString = preProcessHtml(expectedString);
    Node actualPage = getNodeFromString(actualString);
    Node expectedPage = getNodeFromString(expectedString);
    eliminateEmptyTextNodes(actualPage);
    eliminateEmptyTextNodes(expectedPage);
    StringBuilder expectedHTML = new StringBuilder();
    StringBuilder actualHTML = new StringBuilder();
    boolean isLogicalMatch = compare(actualPage, expectedPage, "String_Node_Str", expectedHTML, actualHTML);
    if (!isLogicalMatch) {
        assertEquals("String_Node_Str", expectedHTML.toString(), actualHTML.toString());
    }
    return isLogicalMatch;
}

Output:
     StringBuilder actualHTML = new StringBuilder();
-    boolean isLogicalMatch = compare(actualPage, expectedPage, "String_Node_Str", expectedHTML, actualHTML);
+    boolean isLogicalMatch = compare(actualPage, expectedPage, "String_Node_Str", actualHTML, expectedHTML);
     if (!isLogicalMatch) {


Input:
public void onScanResultsReady() {
    wifiLog("String_Node_Str");
    unregisterReceiver(mContext, mWifiScanReceiver);
    final List<ScanResult> scanResultList = mWifiManager.getScanResults();
    of(mScanResultsListener).ifPresent(resultsListener -> resultsListener.onScanResults(scanResultList));
    of(mConnectionScanResultsListener).ifPresent(connectionResultsListener -> mSingleScanResult = connectionResultsListener.onConnectWithScanResult(scanResultList));
    if (mConnectionWpsListener != null && mBssid != null && mPassword != null) {
        mSingleScanResult = matchScanResultBssid(mBssid, scanResultList);
        if (mSingleScanResult != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
            connectWps(mWifiManager, mSingleScanResult, mPassword, mWpsTimeoutMillis, mConnectionWpsListener);
        else {
            if (mSingleScanResult == null)
                wifiLog("String_Node_Str");
            mConnectionWpsListener.isSuccessful(false);
        }
        return;
    }
    if (mSsid != null) {
        if (mBssid != null)
            mSingleScanResult = matchScanResult(mSsid, mBssid, scanResultList);
        else
            mSingleScanResult = matchScanResultSsid(mSsid, scanResultList);
    }
    if (mSingleScanResult != null && mPassword != null) {
        if (isAlreadyConnected(mWifiManager, mSingleScanResult.BSSID)) {
            mWifiConnectionCallback.successfulConnect();
            return;
        }
        if (connectToWifi(mContext, mWifiManager, mSingleScanResult, mPassword))
            registerReceiver(mContext, mWifiConnectionReceiver.activateTimeoutHandler(mSingleScanResult), new IntentFilter(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION));
        else
            mWifiConnectionCallback.errorConnect();
    } else
        mWifiConnectionCallback.errorConnect();
}

Output:
     if (mSingleScanResult != null && mPassword != null) {
-        if (isAlreadyConnected(mWifiManager, mSingleScanResult.BSSID)) {
-            mWifiConnectionCallback.successfulConnect();
-            return;
-        }
-        if (connectToWifi(mContext, mWifiManager, mSingleScanResult, mPassword))
+        if (connectToWifi(mContext, mWifiManager, mSingleScanResult, mPassword)) {
             registerReceiver(mContext, mWifiConnectionReceiver.activateTimeoutHandler(mSingleScanResult), new IntentFilter(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION));


Input:
public void animateLift() {
    if (animCounter < 4) {
        revert();
        loc.add(0, 1, 0);
        if (animCounter == 0) {
            int totalBendableBlocks = 0;
            for (int x = -1; x <= 1; x++) for (int y = -2; y <= -1; y++) for (int z = -1; z <= 1; z++) {
                Block block = loc.clone().add(x, y, z).getBlock();
                if (GeneralMethods.isRegionProtectedFromBuild(player, "String_Node_Str", block.getLocation())) {
                    remove();
                    return;
                }
                if (isEarthbendableMaterial(block.getType()))
                    totalBendableBlocks++;
            }
            if (totalBendableBlocks < REQUIRED_BENDABLE_BLOCKS) {
                remove();
                return;
            }
            for (int y = 0; y <= 3; y++) {
                Block tempBlock = loc.clone().add(0, y, 0).getBlock();
                if (!EarthMethods.isTransparentToEarthbending(player, tempBlock) && tempBlock.getType() != Material.AIR) {
                    remove();
                    return;
                }
            }
            Location tempLoc = loc.clone().add(0, -2, 0);
            for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++) for (int z = -1; z <= 1; z++) if ((Math.abs(x) + Math.abs(y) + Math.abs(z)) % 2 == 0) {
                Block block = tempLoc.clone().add(x, y, z).getBlock();
                currentBlocks.add(new BlockRepresenter(x, y, z, selectMaterialForRepresenter(block.getType()), block.getData()));
            }
            for (int x = -1; x <= 1; x++) for (int z = -1; z <= 1; z++) {
                if ((Math.abs(x) + Math.abs(z)) % 2 == 1) {
                    Block block = loc.clone().add(x, -2, z).getBlock();
                    if (isEarthbendableMaterial(block.getType()))
                        EarthMethods.addTempAirBlock(block);
                }
                Block block = loc.clone().add(x, -1, z).getBlock();
                if (isEarthbendableMaterial(block.getType()))
                    EarthMethods.addTempAirBlock(block);
            }
            loc.add(0, -1, 0);
        }
        List<Entity> entities = GeneralMethods.getEntitiesAroundPoint(loc, 2.5);
        for (Entity entity : entities) {
            org.bukkit.util.Vector velocity = entity.getVelocity();
            entity.setVelocity(velocity.add(new Vector(0, 0.36, 0)));
        }
        loc.getWorld().playEffect(loc, Effect.GHAST_SHOOT, 0, 7);
        draw();
    } else {
        state = State.LIFTED;
    }
    animCounter++;
}

Output:
                 }
-                if (isEarthbendableMaterial(block.getType()))
+                if (EarthMethods.isEarthbendable(player, block))
                     totalBendableBlocks++;


Input:
final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward) {
    unscheduleGcIdler();
    ActivityRecord r = performResumeActivity(token, clearHide);
    if (r != null) {
        final Activity a = r.activity;
        if (localLOGV)
            Log.v(TAG, "String_Node_Str" + r + "String_Node_Str" + a.mStartedActivity + "String_Node_Str" + r.hideForNow + "String_Node_Str" + a.mFinished);
        final int forwardBit = isForward ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
        if (r.window == null && !a.mFinished && !a.mStartedActivity) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (a.mVisibleFromClient) {
                a.mWindowAdded = true;
                wm.addView(decor, l);
            }
        } else if (a.mStartedActivity) {
            if (localLOGV)
                Log.v(TAG, "String_Node_Str" + r + "String_Node_Str");
            r.hideForNow = true;
        }
        if (!r.activity.mFinished && !a.mStartedActivity && r.activity.mDecor != null && !r.hideForNow) {
            if (r.newConfig != null) {
                if (DEBUG_CONFIGURATION)
                    Log.v(TAG, "String_Node_Str" + r.activityInfo.name + "String_Node_Str" + r.newConfig);
                performConfigurationChanged(r.activity, r.newConfig);
                r.newConfig = null;
            }
            if (localLOGV)
                Log.v(TAG, "String_Node_Str" + r + "String_Node_Str" + isForward);
            WindowManager.LayoutParams l = r.window.getAttributes();
            if ((l.softInputMode & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != forwardBit) {
                l.softInputMode = (l.softInputMode & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)) | forwardBit;
                if (r.activity.mVisibleFromClient) {
                    ViewManager wm = a.getWindowManager();
                    View decor = r.window.getDecorView();
                    wm.updateViewLayout(decor, l);
                }
            }
            r.activity.mVisibleFromServer = true;
            mNumVisibleActivities++;
            if (r.activity.mVisibleFromClient) {
                r.activity.makeVisible();
            }
        }
        r.nextIdle = mNewActivities;
        mNewActivities = r;
        if (localLOGV)
            Log.v(TAG, "String_Node_Str" + r);
        Looper.myQueue().addIdleHandler(new Idler());
    } else {
        try {
            ActivityManagerNative.getDefault().finishActivity(token, Activity.RESULT_CANCELED, null);
        } catch (RemoteException ex) {
        }
    }
}

Output:
         final int forwardBit = isForward ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
-        if (r.window == null && !a.mFinished && !a.mStartedActivity) {
+        boolean willBeVisible = !a.mStartedActivity;
+        if (!willBeVisible) {
+            try {
+                willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(a.getActivityToken());
+            } catch (RemoteException e) {
+            }
+        }
+        if (r.window == null && !a.mFinished && willBeVisible) {
             r.window = r.activity.getWindow();


Input:
public void makeQueryWithBadServerPayloadTest() {
    ModernHttpRequesterMock.setResponseCodes(new Integer[] { 200 });
    ModernHttpRequesterMock.setExpectedUrls(new String[] { "String_Node_Str" });
    ModernHttpRequesterMock.setRequestPayloads(new String[] { "String_Node_Str" });
    AndroidSessionWrapper sessionWrapper = CommCareApplication._().getCurrentSessionWrapper();
    CommCareSession session = sessionWrapper.getSession();
    session.setCommand("String_Node_Str");
    Intent queryActivityIntent = new Intent(RuntimeEnvironment.application, QueryRequestActivity.class);
    QueryRequestActivity queryRequestActivity = Robolectric.buildActivity(QueryRequestActivity.class).withIntent(queryActivityIntent).create().start().resume().get();
    LinearLayout promptsLayout = (LinearLayout) queryRequestActivity.findViewById(R.id.query_prompts);
    EditText patientId = (EditText) promptsLayout.getChildAt(1);
    patientId.setText("String_Node_Str");
    EditText patientName = (EditText) promptsLayout.getChildAt(3);
    patientName.setText("String_Node_Str");
    Button queryButton = (Button) queryRequestActivity.findViewById(R.id.request_button);
    queryButton.performClick();
    TextView errorMessage = (TextView) queryRequestActivity.findViewById(R.id.error_message);
    assertEquals(View.VISIBLE, errorMessage.getVisibility());
    assertTrue(((String) errorMessage.getText()).contains(Localization.get("String_Node_Str", "String_Node_Str")));
}

Output:
     Intent queryActivityIntent = new Intent(RuntimeEnvironment.application, QueryRequestActivity.class);
-    QueryRequestActivity queryRequestActivity = Robolectric.buildActivity(QueryRequestActivity.class).withIntent(queryActivityIntent).create().start().resume().get();
+    ActivityController<QueryRequestActivity> controller = Robolectric.buildActivity(QueryRequestActivity.class).withIntent(queryActivityIntent).create().start().resume();
+    QueryRequestActivity queryRequestActivity = controller.get();
     LinearLayout promptsLayout = (LinearLayout) queryRequestActivity.findViewById(R.id.query_prompts);


Input:
public void Spawn(String world) {
    if (isConsole) {
        return;
    }
    try {
        plugin.getServer().getWorld(world);
    } catch (NullPointerException e) {
        Spawn();
        return;
    }
    Location spawn = plugin.getServer().getWorld(world).getSpawnLocation();
    new Warp(spawn.getX(), spawn.getY(), spawn.getZ(), spawn.getYaw(), spawn.getPitch(), spawn.getWorld().getName(), "String_Node_Str", "String_Node_Str", plugin).WarpHere(this);
}

Output:
     try {
-        plugin.getServer().getWorld(world);
+        spawn = plugin.getServer().getWorld(world).getSpawnLocation();
     } catch (NullPointerException e) {


Input:
private Description handleInvocation(VisitorState state, Symbol.MethodSymbol methodSymbol, List<? extends ExpressionTree> actualParams) {
    ImmutableSet<Integer> nonNullPositions = null;
    if (fromUnannotatedPackage(methodSymbol)) {
        nonNullPositions = handler.onUnannotatedInvocationGetNonNullPositions(this, state, methodSymbol, actualParams, ImmutableSet.of());
    }
    if (nonNullPositions == null) {
        ImmutableSet.Builder<Integer> builder = ImmutableSet.builder();
        List<VarSymbol> formalParams = methodSymbol.getParameters();
        for (int i = 0; i < formalParams.size(); i++) {
            if (i == formalParams.size() - 1 && methodSymbol.isVarArgs()) {
                continue;
            }
            VarSymbol param = formalParams.get(i);
            if (param.type.isPrimitive()) {
                Description unboxingCheck = doUnboxingCheck(state, actualParams.get(i));
                if (unboxingCheck != Description.NO_MATCH) {
                    return unboxingCheck;
                } else {
                    continue;
                }
            }
            boolean nullable = Nullness.hasNullableAnnotation(param);
            if (!nullable) {
                builder.add(i);
            }
        }
        nonNullPositions = builder.build();
    }
    if (nonNullPositions.isEmpty()) {
        return Description.NO_MATCH;
    }
    for (int argPos : nonNullPositions) {
        ExpressionTree actual = actualParams.get(argPos);
        if (mayBeNullExpr(state, actual)) {
            String message = "String_Node_Str" + actual.toString() + "String_Node_Str";
            return createErrorDescriptionForNullAssignment(MessageTypes.PASS_NULLABLE, actual, message, actual, state.getPath());
        }
    }
    return Description.NO_MATCH;
}

Output:
     ImmutableSet<Integer> nonNullPositions = null;
-    if (fromUnannotatedPackage(methodSymbol)) {
+    if (NullabilityUtil.fromUnannotatedPackage(methodSymbol, config)) {
         nonNullPositions = handler.onUnannotatedInvocationGetNonNullPositions(this, state, methodSymbol, actualParams, ImmutableSet.of());


Input:
public static Class<?> classForName(String className, ClassLoader classLoader) {
    try {
        Class<?> c = null;
        try {
            c = Class.forName(className, true, Thread.currentThread().getContextClassLoader());
        } catch (ClassNotFoundException e) {
            try {
                c = Class.forName(className);
            } catch (ClassNotFoundException e1) {
                if (classLoader == null) {
                    throw e1;
                } else {
                    c = classLoader.loadClass(className);
                }
            }
        }
        return c;
    } catch (ClassNotFoundException e) {
        throw new KunderaException(e);
    }
}

Output:
         try {
-            c = Class.forName(className, true, Thread.currentThread().getContextClassLoader());
+            c = Class.forName(className, true, ReflectUtils.class.getClassLoader());
         } catch (ClassNotFoundException e) {


Input:
public ArrayList<SearchToken> push(SearchToken searchToken) {
    LinkedList<SearchToken> queue = getRecentQueue();
    for (SearchToken token : queue) {
        if (token.equals(searchToken)) {
            queue.remove(token);
            queue.addFirst(searchToken);
            return new ArrayList<SearchToken>(queue);
        }
    }
    queue.addFirst(searchToken);
    if (isOverCapacity(queue))
        queue.removeLast();
    saveRecentQueue(queue);
    return new ArrayList<SearchToken>(queue);
}

Output:
             queue.addFirst(searchToken);
-            return new ArrayList<SearchToken>(queue);
+            return new ArrayList<RecentSearchToken>(queue);
         }


Input:
private ContainerRequest setupContainerRequest(TaskStatus taskStatus) throws Exception {
    String taskRoleName = taskStatus.getTaskRoleName();
    Priority priority = statusManager.getNextContainerRequestPriority();
    String nodeLabel = requestManager.getTaskPlatParams().get(taskRoleName).getTaskNodeLabel();
    String nodeGpuType = requestManager.getTaskPlatParams().get(taskRoleName).getTaskNodeGpuType();
    ResourceDescriptor resource = YamlUtils.deepCopy(requestManager.getTaskResources().get(taskRoleName), ResourceDescriptor.class);
    ResourceDescriptor maxResource = conf.getMaxResource();
    if (resource.getMemoryMB() > maxResource.getMemoryMB() || resource.getCpuNumber() > maxResource.getCpuNumber() || resource.getGpuNumber() > maxResource.getGpuNumber()) {
        LOGGER.logWarning("String_Node_Str" + "String_Node_Str" + "String_Node_Str", resource, maxResource);
    }
    if (resource.getGpuNumber() > 0) {
        updateNodeReport(yarnClient.getNodeReports(NodeState.RUNNING));
        GpuAllocation gpuAllocation = gpuAllocationManager.selectCandidateRequestNode(resource, nodeLabel, nodeGpuType);
        if (gpuAllocation != null) {
            resource.setGpuAttribute(gpuAllocation.getGpuBitmap());
            return HadoopUtils.toContainerRequest(resource, priority, null, gpuAllocation.getNodeName());
        } else {
            LOGGER.logWarning("String_Node_Str");
        }
    }
    return HadoopUtils.toContainerRequest(resource, priority, nodeLabel, null);
}

Output:
     String taskRoleName = taskStatus.getTaskRoleName();
-    Priority priority = statusManager.getNextContainerRequestPriority();
-    String nodeLabel = requestManager.getTaskPlatParams().get(taskRoleName).getTaskNodeLabel();
-    String nodeGpuType = requestManager.getTaskPlatParams().get(taskRoleName).getTaskNodeGpuType();
-    ResourceDescriptor resource = YamlUtils.deepCopy(requestManager.getTaskResources().get(taskRoleName), ResourceDescriptor.class);
+    Priority requestPriority = statusManager.getNextContainerRequestPriority();
+    String requestNodeLabel = requestManager.getTaskPlatParams().get(taskRoleName).getTaskNodeLabel();
+    String requestNodeGpuType = requestManager.getTaskPlatParams().get(taskRoleName).getTaskNodeGpuType();
+    ResourceDescriptor requestResource = requestManager.getTaskResources().get(taskRoleName);
     ResourceDescriptor maxResource = conf.getMaxResource();


Input:
private void initialize(byte[] protectedStreamKey) {
    byte[] salsaKey = Sha256.hash(protectedStreamKey);
    salsa20Engine = new Salsa20Engine();
    salsa20Engine.init(true, new ParametersWithIV(new KeyParameter(salsaKey), Hex.decode(SALSA20IV)));
}

Output:
     byte[] salsaKey = Sha256.hash(protectedStreamKey);
-    salsa20Engine = new Salsa20Engine();
-    salsa20Engine.init(true, new ParametersWithIV(new KeyParameter(salsaKey), Hex.decode(SALSA20IV)));
+    try {
+        salsa20Engine = Cipher.getInstance(SALSA20, BouncyCastleProvider.PROVIDER_NAME);
+        salsa20Engine.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(salsaKey, SALSA20), new IvParameterSpec(Hex.decode(SALSA20IV)));
+    } catch (Exception e) {
+        throw new RuntimeException("String_Node_Str" + SALSA20 + "String_Node_Str", e);
+    }
 }


Input:
public static void main(String[] args) {
    System.out.println("String_Node_Str");
    if (args.length < 3) {
        printHelp();
    } else if (args[0] == "String_Node_Str") {
        printHelp();
    } else {
        System.out.println("String_Node_Str");
        MainRunner mr = new MainRunner();
        if (args.length != 3) {
            System.err.println("String_Node_Str");
            printHelp();
        }
        if (args[0].compareTo("String_Node_Str") == 0 || args[0].compareTo("String_Node_Str") == 0) {
            mr.taxonomyLoadParser(args);
        } else if (args[0].compareTo("String_Node_Str") == 0) {
            mr.taxonomyQueryParser(args);
        } else if (args[0].compareTo("String_Node_Str") == 0) {
            mr.graphImporterParser(args);
        }
    }
}

Output:
             mr.taxonomyQueryParser(args);
-        } else if (args[0].compareTo("String_Node_Str") == 0) {
+        } else if (args[0].compareTo("String_Node_Str") == 0 || args[0].compareTo("String_Node_Str") == 0) {
             mr.graphImporterParser(args);


Input:
public List<PanelString> getStringData(int displaySettings, ICardWrapper card, boolean showLabels) {
    List<PanelString> result = new LinkedList<PanelString>();
    PanelString line;
    double PerOut = card.getDouble("String_Node_Str");
    double energyStored = card.getDouble("String_Node_Str");
    double outputlvl = card.getDouble("String_Node_Str");
    double coreTemp = card.getDouble("String_Node_Str");
    int ioutputlvl = (int) outputlvl;
    int ienergyStored = (int) energyStored;
    if ((displaySettings & DISPLAY_TEMP) > 0) {
        line = new PanelString();
        line.textLeft = StringUtils.getFormatted("String_Node_Str", coreTemp, showLabels);
        result.add(line);
    }
    if ((displaySettings & DISPLAY_ENERGY) > 0) {
        line = new PanelString();
        line.textLeft = StringUtils.getFormatted("String_Node_Str", ienergyStored, showLabels);
        result.add(line);
    }
    if ((displaySettings & DISPLAY_OUTPUT) > 0) {
        line = new PanelString();
        line.textLeft = StringUtils.getFormatted("String_Node_Str", ioutputlvl, showLabels);
        result.add(line);
    }
    if ((displaySettings & DISPLAY_PERCENTAGE) > 0) {
        line = new PanelString();
        line.textLeft = StringUtils.getFormatted("String_Node_Str", PerOut, showLabels);
        result.add(line);
    }
    int txtColor = 0;
    String text;
    if ((displaySettings & DISPLAY_ON) > 0) {
        boolean reactorPowered = card.getBoolean("String_Node_Str");
        if (reactorPowered) {
            txtColor = 0x00ff00;
            text = LangHelper.translate("String_Node_Str");
        } else {
            txtColor = 0xff0000;
            text = LangHelper.translate("String_Node_Str");
        }
        if (result.size() > 0) {
            PanelString firstLine = result.get(0);
            firstLine.textRight = text;
            firstLine.colorRight = txtColor;
        } else {
            line = new PanelString();
            line.textLeft = text;
            line.colorLeft = txtColor;
            result.add(line);
        }
    }
    return result;
}

Output:
     int ienergyStored = (int) energyStored;
-    if ((displaySettings & DISPLAY_TEMP) > 0) {
-        line = new PanelString();
-        line.textLeft = StringUtils.getFormatted("String_Node_Str", coreTemp, showLabels);
-        result.add(line);
-    }
-    if ((displaySettings & DISPLAY_ENERGY) > 0) {
-        line = new PanelString();
-        line.textLeft = StringUtils.getFormatted("String_Node_Str", ienergyStored, showLabels);
-        result.add(line);
-    }
-    if ((displaySettings & DISPLAY_OUTPUT) > 0) {
-        line = new PanelString();
-        line.textLeft = StringUtils.getFormatted("String_Node_Str", ioutputlvl, showLabels);
-        result.add(line);
-    }
-    if ((displaySettings & DISPLAY_PERCENTAGE) > 0) {
-        line = new PanelString();
-        line.textLeft = StringUtils.getFormatted("String_Node_Str", PerOut, showLabels);
-        result.add(line);
-    }
-    int txtColor = 0;
-    String text;
-    if ((displaySettings & DISPLAY_ON) > 0) {
-        boolean reactorPowered = card.getBoolean("String_Node_Str");
-        if (reactorPowered) {
-            txtColor = 0x00ff00;
-            text = LangHelper.translate("String_Node_Str");
-        } else {
-            txtColor = 0xff0000;
-            text = LangHelper.translate("String_Node_Str");
-        }
-        if (result.size() > 0) {
-            PanelString firstLine = result.get(0);
-            firstLine.textRight = text;
-            firstLine.colorRight = txtColor;
-        } else {
+    boolean passive = card.getBoolean("String_Node_Str");
+    if (passive) {
+        if ((displaySettings & DISPLAY_TEMP) > 0) {
             line = new PanelString();


Input:
public Bitmap apply(Bitmap bitmap, float scaleFactor, boolean highQuality) {
    Rect cropBounds = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
    RectF c = mGeometry.getCropBounds();
    if (c != null && c.width() > 0 && c.height() > 0)
        c.roundOut(cropBounds);
    Bitmap temp = null;
    if (mGeometry.hasSwitchedWidthHeight()) {
        temp = Bitmap.createBitmap(cropBounds.height(), cropBounds.width(), mConfig);
    } else {
        temp = Bitmap.createBitmap(cropBounds.width(), cropBounds.height(), mConfig);
    }
    Matrix drawMatrix = buildMatrix(c);
    Canvas canvas = new Canvas(temp);
    canvas.drawBitmap(bitmap, drawMatrix, new Paint());
    return temp;
}

Output:
     Rect cropBounds = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
-    RectF c = mGeometry.getCropBounds();
-    if (c != null && c.width() > 0 && c.height() > 0)
-        c.roundOut(cropBounds);
+    RectF crop = mGeometry.getCropBounds(bitmap);
+    if (crop.width() > 0 && crop.height() > 0)
+        crop.roundOut(cropBounds);
     Bitmap temp = null;


Input:
public NetworkResponse createNetworkResponse(Network network) {
    NetworkProfile profile = ApiDBUtils.getNetworkProfile(network.getId());
    NetworkResponse response = new NetworkResponse();
    response.setId(network.getId());
    response.setName(network.getName());
    response.setDisplaytext(network.getDisplayText());
    if (network.getBroadcastDomainType() != null) {
        response.setBroadcastDomainType(network.getBroadcastDomainType().toString());
    }
    if (network.getBroadcastUri() != null) {
        response.setBroadcastUri(network.getBroadcastUri().toString());
    }
    if (network.getTrafficType() != null) {
        response.setTrafficType(network.getTrafficType().name());
    }
    if (network.getGuestType() != null) {
        response.setType(network.getGuestType().name());
    }
    List<? extends Vlan> vlan = ApiDBUtils.listVlanByNetworkId(network.getId());
    if (vlan != null && !vlan.isEmpty()) {
        Vlan singleVlan = vlan.get(0);
        String ipRange = singleVlan.getIpRange();
        String[] range = ipRange.split("String_Node_Str");
        response.setStartIp(range[0]);
        response.setEndIp(range[1]);
        response.setGateway(singleVlan.getVlanGateway());
        response.setNetmask(singleVlan.getVlanNetmask());
        response.setVlan(singleVlan.getVlanTag());
    }
    response.setZoneId(network.getDataCenterId());
    NetworkOffering networkOffering = ApiDBUtils.findNetworkOfferingById(network.getNetworkOfferingId());
    if (networkOffering != null) {
        response.setNetworkOfferingId(networkOffering.getId());
        response.setNetworkOfferingName(networkOffering.getName());
        response.setNetworkOfferingDisplayText(networkOffering.getDisplayText());
        response.setIsSystem(networkOffering.isSystemOnly());
        response.setNetworkOfferingAvailability(networkOffering.getAvailability().toString());
    }
    response.setIsShared(network.getIsShared());
    response.setIsDefault(network.isDefault());
    response.setState(network.getState().toString());
    response.setRelated(network.getRelated());
    response.setNetworkDomain(network.getNetworkDomain());
    response.setDns1(profile.getDns1());
    response.setDns2(profile.getDns2());
    response.setIsSecurityGroupEnabled(network.isSecurityGroupEnabled());
    Map<Service, Map<Capability, String>> serviceCapabilitiesMap = ApiDBUtils.getNetworkCapabilities(network.getId());
    List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>();
    if (serviceCapabilitiesMap != null) {
        for (Service service : serviceCapabilitiesMap.keySet()) {
            ServiceResponse serviceResponse = new ServiceResponse();
            serviceResponse.setName(service.getName());
            List<CapabilityResponse> capabilityResponses = new ArrayList<CapabilityResponse>();
            Map<Capability, String> serviceCapabilities = serviceCapabilitiesMap.get(service);
            if (serviceCapabilities != null) {
                for (Capability capability : serviceCapabilities.keySet()) {
                    CapabilityResponse capabilityResponse = new CapabilityResponse();
                    String capabilityValue = serviceCapabilities.get(capability);
                    capabilityResponse.setName(capability.getName());
                    capabilityResponse.setValue(capabilityValue);
                    capabilityResponse.setObjectName("String_Node_Str");
                    capabilityResponses.add(capabilityResponse);
                }
                serviceResponse.setCapabilities(capabilityResponses);
            }
            serviceResponse.setObjectName("String_Node_Str");
            serviceResponses.add(serviceResponse);
        }
    }
    response.setServices(serviceResponses);
    Account account = ApiDBUtils.findAccountById(network.getAccountId());
    if (account != null && !network.getIsShared()) {
        response.setAccountName(account.getAccountName());
        Domain domain = ApiDBUtils.findDomainById(account.getDomainId());
        response.setDomainId(domain.getId());
        response.setDomain(domain.getName());
    }
    Long dedicatedDomainId = ApiDBUtils.getDedicatedNetworkDomain(network.getId());
    if (dedicatedDomainId != null) {
        Domain domain = ApiDBUtils.findDomainById(dedicatedDomainId);
        response.setDomainId(dedicatedDomainId);
        response.setDomain(domain.getName());
    }
    response.setObjectName("String_Node_Str");
    return response;
}

Output:
     response.setIsSecurityGroupEnabled(network.isSecurityGroupEnabled());
-    Map<Service, Map<Capability, String>> serviceCapabilitiesMap = ApiDBUtils.getNetworkCapabilities(network.getId());
+    Map<Service, Map<Capability, String>> serviceCapabilitiesMap = ApiDBUtils.getNetworkCapabilities(networkOffering.getId(), network.getDataCenterId());
     List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>();


Input:
private static Selection getSelection(String choice, QuestionDef q) {
    Selection s = new Selection(choice);
    if (q != null) {
        q.localizeSelectMap(null);
        int index = q.getSelectedItemIndex(choice);
        s.attachQuestionDef(q);
        return (index != -1 ? s : null);
    }
    return s;
}

Output:
     if (q != null) {
-        q.localizeSelectMap(null);
+        if (q.getSelectItems() == null)
+            q.localizeSelectMap(null);
         int index = q.getSelectedItemIndex(choice);


Input:
private static void setActionListeners() {
    ExperimentAction splashAction = new ExperimentAction(ExperimentActions.LOAD_SPLASH);
    splashAction.registerComponent("String_Node_Str", splashLoaderButton);
    splashAction.registerComponent("String_Node_Str", splashLoadOpt);
    splashAction.registerComponent("String_Node_Str", splashPage);
    splashLoaderButton.addActionListener(splashAction);
    ExperimentAction csvAction = new ExperimentAction(ExperimentActions.SELECT_CSV);
    csvAction.registerComponent("String_Node_Str", selectCSV);
    csvAction.registerComponent("String_Node_Str", csvLabel);
    selectCSV.addActionListener(csvAction);
    previewCSV.addActionListener(new ExperimentAction(ExperimentActions.PREVIEW_CSV));
    viewResults.addActionListener(new ExperimentAction(ExperimentActions.VIEW_RESULTS));
    send.addActionListener(new ExperimentAction(ExperimentActions.SEND_SURVEY));
    previewHTML.addActionListener(new ExperimentAction(ExperimentActions.PREVIEW_HIT));
    dumpParams.addActionListener(new ExperimentAction(ExperimentActions.DUMP_PARAMS));
    viewHIT.addActionListener(new ExperimentAction(ExperimentActions.VIEW_HIT));
}

Output:
 private static void setActionListeners() {
-    ExperimentAction splashAction = new ExperimentAction(ExperimentActions.LOAD_SPLASH);
-    splashAction.registerComponent("String_Node_Str", splashLoaderButton);
-    splashAction.registerComponent("String_Node_Str", splashLoadOpt);
-    splashAction.registerComponent("String_Node_Str", splashPage);
-    splashLoaderButton.addActionListener(splashAction);
-    ExperimentAction csvAction = new ExperimentAction(ExperimentActions.SELECT_CSV);
-    csvAction.registerComponent("String_Node_Str", selectCSV);
-    csvAction.registerComponent("String_Node_Str", csvLabel);
-    selectCSV.addActionListener(csvAction);
+    splashLoaderButton.addActionListener(new ExperimentAction(ExperimentActions.LOAD_SPLASH));
+    selectCSV.addActionListener(new ExperimentAction(ExperimentActions.SELECT_CSV));
     previewCSV.addActionListener(new ExperimentAction(ExperimentActions.PREVIEW_CSV));


Input:
private List<QBChatDialog> loadAllDialogs(Bundle returnedBundle, QBRequestGetBuilder qbRequestGetBuilder) throws QBResponseException {
    List<QBChatDialog> allDialogsList = null;
    List<QBChatDialog> allDialogsListPrivate = new ArrayList<>();
    List<QBChatDialog> allDialogsListGroup = new ArrayList<>();
    boolean needToLoadMorePrivate = true;
    boolean needToLoadMoreGroup = true;
    int pageNumber = 0;
    final QBRequestGetBuilder qbRequestGetBuilderPrivate = new QBRequestGetBuilder();
    qbRequestGetBuilderPrivate.setLimit(ConstsCore.CHATS_DIALOGS_PER_PAGE);
    qbRequestGetBuilderPrivate.sortDesc(QBServiceConsts.EXTRA_LAST_MESSAGE_DATE_SENT);
    qbRequestGetBuilderPrivate.addRule(FIELD_DIALOG_TYPE, OPERATOR_EQ, QBDialogType.PRIVATE.getCode());
    final QBRequestGetBuilder qbRequestGetBuilderGroup = new QBRequestGetBuilder();
    qbRequestGetBuilderGroup.setLimit(ConstsCore.CHATS_DIALOGS_PER_PAGE);
    qbRequestGetBuilderGroup.sortDesc(QBServiceConsts.EXTRA_LAST_MESSAGE_DATE_SENT);
    qbRequestGetBuilderGroup.addRule(FIELD_DIALOG_TYPE, OPERATOR_EQ, QBDialogType.GROUP.getCode());
    do {
        if (needToLoadMorePrivate) {
            needToLoadMorePrivate = loadAllDialogsByType(QBDialogType.PRIVATE, returnedBundle, qbRequestGetBuilderPrivate, allDialogsListPrivate, pageNumber);
        }
        if (needToLoadMoreGroup) {
            needToLoadMoreGroup = loadAllDialogsByType(QBDialogType.GROUP, returnedBundle, qbRequestGetBuilderGroup, allDialogsListGroup, pageNumber);
        }
        List<QBChatDialog> dialogsList = new ArrayList<>(dialogsListPrivate.size() + dialogsListGroup.size());
        dialogsList.addAll(dialogsListPrivate);
        dialogsList.addAll(dialogsListGroup);
        chatHelper.saveDialogsToCache(dialogsList);
        dialogsListPrivate = null;
        dialogsListGroup = null;
        pageNumber++;
        if (pageNumber == FIRST_PAGE_NUMBER) {
            sendLoadPageSuccess(new Bundle());
        }
    } while (needToLoadMorePrivate || needToLoadMoreGroup);
    allDialogsList = new ArrayList<>(allDialogsListPrivate.size() + allDialogsListGroup.size());
    allDialogsList.addAll(allDialogsListPrivate);
    allDialogsList.addAll(allDialogsListGroup);
    return allDialogsList;
}

Output:
         }
-        List<QBChatDialog> dialogsList = new ArrayList<>(dialogsListPrivate.size() + dialogsListGroup.size());
-        dialogsList.addAll(dialogsListPrivate);
-        dialogsList.addAll(dialogsListGroup);
+        int sizeListPrivate = dialogsListPrivate == null ? 0 : dialogsListPrivate.size();
+        int sizeListGroup = dialogsListGroup == null ? 0 : dialogsListGroup.size();
+        List<QBChatDialog> dialogsList = new ArrayList<>(sizeListPrivate + sizeListGroup);
+        if (dialogsListPrivate != null)
+            dialogsList.addAll(dialogsListPrivate);
+        if (dialogsListGroup != null)
+            dialogsList.addAll(dialogsListGroup);
         chatHelper.saveDialogsToCache(dialogsList);


Input:
public void onClick(DialogInterface dialog, int id) {
    String entered_url = url_input_field.getText().toString().trim();
    if (!entered_url.startsWith("String_Node_Str")) {
        if (entered_url.startsWith("String_Node_Str")) {
            entered_url = entered_url.substring("String_Node_Str".length());
        }
        entered_url = "String_Node_Str".concat(entered_url);
    }
    if (validURL(entered_url)) {
        interface_with_ConfigurationWizard.showAndSelectProvider(entered_url);
        Toast.makeText(getActivity().getApplicationContext(), R.string.valid_url_entered, Toast.LENGTH_LONG).show();
    } else {
        url_input_field.setText("String_Node_Str");
        Toast.makeText(getActivity().getApplicationContext(), R.string.not_valid_url_entered, Toast.LENGTH_LONG).show();
        ;
    }
}

Output:
 public void onClick(DialogInterface dialog, int id) {
-    String entered_url = url_input_field.getText().toString().trim();
-    if (!entered_url.startsWith("String_Node_Str")) {
-        if (entered_url.startsWith("String_Node_Str")) {
-            entered_url = entered_url.substring("String_Node_Str".length());
-        }
-        entered_url = "String_Node_Str".concat(entered_url);
-    }
-    if (validURL(entered_url)) {
-        interface_with_ConfigurationWizard.showAndSelectProvider(entered_url);
-        Toast.makeText(getActivity().getApplicationContext(), R.string.valid_url_entered, Toast.LENGTH_LONG).show();
-    } else {
-        url_input_field.setText("String_Node_Str");
-        Toast.makeText(getActivity().getApplicationContext(), R.string.not_valid_url_entered, Toast.LENGTH_LONG).show();
-        ;
-    }
+    saveProvider();
 }


Input:
public boolean isClosed() throws SQLException {
    if (jdbcPooledConnection == null)
        return true;
    return getConnection().isClosed();
}

Output:
         return true;
-    return getConnection().isClosed();
+    return getDelegate().isClosed();
 }


Input:
public void windowChangedNotification() {
    if (lastUsedExperiment != null) {
        if (selectedWindowRequest.isCompleted() == false) {
            selectedWindowRequest.cancel();
        }
        selectedWindowTime = fullExperimentCanvas.getCurrentWindow().getTimestampCenter();
        selectedWindowTimerange = fullExperimentCanvas.getCurrentWindow().getWindowTimeWidth();
        if (isGivenTimestampInSelectedWindow(currentEventTime) == false) {
            currentEventChangeNotification(fullExperimentCanvas.getCurrentWindow().getTimestampLeft());
        }
        performSelectedWindowEventsRequest(lastUsedExperiment);
    }
}

Output:
         }
-        selectedWindowTime = fullExperimentCanvas.getCurrentWindow().getTimestampCenter();
+        selectedWindowTime = fullExperimentCanvas.getCurrentWindow().getTimestampOfCenterPosition();
         selectedWindowTimerange = fullExperimentCanvas.getCurrentWindow().getWindowTimeWidth();


Input:
public static PlayerExtendedProperties getProperties(EntityPlayer player) {
    IExtendedEntityProperties properties = player.getExtendedProperties(ID);
    return (PlayerExtendedProperties) properties;
}

Output:
 public static PlayerExtendedProperties getProperties(EntityPlayer player) {
-    IExtendedEntityProperties properties = player.getExtendedProperties(ID);
-    return (PlayerExtendedProperties) properties;
+    return null;
 }


Input:
public static Document readXmlFromUrl(String serverUrl) throws Exception {
    MCUpdater.apiLogger.fine("String_Node_Str" + serverUrl + "String_Node_Str");
    if (serverUrl.equals("String_Node_Str")) {
        return null;
    }
    final URL server;
    try {
        server = new URL(serverUrl);
    } catch (MalformedURLException e) {
        MCUpdater.apiLogger.log(Level.WARNING, "String_Node_Str", e);
        return null;
    }
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    URLConnection serverConn = server.openConnection();
    serverConn.setRequestProperty("String_Node_Str", "String_Node_Str" + Version.VERSION);
    serverConn.setConnectTimeout(MCUpdater.getInstance().getTimeout());
    serverConn.setReadTimeout(MCUpdater.getInstance().getTimeout());
    try {
        DocumentBuilder db = dbf.newDocumentBuilder();
        return db.parse(serverConn.getInputStream());
    } catch (ParserConfigurationException pce) {
        MCUpdater.apiLogger.log(Level.SEVERE, "String_Node_Str", pce);
    } catch (SAXException se) {
        MCUpdater.apiLogger.log(Level.SEVERE, "String_Node_Str", se);
    } catch (IOException ioe) {
        MCUpdater.apiLogger.log(Level.SEVERE, "String_Node_Str", ioe);
    }
    return null;
}

Output:
     MCUpdater.apiLogger.fine("String_Node_Str" + serverUrl + "String_Node_Str");
-    if (serverUrl.equals("String_Node_Str")) {
+    if (serverUrl.equals("String_Node_Str") || serverUrl.isEmpty()) {
         return null;


Input:
public void testLogout() throws Exception {
    driver.get(getStoreURL() + "String_Node_Str" + SUPER_TENANT_DOMAIN_NAME);
    WebDriverWait wait = new WebDriverWait(driver, 60);
    wait.until(ExpectedConditions.visibilityOfElementLocated(By.linkText("String_Node_Str")));
    driver.findElement(By.linkText("String_Node_Str")).click();
    wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("String_Node_Str")));
    WebElement usernameEle = driver.findElement(By.id("String_Node_Str"));
    usernameEle.sendKeys(gatewayContext.getContextTenant().getContextUser().getUserName());
    wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("String_Node_Str")));
    WebElement passwordEle = driver.findElement(By.id("String_Node_Str"));
    passwordEle.sendKeys(gatewayContext.getContextTenant().getContextUser().getPassword());
    driver.manage().timeouts().implicitlyWait(2, TimeUnit.SECONDS);
    driver.findElement(By.id("String_Node_Str")).click();
    wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("String_Node_Str")));
    driver.navigate().to(getStoreURL() + "String_Node_Str" + TEST_DATA_API_NAME + "String_Node_Str" + TEST_DATA_API_VERSION + "String_Node_Str" + gatewayContext.getContextTenant().getContextUser().getUserName() + "String_Node_Str" + SUPER_TENANT_DOMAIN_NAME);
    wait.until(ExpectedConditions.visibilityOfElementLocated(By.linkText(gatewayContext.getContextTenant().getContextUser().getUserName())));
    driver.findElement(By.linkText(gatewayContext.getContextTenant().getContextUser().getUserName())).click();
    wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("String_Node_Str")));
    driver.findElement(By.id("String_Node_Str")).click();
    assertFalse(driver.getPageSource().contains("String_Node_Str"), "String_Node_Str");
}

Output:
     WebElement usernameEle = driver.findElement(By.id("String_Node_Str"));
-    usernameEle.sendKeys(gatewayContext.getContextTenant().getContextUser().getUserName());
+    usernameEle.sendKeys(storeContext.getContextTenant().getContextUser().getUserName());
     wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("String_Node_Str")));


Input:
private static boolean cherryPick(GitRepository repository, GitCommit commit, Git git, GitPlatformFacade platformFacade, Project project) {
    GitSimpleEventDetector conflictDetector = new GitSimpleEventDetector(CHERRY_PICK_CONFLICT);
    GitSimpleEventDetector localChangesOverwrittenDetector = new GitSimpleEventDetector(LOCAL_CHANGES_OVERWRITTEN_BY_CHERRY_PICK);
    GitUntrackedFilesOverwrittenByOperationDetector untrackedFilesDetector = new GitUntrackedFilesOverwrittenByOperationDetector(repository.getRoot());
    GitCommandResult result = git.cherryPick(repository, commit.getHash().asString(), false, conflictDetector, localChangesOverwrittenDetector, untrackedFilesDetector);
    if (result.success()) {
        return true;
    } else if (conflictDetector.hasHappened()) {
        return new CherryPickConflictResolver(project, git, platformFacade, repository.getRoot(), commit.getHash().asString(), commit.getAuthorName(), commit.getSubject()).merge();
    } else if (untrackedFilesDetector.wasMessageDetected()) {
        String description = "String_Node_Str" + "String_Node_Str";
        UntrackedFilesNotifier.notifyUntrackedFilesOverwrittenBy(project, platformFacade, untrackedFilesDetector.getFiles(), "String_Node_Str", description);
        return false;
    } else if (localChangesOverwrittenDetector.hasHappened()) {
        GerritUtil.notifyError(project, "String_Node_Str", "String_Node_Str");
        return false;
    } else {
        GerritUtil.notifyError(project, "String_Node_Str", result.getErrorOutputAsHtmlString());
        return false;
    }
}

Output:
     GitUntrackedFilesOverwrittenByOperationDetector untrackedFilesDetector = new GitUntrackedFilesOverwrittenByOperationDetector(repository.getRoot());
-    GitCommandResult result = git.cherryPick(repository, commit.getHash().asString(), false, conflictDetector, localChangesOverwrittenDetector, untrackedFilesDetector);
+    GitCommandResult result = git.cherryPick(repository, commit.getHash().getValue(), false, conflictDetector, localChangesOverwrittenDetector, untrackedFilesDetector);
     if (result.success()) {


Input:
public Object encodeSend(LogEvent logEvent) {
    ILoggingEvent event = logEvent.getLoggingEvent();
    StackTraceElement[] stackTraceElements = event.getCallerData();
    String className = "String_Node_Str";
    String simpleClassName = "String_Node_Str";
    int lineNumber = 0;
    if (stackTraceElements != null && stackTraceElements.length > 0) {
        StackTraceElement first = stackTraceElements[0];
        className = first.getClassName();
        simpleClassName = (className.indexOf('.') >= 0) ? className.substring(className.lastIndexOf('.') + 1) : className;
        lineNumber = first.getLineNumber();
    }
    LogData logData = new LogData(event.getTimeStamp(), event.getLevel().toString(), event.getThreadName(), className, simpleClassName, lineNumber, event.getFormattedMessage(), ThrowableProxyUtil.asString(event.getThrowableProxy()));
    return modifyLogJsonElememnt(GSON.toJsonTree(new FormattedLogDataEvent(logData, logEvent.getOffset())));
}

Output:
     }
-    LogData logData = new LogData(event.getTimeStamp(), event.getLevel().toString(), event.getThreadName(), className, simpleClassName, lineNumber, event.getFormattedMessage(), ThrowableProxyUtil.asString(event.getThrowableProxy()));
+    LogData logData = new LogData(event.getTimeStamp(), event.getLevel().toString(), event.getThreadName(), className, simpleClassName, lineNumber, event.getFormattedMessage(), ThrowableProxyUtil.asString(event.getThrowableProxy()), event.getLoggerName());
     return modifyLogJsonElememnt(GSON.toJsonTree(new FormattedLogDataEvent(logData, logEvent.getOffset())));


Input:
private void changeBalance(Player player, HumanNPC npc, String[] args) {
    double amount;
    try {
        amount = Double.parseDouble(args[2]);
    } catch (NumberFormatException e) {
        player.sendMessage(ChatColor.RED + "String_Node_Str");
        return;
    }
    if (args[1].contains("String_Node_Str")) {
        if (EconomyHandler.canBuy(new Payment(amount, true), player)) {
            EconomyHandler.pay(new Payment(-amount, true), npc, -1);
            EconomyHandler.pay(new Payment(amount, true), player, -1);
            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getFormattedBalance(player.getName()), ChatColor.GREEN) + "String_Node_Str");
        } else {
            player.sendMessage(ChatColor.RED + "String_Node_Str" + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount - IconomyInterface.getBalance(player.getName())), ChatColor.RED) + "String_Node_Str");
        }
    } else if (args[1].contains("String_Node_Str")) {
        if (EconomyHandler.canBuy(new Payment(amount, true), npc)) {
            EconomyHandler.pay(new Payment(amount, true), npc, -1);
            EconomyHandler.pay(new Payment(-amount, true), player, -1);
            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getFormattedBalance(player.getName())) + "String_Node_Str");
        } else {
            player.sendMessage(ChatColor.RED + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount - npc.getBalance()), ChatColor.RED) + "String_Node_Str");
        }
    } else
        player.sendMessage(ChatColor.RED + "String_Node_Str" + StringUtils.yellowify(args[1], ChatColor.RED) + "String_Node_Str");
}

Output:
             EconomyHandler.pay(new Payment(amount, true), player, -1);
-            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getCurrency(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getFormattedBalance(player.getName()), ChatColor.GREEN) + "String_Node_Str");
+            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.format(amount)) + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str" + StringUtils.yellowify(IconomyInterface.getFormattedBalance(player.getName()), ChatColor.GREEN) + "String_Node_Str");
         } else {


Input:
public NodeGroupRead toNodeGroupRead(boolean ignoreObsoleteNode) {
    NodeGroupRead nodeGroupRead = new NodeGroupRead();
    nodeGroupRead.setName(this.name);
    nodeGroupRead.setCpuNum(this.cpuNum);
    nodeGroupRead.setMemCapacityMB(this.memorySize);
    nodeGroupRead.setSwapRatio(this.swapRatio);
    nodeGroupRead.setInstanceNum(this.getRealInstanceNum(ignoreObsoleteNode));
    Gson gson = new Gson();
    List<String> groupRoles = gson.fromJson(roles, List.class);
    nodeGroupRead.setRoles(groupRoles);
    StorageRead storage = new StorageRead();
    storage.setType(this.storageType.toString());
    storage.setSizeGB(this.storageSize);
    storage.setDiskNum(this.diskNum);
    storage.setShareDatastore(this.shareDatastore);
    List<String> datastoreNameList = getVcDatastoreNameList();
    if (datastoreNameList != null && !datastoreNameList.isEmpty())
        storage.setDsNames(datastoreNameList);
    if (getSdDatastoreNameList() != null && !getSdDatastoreNameList().isEmpty())
        storage.setDsNames4System(getSdDatastoreNameList());
    if (getDdDatastoreNameList() != null && !getDdDatastoreNameList().isEmpty())
        storage.setDsNames4Data(getDdDatastoreNameList());
    nodeGroupRead.setStorage(storage);
    List<NodeRead> nodeList = new ArrayList<NodeRead>();
    for (NodeEntity node : this.nodes) {
        if (ignoreObsoleteNode && (node.isObsoleteNode() || node.isDisconnected())) {
            continue;
        }
        nodeList.add(node.toNodeRead(true));
    }
    nodeGroupRead.setInstances(nodeList);
    List<GroupAssociation> associations = new ArrayList<GroupAssociation>();
    for (NodeGroupAssociation relation : groupAssociations) {
        GroupAssociation association = new GroupAssociation();
        association.setReference(relation.getReferencedGroup());
        association.setType(relation.getAssociationType());
        associations.add(association);
    }
    PlacementPolicy policy = new PlacementPolicy();
    policy.setInstancePerHost(instancePerHost);
    policy.setGroupAssociations(associations);
    policy.setGroupRacks(new Gson().fromJson(groupRacks, GroupRacks.class));
    nodeGroupRead.setPlacementPolicies(policy);
    return nodeGroupRead;
}

Output:
     nodeGroupRead.setStorage(storage);
-    List<NodeRead> nodeList = new ArrayList<NodeRead>();
-    for (NodeEntity node : this.nodes) {
-        if (ignoreObsoleteNode && (node.isObsoleteNode() || node.isDisconnected())) {
-            continue;
+    if (withNodesList) {
+        List<NodeRead> nodeList = new ArrayList<NodeRead>();
+        for (NodeEntity node : this.nodes) {
+            if (ignoreObsoleteNode && (node.isObsoleteNode() || node.isDisconnected())) {
+                continue;
+            }
+            nodeList.add(node.toNodeRead(true));
         }


Input:
public void saveAnalysis() throws DataprofilerCoreException {
    IRepositoryViewObject reposObject = null;
    analysisHandler.clearAnalysis();
    ModelElementIndicator[] modelElementIndicators = this.getCurrentModelElementIndicators();
    Connection tdProvider = null;
    Analysis analysis = analysisHandler.getAnalysis();
    for (Domain domain : this.analysis.getParameters().getDataFilter()) {
        domain.setName(this.analysis.getName());
    }
    analysis.getParameters().setExecutionLanguage(ExecutionLanguage.get(execLang));
    try {
        Integer.valueOf(numberOfConnectionsPerAnalysisText.getText());
    } catch (NumberFormatException nfe) {
        MessageDialogWithToggle.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str", DefaultMessagesImpl.getString("String_Node_Str")));
        String originalValue = TaggedValueHelper.getTaggedValue(TdqAnalysisConnectionPool.NUMBER_OF_CONNECTIONS_PER_ANALYSIS, this.analysis.getTaggedValue()).getValue();
        numberOfConnectionsPerAnalysisText.setText(originalValue);
    }
    this.saveNumberOfConnectionsPerAnalysis();
    try {
        analysis.getParameters().setMaxNumberRows(Integer.parseInt(maxNumText.getText()));
    } catch (NumberFormatException nfe) {
        MessageDialogWithToggle.openError(null, DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str", DefaultMessagesImpl.getString("String_Node_Str")));
        maxNumText.setText(String.valueOf(analysis.getParameters().getMaxNumberRows()));
    }
    analysis.getParameters().setMaxNumberRows(analysis.getParameters().getMaxNumberRows());
    analysis.getParameters().setStoreData(drillDownCheck.getSelection());
    if (modelElementIndicators != null && modelElementIndicators.length != 0) {
        tdProvider = ModelElementIndicatorHelper.getTdDataProvider(modelElementIndicators[0]);
        if (tdProvider.eIsProxy()) {
            tdProvider = (Connection) EObjectHelper.resolveObject(tdProvider);
        }
        analysis.getContext().setConnection(tdProvider);
        for (ModelElementIndicator modelElementIndicator : modelElementIndicators) {
            reposObject = modelElementIndicator.getModelElementRepositoryNode().getObject();
            ModelElement modelEle = null;
            if (reposObject instanceof MetadataColumnRepositoryObject) {
                modelEle = ((MetadataColumnRepositoryObject) reposObject).getTdColumn();
            } else if (reposObject instanceof MetadataXmlElementTypeRepositoryObject) {
                modelEle = ((MetadataXmlElementTypeRepositoryObject) reposObject).getTdXmlElementType();
            }
            analysisHandler.addIndicator(modelEle, modelElementIndicator.getIndicators());
            DataminingType type = MetadataHelper.getDataminingType(modelEle);
            if (type == null) {
                type = MetadataHelper.getDefaultDataminingType(modelElementIndicator.getJavaType());
            }
            analysisHandler.setDatamingType(type.getLiteral(), modelEle);
        }
    } else {
        deleteConnectionDependency(analysis);
    }
    analysisHandler.setStringDataFilter(dataFilterComp.getDataFilterString());
    this.updateAnalysisClientDependency();
    ReturnCode saved = new ReturnCode(false);
    IEditorInput editorInput = this.getEditorInput();
    if (editorInput instanceof AnalysisItemEditorInput) {
        AnalysisItemEditorInput analysisInput = (AnalysisItemEditorInput) editorInput;
        TDQAnalysisItem tdqAnalysisItem = analysisInput.getTDQAnalysisItem();
        tdqAnalysisItem.getProperty().setDisplayName(analysisHandler.getName());
        tdqAnalysisItem.getProperty().setLabel(WorkspaceUtils.normalize(analysisHandler.getName()));
        this.nameText.setText(analysisHandler.getName());
        saved = ElementWriterFactory.getInstance().createAnalysisWrite().save(tdqAnalysisItem, true);
    }
    logSaved(saved);
    treeViewer.setDirty(false);
    dataFilterComp.setDirty(false);
}

Output:
     } else {
-        deleteConnectionDependency(analysis);
+        analysis.getContext().setConnection(null);
     }


Input:
public void visit(ASTNode[] nodes, SourceUnit source) {
    if (!(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) {
        throw new RuntimeException("String_Node_Str");
    }
    AnnotationNode annotation = (AnnotationNode) nodes[0];
    AnnotatedNode parent = (AnnotatedNode) nodes[1];
    ClassNode declaringClass = parent.getDeclaringClass();
    if (parent instanceof FieldNode) {
        addListenerToProperty(source, annotation, declaringClass, (FieldNode) parent);
    } else if (parent instanceof ClassNode) {
        addListenerToClass(source, annotation, (ClassNode) parent);
    }
}

Output:
 public void visit(ASTNode[] nodes, SourceUnit source) {
-    if (!(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) {
-        throw new RuntimeException("String_Node_Str");
-    }
+    checkNodesForAnnotationAndType(nodes[0], nodes[1]);
     AnnotationNode annotation = (AnnotationNode) nodes[0];


Input:
private static void setParentBackingInfo(VirtualDiskFlatVer2BackingInfo backingInfo, Pair<String, ManagedObjectReference>[] parentDatastorePathList) {
    VirtualDiskFlatVer2BackingInfo parentBacking = new VirtualDiskFlatVer2BackingInfo();
    parentBacking.setDatastore(parentDatastorePathList[0].second());
    parentBacking.setDiskMode(VirtualDiskMode.PERSISTENT.toString());
    if (parentDatastorePathList.length > 1) {
        Pair<String, ManagedObjectReference>[] nextDatastorePathList = new Pair[parentDatastorePathList.length - 1];
        for (int i = 0; i < parentDatastorePathList.length - 1; i++) nextDatastorePathList[i] = parentDatastorePathList[i + 1];
        setParentBackingInfo(parentBacking, nextDatastorePathList);
    }
    parentBacking.setFileName(parentDatastorePathList[0].first());
    backingInfo.setParent(parentBacking);
}

Output:
     parentBacking.setDatastore(parentDatastorePathList[0].second());
-    parentBacking.setDiskMode(VirtualDiskMode.PERSISTENT.toString());
+    parentBacking.setDiskMode(VirtualDiskMode.PERSISTENT.value());
     if (parentDatastorePathList.length > 1) {


Input:
private Message createMessage(Message newMessage, Map<String, Serializable> headerSettings) {
    ComponentStatistics statistics = componentContext.getComponentStatistics();
    MessageHeader header = newMessage.getHeader();
    Message inputMessage = currentInputMessages.get(ThreadUtils.getThreadNumber(threadCount));
    if (inputMessage != null) {
        header.putAll(inputMessage.getHeader());
    }
    if (headerSettings != null) {
        header.putAll(headerSettings);
    }
    header.setSequenceNumber(statistics.getNumberOutboundMessages(ThreadUtils.getThreadNumber(threadCount)) + 1);
    return newMessage;
}

Output:
     }
-    header.setSequenceNumber(statistics.getNumberOutboundMessages(ThreadUtils.getThreadNumber(threadCount)) + 1);
+    header.setSequenceNumber(statistics.getNumberOutboundMessages(ThreadUtils.getThreadNumber(threadCount)));
     return newMessage;


Input:
private Map<Character, Integer> updateIndex(List<ContactItem> list) {
    Character lastCharcter = '#';
    Map<Character, Integer> map = new HashMap<>();
    for (int i = 0; i < list.size(); i++) {
        Character curChar = Character.toLowerCase(list.get(i).sortContent.charAt(0));
        if (!lastCharcter.equals(curChar)) {
            map.put(curChar, i);
        }
        lastCharcter = curChar;
    }
    return map;
}

Output:
     for (int i = 0; i < list.size(); i++) {
-        Character curChar = Character.toLowerCase(list.get(i).sortContent.charAt(0));
-        if (!lastCharcter.equals(curChar)) {
-            map.put(curChar, i);
+        if (!TextUtils.isEmpty(list.get(i).sortContent)) {
+            Character curChar = Character.toLowerCase(list.get(i).sortContent.charAt(0));
+            if (!lastCharcter.equals(curChar)) {
+                map.put(curChar, i);
+            }
+            lastCharcter = curChar;
         }


Input:
public void serviceResolved(ServiceEvent ev) {
    String additions = "String_Node_Str";
    if (ev.getInfo().getInetAddresses() != null && ev.getInfo().getInetAddresses().length > 0) {
        log.debug("String_Node_Str" + ev.getInfo().getInetAddresses().length);
        additions = ev.getInfo().getInetAddresses()[0].getHostAddress();
        log.debug("String_Node_Str" + ev.getInfo().getQualifiedName() + "String_Node_Str" + ev.getInfo().getPort() + "String_Node_Str" + additions);
        String host = additions;
        int port = ev.getInfo().getPort();
        if (!(ev.getInfo().getQualifiedName().equals(zeroconfServiceName + "String_Node_Str" + zeroconfType))) {
            connect(host, port);
        }
    }
}

Output:
         if (!(ev.getInfo().getQualifiedName().equals(zeroconfServiceName + "String_Node_Str" + zeroconfType))) {
-            connect(host, port);
+            DiscoveredDevice d = new DiscoveredDevice(ev.getName(), host, port);
+            discoveredDevices.put(ev.getName(), d);
+        }
+    }
+    if (!discoveredDevices.isEmpty()) {
+        Iterator it = discoveredDevices.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry pairs = (Map.Entry) it.next();
+            DiscoveredDevice d = (DiscoveredDevice) pairs.getValue();
+            connect(d.getHost(), d.getPort());
         }


Input:
public void execute() {
    Pair<List<? extends PhysicalNetworkTrafficType>, Integer> trafficTypes = _networkService.listTrafficTypes(getPhysicalNetworkId());
    ListResponse<TrafficTypeResponse> response = new ListResponse<TrafficTypeResponse>();
    List<TrafficTypeResponse> trafficTypesResponses = new ArrayList<TrafficTypeResponse>();
    for (PhysicalNetworkTrafficType trafficType : trafficTypes.first()) {
        TrafficTypeResponse trafficTypeResponse = _responseGenerator.createTrafficTypeResponse(trafficType);
        trafficTypesResponses.add(trafficTypeResponse);
    }
    response.setResponses(trafficTypesResponses, trafficTypes.second());
    response.setResponseName(getCommandName());
    this.setResponseObject(response);
}

Output:
     List<TrafficTypeResponse> trafficTypesResponses = new ArrayList<TrafficTypeResponse>();
-    for (PhysicalNetworkTrafficType trafficType : trafficTypes.first()) {
-        TrafficTypeResponse trafficTypeResponse = _responseGenerator.createTrafficTypeResponse(trafficType);
-        trafficTypesResponses.add(trafficTypeResponse);
+    if (trafficTypes != null) {
+        for (PhysicalNetworkTrafficType trafficType : trafficTypes.first()) {
+            TrafficTypeResponse trafficTypeResponse = _responseGenerator.createTrafficTypeResponse(trafficType);
+            trafficTypesResponses.add(trafficTypeResponse);
+        }
+        response.setResponses(trafficTypesResponses, trafficTypes.second());
+        response.setResponseName(getCommandName());
     }


Input:
public void check(MarkerList markers, IContext context) {
    this.arguments.check(markers, context);
    if (this.type == null || this.type.isArrayType()) {
        return;
    }
    IClass iclass = this.type.getTheClass();
    if (iclass == null) {
        return;
    }
    if (iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
        markers.add(this.position, "String_Node_Str", iclass.getName());
    } else if (iclass.hasModifier(Modifiers.ABSTRACT)) {
        markers.add(this.position, "String_Node_Str", iclass.getName());
    }
    if (this.constructor != null) {
        this.constructor.checkCall(markers, this.position, context, this.arguments);
    }
}

Output:
     if (iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
-        markers.add(this.position, "String_Node_Str", iclass.getName());
-    } else if (iclass.hasModifier(Modifiers.ABSTRACT)) {
-        markers.add(this.position, "String_Node_Str", iclass.getName());
+        markers.add(this.position, "String_Node_Str", this.type);
+        return;
+    }
+    if (iclass.hasModifier(Modifiers.ABSTRACT)) {
+        markers.add(this.position, "String_Node_Str", this.type);
     }


Input:
private static String createPortMappingPayloadString(CartridgeInfo cartridge) {
    StringBuilder portMapBuilder = new StringBuilder();
    PortMapping[] portMappings = cartridge.getPortMappings();
    for (PortMapping portMapping : portMappings) {
        String port = portMapping.getPort();
        portMapBuilder.append(port).append("String_Node_Str");
    }
    String portMappingString = portMapBuilder.toString().replaceAll("String_Node_Str", "String_Node_Str");
    return portMappingString;
}

Output:
     for (PortMapping portMapping : portMappings) {
-        String port = portMapping.getPort();
+        int port = portMapping.getPort();
         portMapBuilder.append(port).append("String_Node_Str");


Input:
V put(Bytes keyBytes, K key, V value, int hash2, boolean replaceIfPresent) {
    lock();
    try {
        long keyLen = keyBytes.remaining();
        hashLookup.startSearch(hash2);
        for (int pos; (pos = hashLookup.nextPos()) >= 0; ) {
            long offset = offsetFromPos(pos);
            NativeBytes entry = entry(offset);
            if (!keyEquals(keyBytes, keyLen, entry))
                continue;
            entry.skip(keyLen);
            if (replaceIfPresent) {
                return replaceValueOnPut(key, value, entry, pos, offset);
            } else {
                return putReturnsNull ? null : readValue(entry, null);
            }
        }
        long offset = putEntry(keyBytes, value, false);
        incrementSize();
        notifyPut(offset, true, key, value, posFromOffset(offset));
        return null;
    } finally {
        unlock();
    }
}

Output:
             if (replaceIfPresent) {
-                return replaceValueOnPut(key, value, entry, pos, offset);
+                return replaceValueOnPut(key, value, entry, pos, offset, !putReturnsNull, hashLookup);
             } else {


Input:
private boolean isSelectedToReplayEvent(Event event) {
    return event instanceof PlaySoundEvent || event instanceof BindableButton || event instanceof KeyEvent || event instanceof BindAxisEvent || event instanceof CharacterMoveInputEvent || event instanceof MouseButtonEvent || event instanceof MouseWheelEvent || event instanceof MouseAxisEvent;
}

Output:
 private boolean isSelectedToReplayEvent(Event event) {
-    return event instanceof PlaySoundEvent || event instanceof BindableButton || event instanceof KeyEvent || event instanceof BindAxisEvent || event instanceof CharacterMoveInputEvent || event instanceof MouseButtonEvent || event instanceof MouseWheelEvent || event instanceof MouseAxisEvent;
+    boolean selectedToReplay = false;
+    for (Class<?> supportedEventClass : this.selectedClassesToReplay) {
+        if (supportedEventClass.isInstance(event)) {
+            selectedToReplay = true;
+            break;
+        }
+    }
+    return selectedToReplay;
 }


Input:
public static MDMConnection createMdmTdDataProvider(DBConnectionParameter parameter) {
    MdmWebserviceConnection mdmConnection = new MdmWebserviceConnection(parameter.getJdbcUrl(), parameter.getParameters());
    ReturnCode rt = mdmConnection.checkDatabaseConnection();
    if (rt.isOk()) {
        MDMConnection dataProvider = ConnectionHelper.createMDMConnection(parameter.getName());
        mdmConnection.setSofewareSystem(dataProvider, parameter);
        mdmConnection.setProviderConnection(dataProvider, parameter);
        ConnectionHelper.addXMLDocuments(mdmConnection.createConnection(), dataProvider);
        dataProvider.setUsername(mdmConnection.getUserName());
        dataProvider.setPassword(mdmConnection.getUserPass());
        dataProvider.setLabel(parameter.getName());
        return dataProvider;
    }
    return null;
}

Output:
         mdmConnection.setProviderConnection(dataProvider, parameter);
-        ConnectionHelper.addXMLDocuments(mdmConnection.createConnection(), dataProvider);
+        ConnectionHelper.addXMLDocuments(mdmConnection.createConnection(dataProvider));
         dataProvider.setUsername(mdmConnection.getUserName());


Input:
public void resetData(SubItem subItem) {
    if (subItem.equals(this.subItem)) {
        triggerRefresh();
    } else {
        currentPage = -1;
        this.subItem = subItem;
        adapter.clear();
        adapter.notifyDataSetInvalidated();
        listView.setCanPullToRefresh(false);
        listView.setCanPullToLoadMore(false);
        headerView.getLayoutParams().height = 1;
        headerView.setVisibility(View.GONE);
        loadOver();
    }
    hideMoreGroups();
    setTitle();
}

Output:
     }
-    hideMoreGroups();
+    if (isMoreGroupsButtonShowing) {
+        hideMoreGroups();
+    }
     setTitle();


Input:
public void getUnsafeTypedCacheRequest() {
    CacheManager cacheManager = getCacheManager();
    MutableConfiguration<String, Long> config = new MutableConfiguration<String, Long>(String.class, Long.class);
    cacheManager.configureCache("String_Node_Str", config);
    Cache cache = cacheManager.getCache("String_Node_Str");
}

Output:
     CacheManager cacheManager = getCacheManager();
-    MutableConfiguration<String, Long> config = new MutableConfiguration<String, Long>(String.class, Long.class);
+    MutableConfiguration<String, Long> config = new MutableConfiguration<String, Long>().setTypes(String.class, Long.class);
     cacheManager.configureCache("String_Node_Str", config);


Input:
private PortUnification getPortUnification(Protocol protocol) {
    PortUnification pu = protocol.getPortUnification();
    if (pu == null) {
        report.setMessage(MessageFormat.format(rb.getString(DeleteProtocolFilter.NOT_FOUND), "String_Node_Str", protocol.getName()));
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
    }
    return pu;
}

Output:
     PortUnification pu = protocol.getPortUnification();
-    if (pu == null) {
+    if ((pu == null) && (report != null)) {
         report.setMessage(MessageFormat.format(rb.getString(DeleteProtocolFilter.NOT_FOUND), "String_Node_Str", protocol.getName()));


Input:
private Intent handleLiveGeocachingApiExceptions(LiveGeocachingApiException t, Intent positiveAction, String baseMessage) {
    AccountRestrictions restrictions = App.get(mContext).getAuthenticatorHelper().getRestrictions();
    ErrorActivity.IntentBuilder builder = new ErrorActivity.IntentBuilder(mContext);
    switch(t.getStatusCode()) {
        case CacheLimitExceeded:
            int title = (restrictions.isPremiumMember()) ? R.string.premium_member_warning_title : R.string.basic_member_warning_title;
            int message = (restrictions.isPremiumMember()) ? R.string.premium_member_full_geocaching_quota_exceeded_message : R.string.basic_member_full_geocaching_quota_exceeded;
            int cachesPerPeriod = (int) restrictions.getMaxFullGeocacheLimit();
            int period = (int) restrictions.getFullGeocacheLimitPeriod();
            String periodString;
            if (period < AppConstants.SECONDS_PER_MINUTE) {
                periodString = mContext.getResources().getQuantityString(R.plurals.plurals_minute, period, period);
            } else {
                period /= AppConstants.SECONDS_PER_MINUTE;
                periodString = mContext.getResources().getQuantityString(R.plurals.plurals_hour, period, period);
            }
            String renewTime = DateFormat.getTimeFormat(mContext).format(restrictions.getRenewFullGeocacheLimit());
            String cacheString = mContext.getResources().getQuantityString(R.plurals.plurals_cache, cachesPerPeriod, cachesPerPeriod);
            String errorText = mContext.getString(message, cacheString, periodString, renewTime);
            builder.setTitle(title).setMessage(baseMessage, errorText);
            if (positiveAction != null) {
                builder.setPositiveAction(positiveAction).setPositiveButtonText(R.string.yes_button).setNegativeButtonText(R.string.no_button);
            }
            return builder.build();
        case NumberOfCallsExceeded:
            builder.setTitle(R.string.method_quota_exceeded_title).setMessage(baseMessage, mContext.getString(R.string.method_quota_exceeded_message));
            if (positiveAction != null) {
                builder.setPositiveAction(positiveAction).setPositiveButtonText(R.string.continue_button).setNegativeButtonText(R.string.cancel_button);
            }
            return builder.build();
        case PremiumMembershipRequiredForBookmarksExcludeFilter:
        case PremiumMembershipRequiredForDifficultyFilter:
        case PremiumMembershipRequiredForFavoritePointsFilter:
        case PremiumMembershipRequiredForGeocacheContainerSizeFilter:
        case PremiumMembershipRequiredForGeocacheNameFilter:
        case PremiumMembershipRequiredForHiddenByUserFilter:
        case PremiumMembershipRequiredForNotHiddenByUserFilter:
        case PremiumMembershipRequiredForTerrainFilter:
        case PremiumMembershipRequiredForTrackableCountFilter:
            restrictions.updateMemberType(MemberType.Basic);
            return builder.setTitle(R.string.premium_member_warning_title).setMessage(R.string.premium_member_for_filter_required).build();
        default:
            return null;
    }
}

Output:
             if (positiveAction != null) {
-                builder.setPositiveAction(positiveAction).setPositiveButtonText(R.string.continue_button).setNegativeButtonText(R.string.cancel_button);
+                builder.setPositiveAction(positiveAction).setPositiveButtonText(R.string.yes_button).setNegativeButtonText(R.string.no_button);
             }


Input:
public void queryTaxedPrice() throws Exception {
    withFilledCart(client(), cart -> {
        final Cart loadedCart = execute(CartQuery.of().withSort(m -> m.createdAt().sort().desc()).withLimit(1).withPredicates(m -> m.taxedPrice().isPresent().and(m.taxedPrice().totalNet().centAmount().is(centAmountOf(cart.getTaxedPrice().getTotalNet()))).and(m.taxedPrice().totalGross().centAmount().is(centAmountOf(cart.getTaxedPrice().getTotalGross()))))).head().get();
        assertThat(loadedCart.getId()).isEqualTo(cart.getId());
    });
}

Output:
     withFilledCart(client(), cart -> {
-        final Cart loadedCart = execute(CartQuery.of().withSort(m -> m.createdAt().sort().desc()).withLimit(1).withPredicates(m -> m.taxedPrice().isPresent().and(m.taxedPrice().totalNet().centAmount().is(centAmountOf(cart.getTaxedPrice().getTotalNet()))).and(m.taxedPrice().totalGross().centAmount().is(centAmountOf(cart.getTaxedPrice().getTotalGross()))))).head().get();
+        final Cart loadedCart = execute(CartQuery.of().withSort(m -> m.createdAt().sort().desc()).withLimit(1).withPredicates(m -> m.taxedPrice().isPresent().and(m.taxedPrice().totalNet().centAmount().is(centAmountOf(cart.getTaxedPrice().getTotalNet()))).and(m.taxedPrice().totalGross().centAmount().is(centAmountOf(cart.getTaxedPrice().getTotalGross())).and(m.id().is(cart.getId()))))).head().get();
         assertThat(loadedCart.getId()).isEqualTo(cart.getId());


Input:
public boolean startElement(XPathFragment xPathFragment, UnmarshalRecord unmarshalRecord, Attributes atts) {
    try {
        Descriptor xmlDescriptor = (Descriptor) xmlCompositeCollectionMapping.getReferenceDescriptor();
        if (xmlDescriptor == null) {
            xmlDescriptor = findReferenceDescriptor(xPathFragment, unmarshalRecord, atts, xmlCompositeCollectionMapping, xmlCompositeCollectionMapping.getKeepAsElementPolicy());
            if (xmlDescriptor == null) {
                if (unmarshalRecord.getXMLReader().isNullRepresentedByXsiNil(xmlCompositeCollectionMapping.getNullPolicy())) {
                    if (unmarshalRecord.isNil()) {
                        return true;
                    }
                } else if (xmlCompositeCollectionMapping.getNullPolicy().valueIsNull(atts)) {
                    getContainerPolicy().addInto(null, unmarshalRecord.getContainerInstance(this), unmarshalRecord.getSession());
                    return true;
                }
                if (xmlCompositeCollectionMapping.getField() != null) {
                    QName leafType = ((Field) xmlCompositeCollectionMapping.getField()).getLastXPathFragment().getLeafElementType();
                    if (leafType != null) {
                        XPathFragment frag = new XPathFragment();
                        frag.setNamespaceAware(unmarshalRecord.isNamespaceAware());
                        String xpath = leafType.getLocalPart();
                        String uri = leafType.getNamespaceURI();
                        if (uri != null && uri.length() > 0) {
                            frag.setNamespaceURI(uri);
                            String prefix = ((Descriptor) xmlCompositeCollectionMapping.getDescriptor()).getNonNullNamespaceResolver().resolveNamespaceURI(uri);
                            if (prefix != null && prefix.length() > 0) {
                                xpath = prefix + Constants.COLON + xpath;
                            }
                        }
                        frag.setXPath(xpath);
                        Context xmlContext = unmarshalRecord.getUnmarshaller().getContext();
                        xmlDescriptor = xmlContext.getDescriptorByGlobalType(frag);
                    }
                }
            }
            UnmarshalKeepAsElementPolicy policy = xmlCompositeCollectionMapping.getKeepAsElementPolicy();
            if (policy != null && ((xmlDescriptor == null && policy.isKeepUnknownAsElement()) || policy.isKeepAllAsElement())) {
                if (unmarshalRecord.getTypeQName() != null) {
                    Class theClass = (Class) ((XMLConversionManager) unmarshalRecord.getSession().getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(unmarshalRecord.getTypeQName());
                    if (theClass == null) {
                        setupHandlerForKeepAsElementPolicy(unmarshalRecord, xPathFragment, atts);
                        return true;
                    }
                } else {
                    setupHandlerForKeepAsElementPolicy(unmarshalRecord, xPathFragment, atts);
                    return true;
                }
            }
        }
        AbstractNullPolicy nullPolicy = xmlCompositeCollectionMapping.getNullPolicy();
        if (nullPolicy.isNullRepresentedByEmptyNode()) {
            String qnameString = xPathFragment.getLocalName();
            if (xPathFragment.getPrefix() != null) {
                qnameString = xPathFragment.getPrefix() + Constants.COLON + qnameString;
            }
            if (null != xmlDescriptor) {
                CompositeCollectionMappingContentHandler aHandler = new CompositeCollectionMappingContentHandler(unmarshalRecord, this, xmlCompositeCollectionMapping, atts, xPathFragment, xmlDescriptor);
                aHandler.startElement(xPathFragment.getNamespaceURI(), xPathFragment.getLocalName(), qnameString, atts);
                XMLReader xmlReader = unmarshalRecord.getXMLReader();
                xmlReader.setContentHandler(aHandler);
                xmlReader.setLexicalHandler(aHandler);
            }
        } else if (!(unmarshalRecord.getXMLReader().isNullRepresentedByXsiNil(nullPolicy) && unmarshalRecord.isNil())) {
            Field xmlFld = (Field) this.xmlCompositeCollectionMapping.getField();
            if (xmlFld.hasLastXPathFragment()) {
                unmarshalRecord.setLeafElementType(xmlFld.getLastXPathFragment().getLeafElementType());
            }
            processChild(xPathFragment, unmarshalRecord, atts, xmlDescriptor, xmlCompositeCollectionMapping);
        }
    } catch (SAXException e) {
        throw XMLMarshalException.unmarshalException(e);
    }
    return true;
}

Output:
                 if (unmarshalRecord.getTypeQName() != null) {
-                    Class theClass = (Class) ((XMLConversionManager) unmarshalRecord.getSession().getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(unmarshalRecord.getTypeQName());
+                    Class theClass = (Class) XMLConversionManager.getDefaultXMLTypes().get(unmarshalRecord.getTypeQName());
                     if (theClass == null) {


Input:
public void testGeneral() {
    LookupPaintScale s = new LookupPaintScale(0.0, 100.0, Color.BLACK);
    assertEquals(Color.BLACK, s.getPaint(-1.0));
    assertEquals(Color.BLACK, s.getPaint(0.0));
    assertEquals(Color.BLACK, s.getPaint(50.0));
    assertEquals(Color.BLACK, s.getPaint(100.0));
    assertEquals(Color.BLACK, s.getPaint(101.0));
    s.add(new Double(50.0), Color.BLUE);
    assertEquals(Color.BLACK, s.getPaint(-1.0));
    assertEquals(Color.BLACK, s.getPaint(0.0));
    assertEquals(Color.BLUE, s.getPaint(50.0));
    assertEquals(Color.BLUE, s.getPaint(100.0));
    assertEquals(Color.BLACK, s.getPaint(101.0));
    s.add(new Double(50.0), Color.RED);
    assertEquals(Color.BLACK, s.getPaint(-1.0));
    assertEquals(Color.BLACK, s.getPaint(0.0));
    assertEquals(Color.RED, s.getPaint(50.0));
    assertEquals(Color.RED, s.getPaint(100.0));
    assertEquals(Color.BLACK, s.getPaint(101.0));
    s.add(new Double(25.0), Color.green);
    assertEquals(Color.BLACK, s.getPaint(-1.0));
    assertEquals(Color.BLACK, s.getPaint(0.0));
    assertEquals(Color.green, s.getPaint(25.0));
    assertEquals(Color.RED, s.getPaint(50.0));
    assertEquals(Color.RED, s.getPaint(100.0));
    assertEquals(Color.BLACK, s.getPaint(101.0));
    s.add(new Double(75.0), Color.yellow);
    assertEquals(Color.BLACK, s.getPaint(-1.0));
    assertEquals(Color.BLACK, s.getPaint(0.0));
    assertEquals(Color.green, s.getPaint(25.0));
    assertEquals(Color.RED, s.getPaint(50.0));
    assertEquals(Color.yellow, s.getPaint(75.0));
    assertEquals(Color.yellow, s.getPaint(100.0));
    assertEquals(Color.BLACK, s.getPaint(101.0));
}

Output:
     assertEquals(Color.BLACK, s.getPaint(101.0));
-    s.add(new Double(50.0), Color.BLUE);
+    s.add(50.0, Color.BLUE);
     assertEquals(Color.BLACK, s.getPaint(-1.0));


Input:
private void onQsTouch(MotionEvent event) {
    int pointerIndex = event.findPointerIndex(mTrackingPointer);
    if (pointerIndex < 0) {
        pointerIndex = 0;
        mTrackingPointer = event.getPointerId(pointerIndex);
    }
    final float y = event.getY(pointerIndex);
    final float x = event.getX(pointerIndex);
    final float h = y - mInitialTouchY;
    switch(event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
            mQsTracking = true;
            mInitialTouchY = y;
            mInitialTouchX = x;
            onQsExpansionStarted();
            mInitialHeightOnTouch = mQsExpansionHeight;
            initVelocityTracker();
            trackMovement(event);
            break;
        case MotionEvent.ACTION_POINTER_UP:
            final int upPointer = event.getPointerId(event.getActionIndex());
            if (mTrackingPointer == upPointer) {
                final int newIndex = event.getPointerId(0) != upPointer ? 0 : 1;
                final float newY = event.getY(newIndex);
                final float newX = event.getX(newIndex);
                mTrackingPointer = event.getPointerId(newIndex);
                mInitialHeightOnTouch = mQsExpansionHeight;
                mInitialTouchY = newY;
                mInitialTouchX = newX;
            }
            break;
        case MotionEvent.ACTION_MOVE:
            setQsExpansion(h + mInitialHeightOnTouch);
            if (h >= getFalsingThreshold()) {
                mQsTouchAboveFalsingThreshold = true;
            }
            trackMovement(event);
            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
            mQsTracking = false;
            mTrackingPointer = -1;
            trackMovement(event);
            flingQsWithCurrentVelocity(y, event.getActionMasked() == MotionEvent.ACTION_CANCEL);
            if (mVelocityTracker != null) {
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            break;
    }
}

Output:
             trackMovement(event);
-            flingQsWithCurrentVelocity(y, event.getActionMasked() == MotionEvent.ACTION_CANCEL);
+            float fraction = getQsExpansionFraction();
+            if (fraction != 0f || y >= mInitialTouchY) {
+                flingQsWithCurrentVelocity(y, event.getActionMasked() == MotionEvent.ACTION_CANCEL);
+            }
             if (mVelocityTracker != null) {


Input:
private boolean _prefireWithEnclosingNonContinuousDirector() throws IllegalActionException {
    CompositeActor container = (CompositeActor) getContainer();
    Director executiveDirector = ((Actor) container).getExecutiveDirector();
    Time outTime = executiveDirector.getModelTime();
    int localTimeExceedsOutsideTime = _currentTime.compareTo(outTime);
    if (localTimeExceedsOutsideTime > 0) {
        if (!_commitIsPending) {
            throw new IllegalActionException(this, "String_Node_Str" + container.getFullName() + "String_Node_Str" + "String_Node_Str" + outTime + "String_Node_Str" + _currentTime);
        }
        _currentStepSize = outTime.subtract(_iterationBeginTime).getDoubleValue();
        if (_currentStepSize < 0.0) {
            throw new IllegalActionException(this, "String_Node_Str" + _iterationBeginTime + "String_Node_Str" + outTime + "String_Node_Str");
        }
        rollBackToCommittedState();
        _commitIsPending = false;
    } else if (localTimeExceedsOutsideTime == 0 && _commitIsPending) {
        _currentStepSize = 0.0;
        return true;
    } else if (localTimeExceedsOutsideTime < 0 && executiveDirector != _enclosingContinuousDirector()) {
        if (_commitIsPending) {
            _commitIsPending = false;
            rollBackToCommittedState();
        }
        _currentTime = outTime;
        if (_debugging) {
            _debug("String_Node_Str" + _currentTime + "String_Node_Str");
        }
        _currentStepSize = 0.0;
    }
    Time environmentNextIterationTime = executiveDirector.getModelNextIterationTime();
    Time localTargetTime = _iterationBeginTime.add(_currentStepSize);
    if (environmentNextIterationTime.compareTo(localTargetTime) < 0) {
        _currentStepSize = environmentNextIterationTime.subtract(_currentTime).getDoubleValue();
        if (_debugging) {
            _debug("String_Node_Str" + _currentStepSize);
        }
    }
    if (!_breakpoints.isEmpty()) {
        SuperdenseTime nextBreakpoint = (SuperdenseTime) _breakpoints.first();
        Time breakpointTime = nextBreakpoint.timestamp();
        localTimeExceedsOutsideTime = breakpointTime.compareTo(_currentTime);
        while (localTimeExceedsOutsideTime < 0 || (localTimeExceedsOutsideTime == 0 && nextBreakpoint.index() < _index)) {
            if (_debugging) {
                _debug("String_Node_Str" + breakpointTime);
            }
            _fireAtSkipped(breakpointTime);
            _breakpoints.removeFirst();
            if (_breakpoints.isEmpty()) {
                break;
            }
            nextBreakpoint = (SuperdenseTime) _breakpoints.first();
            breakpointTime = nextBreakpoint.timestamp();
            localTimeExceedsOutsideTime = breakpointTime.compareTo(_currentTime);
        }
        if (localTimeExceedsOutsideTime == 0 && nextBreakpoint.index() == _index) {
            if (_debugging) {
                _debug("String_Node_Str" + nextBreakpoint + "String_Node_Str");
            }
            _breakpoints.removeFirst();
        }
    }
    boolean result = super.prefire();
    if (executiveDirector instanceof SuperdenseTimeDirector) {
        _index = ((SuperdenseTimeDirector) executiveDirector).getIndex();
    }
    _resetAllReceivers();
    if (_debugging) {
        _debug("String_Node_Str" + result);
    }
    return result;
}

Output:
         return true;
-    } else if (localTimeExceedsOutsideTime < 0 && executiveDirector != _enclosingContinuousDirector()) {
+    } else if (localTimeExceedsOutsideTime < 0) {
         if (_commitIsPending) {


Input:
public PShape groupChildren(PShape[] gchildren, String gname) {
    if (family != GROUP)
        return null;
    PShape3D group = new PShape3D();
    group.family = PShape.GROUP;
    group.name = gname;
    group.papplet = papplet;
    group.a3d = a3d;
    group.gl = gl;
    group.root = root;
    PShape child, p;
    int idx;
    child = gchildren[0];
    p = child.parent;
    if (p != null) {
        idx = p.getChildIdx(child);
        if (idx < 0)
            idx = 0;
    } else {
        p = this;
        idx = 0;
    }
    p.addChild(group, idx);
    for (int i = 0; i < gchildren.length; i++) {
        child = gchildren[i];
        p = child.parent;
        if (p != null) {
            idx = p.getChildIdx(child);
            if (-1 < idx) {
                p.removeChild(idx);
            }
        }
    }
    group.firstVertex = root.vertexCount;
    group.lastVertex = 0;
    for (int i = 0; i < gchildren.length; i++) {
        group.firstVertex = PApplet.min(group.firstVertex, ((PShape3D) gchildren[i]).firstVertex);
        group.lastVertex = PApplet.max(group.lastVertex, ((PShape3D) gchildren[i]).lastVertex);
    }
    for (int i = 0; i < gchildren.length; i++) {
        group.addChildImpl(gchildren[i], false);
    }
    return group;
}

Output:
     if (p != null) {
-        idx = p.getChildIdx(child);
+        idx = p.getChildIndex(child);
         if (idx < 0)


Input:
protected void _addChoices(Parameter parameter, String directoryPath) throws IllegalActionException {
    try {
        URI directoryURI = new URI(FileUtilities.nameToURL(directoryPath, null, null).toExternalForm().replaceAll("String_Node_Str", "String_Node_Str"));
        File directory = null;
        try {
            try {
                directory = new File(directoryURI);
            } catch (Throwable throwable) {
                throw new InternalErrorException(this, throwable, "String_Node_Str" + directoryURI + "String_Node_Str");
            }
            DirectoryNameFilter filter = new DirectoryNameFilter();
            File[] directories = directory.listFiles(filter);
            if (directories == null) {
                throw new InternalErrorException(this, null, "String_Node_Str" + directoryPath + "String_Node_Str");
            } else {
                for (File element : directories) {
                    String directoryName = element.getName();
                    parameter.addChoice(directoryName);
                }
            }
        } catch (Throwable throwable) {
            try {
                if (!directoryURI.toString().startsWith("String_Node_Str")) {
                    throw throwable;
                } else {
                    List<String> directories = ClassUtilities.jarURLDirectories(directoryURI.toURL());
                    for (String directoryFullPath : directories) {
                        String directoryName = directoryFullPath;
                        if (directoryName.lastIndexOf("String_Node_Str") > -1) {
                            if (directoryName.lastIndexOf("String_Node_Str") == directoryName.length() - 1) {
                                directoryName = directoryName.substring(0, directoryName.length() - 1);
                            }
                            directoryName = directoryName.substring(directoryName.lastIndexOf("String_Node_Str") + 1);
                        }
                        parameter.addChoice(directoryName);
                    }
                }
            } catch (Throwable throwable2) {
                System.err.println("String_Node_Str");
                throwable2.printStackTrace();
                throw new IllegalActionException(this, throwable, "String_Node_Str" + directoryURI);
            }
        }
    } catch (Exception ex) {
        throw new InternalErrorException(this, ex, "String_Node_Str" + directoryPath + "String_Node_Str" + parameter.getFullName() + "String_Node_Str");
    }
}

Output:
         }
-    } catch (Exception ex) {
+    } catch (Throwable ex) {
         throw new InternalErrorException(this, ex, "String_Node_Str" + directoryPath + "String_Node_Str" + parameter.getFullName() + "String_Node_Str");


Input:
protected void _arriveFirst(CSPReceiver receiver, ConditionalBranchController controller) throws InterruptedException {
    receiver._setConditionalReceive(true, controller);
    getController()._branchBlocked(this.getReceiver());
    getReceiver()._checkFlagsAndWait();
    getController()._branchUnblocked(this.getReceiver());
    while (true) {
        if (!isAlive()) {
            receiver._setConditionalReceive(false, null);
            controller._branchFailed(getID());
            receiver.notifyAll();
            return;
        } else if (receiver._isPutWaiting()) {
            if (controller._isBranchFirst(getID())) {
                receiver._setConditionalReceive(false, null);
                setToken(receiver.get());
                controller._branchSucceeded(getID());
                return;
            }
        }
        getController()._branchBlocked(this.getReceiver());
        getReceiver()._checkFlagsAndWait();
        getController()._branchUnblocked(this.getReceiver());
    }
}

Output:
 protected void _arriveFirst(CSPReceiver receiver, ConditionalBranchController controller) throws InterruptedException {
-    receiver._setConditionalReceive(true, controller);
+    receiver._setConditionalReceive(true, controller, getID());
     getController()._branchBlocked(this.getReceiver());


Input:
private PickerLabel processInitialLabel(String initialLabel, List<String> removedLabels, Optional<String> suggestion) {
    TurboLabel repoInitialLabel = getRepoTurboLabel(initialLabel);
    if (!removedLabels.contains(initialLabel) && !suggestion.isPresent()) {
        return getStyledPickerLabel(repoInitialLabel, false, false, false, false, true);
    }
    if (!removedLabels.contains(initialLabel) && suggestion.isPresent() && initialLabel.equals(suggestion.get())) {
        return getStyledPickerLabel(repoInitialLabel, true, false, true, false, true);
    }
    if (removedLabels.contains(initialLabel) && !suggestion.isPresent()) {
        return getStyledPickerLabel(repoInitialLabel, false, false, true, false, true);
    }
    if (removedLabels.contains(initialLabel) && suggestion.isPresent() && initialLabel.equals(suggestion.get())) {
        return getStyledPickerLabel(repoInitialLabel, true, false, false, false, true);
    }
    return getStyledPickerLabel(repoInitialLabel, false, false, false, false, true);
}

Output:
     TurboLabel repoInitialLabel = getRepoTurboLabel(initialLabel);
-    if (!removedLabels.contains(initialLabel) && !suggestion.isPresent()) {
+    if (!removedLabels.contains(initialLabel)) {
+        if (suggestion.isPresent() && initialLabel.equals(suggestion.get())) {
+            return getStyledPickerLabel(repoInitialLabel, true, false, true, false, true);
+        }
         return getStyledPickerLabel(repoInitialLabel, false, false, false, false, true);


Input:
public void testMirrorOnYearDimension() throws DataException {
    ICubeQueryDefinition cqd = createMirroredQueryDefinition("String_Node_Str");
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
    List rowEdgeBindingNames = new ArrayList();
    rowEdgeBindingNames.add("String_Node_Str");
    rowEdgeBindingNames.add("String_Node_Str");
    rowEdgeBindingNames.add("String_Node_Str");
    rowEdgeBindingNames.add("String_Node_Str");
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    List measureBindingNames = new ArrayList();
    measureBindingNames.add("String_Node_Str");
    try {
        testOut.print(new CubeUtility().printCubeAlongEdge(dataCursor, columnEdgeBindingNames, rowEdgeBindingNames, measureBindingNames, null, null, null, null));
        this.checkOutputFile();
    } catch (Exception e) {
        fail("String_Node_Str");
    }
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube, false);
     List rowEdgeBindingNames = new ArrayList();