Input:
private String getLuceneQuery(KunderaQuery kunderaQuery) {
    StringBuffer sb = new StringBuffer();
    if (kunderaQuery.getFilterClauseQueue().isEmpty()) {
        String idColumnName = ((AbstractAttribute) kunderaQuery.getEntityMetadata().getIdAttribute()).getJPAColumnName();
        sb.append(idColumnName).append("String_Node_Str").append("String_Node_Str");
    } else {
        for (Object object : kunderaQuery.getFilterClauseQueue()) {
            if (object instanceof FilterClause) {
                boolean appended = false;
                FilterClause filter = (FilterClause) object;
                sb.append(filter.getProperty());
                String appender = "String_Node_Str";
                if (filter.getCondition().equals("String_Node_Str")) {
                    sb.append("String_Node_Str");
                } else if (filter.getCondition().equalsIgnoreCase("String_Node_Str")) {
                    sb.append("String_Node_Str");
                    appender = "String_Node_Str";
                } else if (filter.getCondition().equalsIgnoreCase("String_Node_Str")) {
                    sb.append(appendRange(filter.getValue().toString(), false, true, String.class));
                    appended = true;
                } else if (filter.getCondition().equalsIgnoreCase("String_Node_Str")) {
                    sb.append(appendRange(filter.getValue().toString(), true, true, String.class));
                    appended = true;
                } else if (filter.getCondition().equalsIgnoreCase("String_Node_Str")) {
                    sb.append(appendRange(filter.getValue().toString(), false, false, String.class));
                    appended = true;
                } else if (filter.getCondition().equalsIgnoreCase("String_Node_Str")) {
                    sb.append(appendRange(filter.getValue().toString(), true, false, String.class));
                    appended = true;
                }
                if (!appended) {
                    if (appender.equals("String_Node_Str") && filter.getValue() != null && filter.getValue().toString().contains("String_Node_Str")) {
                        sb.append("String_Node_Str");
                        sb.append(filter.getValue().toString());
                        sb.append("String_Node_Str");
                    } else {
                        sb.append(filter.getValue());
                        sb.append(appender);
                    }
                }
            } else {
                sb.append("String_Node_Str" + object + "String_Node_Str");
            }
        }
    }
    return sb.toString();
}

Output:
                 String appender = "String_Node_Str";
-                if (filter.getCondition().equals("String_Node_Str")) {
+                String condition = filter.getCondition().trim();
+                if (condition.equals("String_Node_Str")) {
                     sb.append("String_Node_Str");


Input:
public String getFieldIgnored() {
    return fieldIgnored;
}

Output:
 public String getFieldIgnored() {
-    return fieldIgnored;
+    return realmGetter$fieldIgnored();
 }


Input:
public Expression normalize(ExpressionNormalizer normalizer, Expression base, List<Expression> foreignKeyJoinPointer) {
    if (this.hasBeenNormalized) {
        return this;
    }
    Expression clonedExpression = checkJoinForSubSelectWithParent(normalizer, base, foreignKeyJoinPointer);
    if (clonedExpression != null) {
        return clonedExpression;
    }
    super.normalize(normalizer);
    DatabaseMapping mapping = getMapping();
    SQLSelectStatement statement = normalizer.getStatement();
    if ((mapping != null) && mapping.isDirectToXMLTypeMapping()) {
        statement.setRequiresAliases(true);
    }
    if (isAttribute()) {
        return this;
    }
    ReadQuery query = normalizer.getStatement().getQuery();
    if ((query != null) && query.shouldCacheQueryResults()) {
        if ((mapping != null) && (mapping.getReferenceDescriptor().getJavaClass() != null)) {
            query.getQueryResultsCachePolicy().getInvalidationClasses().add(mapping.getReferenceDescriptor().getJavaClass());
        } else {
            QueryKey queryKey = getQueryKeyOrNull();
            if ((queryKey != null) && queryKey.isForeignReferenceQueryKey()) {
                query.getQueryResultsCachePolicy().getInvalidationClasses().add(((ForeignReferenceQueryKey) queryKey).getReferenceClass());
            }
        }
    }
    if ((mapping != null) && (mapping.isReferenceMapping() || mapping.isStructureMapping())) {
        statement.setRequiresAliases(true);
        return this;
    }
    if (shouldQueryToManyRelationship() && (!statement.isDistinctComputed()) && (!statement.isAggregateSelect())) {
        statement.useDistinct();
    }
    if ((mapping != null) && mapping.isNestedTableMapping()) {
        if (!shouldQueryToManyRelationship()) {
            return this;
        }
        statement.dontUseDistinct();
    }
    if (this.onClause != null) {
        this.onClause = this.onClause.normalize(normalizer);
    }
    Expression mappingExpression = mappingCriteria(base);
    if (mappingExpression != null) {
        mappingExpression = mappingExpression.normalize(normalizer);
    }
    if (mappingExpression != null) {
        if (shouldUseOuterJoin() && (getSession().getPlatform().isInformixOuterJoin())) {
            setOuterJoinExpIndex(statement.addOuterJoinExpressionsHolders(this, mappingExpression, null, null));
            normalizer.addAdditionalExpression(mappingExpression.and(additionalExpressionCriteria()));
            return this;
        } else if ((shouldUseOuterJoin() && (!getSession().getPlatform().shouldPrintOuterJoinInWhereClause())) || (!getSession().getPlatform().shouldPrintInnerJoinInWhereClause())) {
            setOuterJoinExpIndex(statement.addOuterJoinExpressionsHolders(this, mappingExpression, additionalExpressionCriteriaMap(), null));
            if ((getDescriptor() != null) && (getDescriptor().getHistoryPolicy() != null)) {
                Expression historyOnClause = getDescriptor().getHistoryPolicy().additionalHistoryExpression(this, this, 0);
                if (getOnClause() != null) {
                    setOnClause(getOnClause().and(historyOnClause));
                } else {
                    setOnClause(historyOnClause);
                }
            }
            return this;
        } else if (isUsingOuterJoinForMultitableInheritance() && (!getSession().getPlatform().shouldPrintOuterJoinInWhereClause())) {
            setOuterJoinExpIndex(statement.addOuterJoinExpressionsHolders(null, null, additionalExpressionCriteriaMap(), mapping.getReferenceDescriptor()));
        }
        if (foreignKeyJoinPointer != null) {
            foreignKeyJoinPointer.add(mappingExpression.and(this.onClause));
        } else {
            normalizer.addAdditionalExpression(mappingExpression.and(additionalExpressionCriteria()).and(this.onClause));
        }
    }
    return this;
}

Output:
     if ((query != null) && query.shouldCacheQueryResults()) {
-        if ((mapping != null) && (mapping.getReferenceDescriptor().getJavaClass() != null)) {
+        if ((mapping != null) && (mapping.getReferenceDescriptor() != null) && (mapping.getReferenceDescriptor().getJavaClass() != null)) {
             query.getQueryResultsCachePolicy().getInvalidationClasses().add(mapping.getReferenceDescriptor().getJavaClass());


Input:
public void testGetAllVars1() {
    String fnString = "String_Node_Str";
    Compiler compiler = new Compiler();
    compiler.setLifeCycleStage(LifeCycleStage.NORMALIZED);
    ScopeCreator scopeCreator = new Es6SyntacticScopeCreator(compiler);
    Node ast = parse(fnString);
    Node functionNode = getFunctionNode(fnString);
    Scope globalScope = Scope.createGlobalScope(ast);
    Scope functionScope = scopeCreator.createScope(functionNode, globalScope);
    Map<String, Var> allVariables = new HashMap<>();
    List<Var> orderedVars = new LinkedList<>();
    NodeUtil.getAllVarsDeclaredInFunction(allVariables, orderedVars, compiler, scopeCreator, functionScope);
    Set<String> keySet = new HashSet<>(Arrays.asList("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str"));
    assertEquals(keySet, allVariables.keySet());
}

Output:
     Map<String, Var> allVariables = new HashMap<>();
-    List<Var> orderedVars = new LinkedList<>();
+    List<Var> orderedVars = new ArrayList<>();
     NodeUtil.getAllVarsDeclaredInFunction(allVariables, orderedVars, compiler, scopeCreator, functionScope);


Input:
private void showNotificationForBuilder(NotificationCompat.Builder builder, Context context, String wpcomNoteID, int pushId, boolean notifyUser) {
    if (builder == null || context == null) {
        return;
    }
    Intent resultIntent = new Intent(context, WPMainActivity.class);
    resultIntent.putExtra(WPMainActivity.ARG_OPENED_FROM_PUSH, true);
    resultIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    resultIntent.setAction("String_Node_Str");
    resultIntent.addCategory("String_Node_Str");
    resultIntent.putExtra(NotificationsListFragment.NOTE_ID_EXTRA, wpcomNoteID);
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
    boolean shouldReceiveNotifications = prefs.getBoolean(context.getString(R.string.wp_pref_notifications_master), true);
    if (shouldReceiveNotifications) {
        if (notifyUser) {
            boolean shouldVibrate = prefs.getBoolean(context.getString(R.string.wp_pref_notification_vibrate), false);
            boolean shouldBlinkLight = prefs.getBoolean(context.getString(R.string.wp_pref_notification_light), true);
            String notificationSound = prefs.getString(context.getString(R.string.wp_pref_custom_notification_sound), context.getString(R.string.notification_settings_item_sights_and_sounds_choose_sound_default));
            if (!TextUtils.isEmpty(notificationSound) && !notificationSound.trim().toLowerCase().startsWith("String_Node_Str")) {
                builder.setSound(Uri.parse(notificationSound));
            }
            if (shouldVibrate) {
                builder.setVibrate(new long[] { 500, 500, 500 });
            }
            if (shouldBlinkLight) {
                builder.setLights(0xff0000ff, 1000, 5000);
            }
        } else {
            builder.setVibrate(null);
            builder.setSound(null);
        }
        Intent notificationDeletedIntent = new Intent(context, NotificationDismissBroadcastReceiver.class);
        notificationDeletedIntent.putExtra("String_Node_Str", pushId);
        notificationDeletedIntent.setAction(String.valueOf(pushId));
        PendingIntent pendingDeleteIntent = PendingIntent.getBroadcast(context, pushId, notificationDeletedIntent, 0);
        builder.setDeleteIntent(pendingDeleteIntent);
        builder.setCategory(NotificationCompat.CATEGORY_SOCIAL);
        PendingIntent pendingIntent = PendingIntent.getActivity(context, pushId, resultIntent, PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_UPDATE_CURRENT);
        builder.setContentIntent(pendingIntent);
        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
        notificationManager.notify(pushId, builder.build());
    }
}

Output:
             String notificationSound = prefs.getString(context.getString(R.string.wp_pref_custom_notification_sound), context.getString(R.string.notification_settings_item_sights_and_sounds_choose_sound_default));
-            if (!TextUtils.isEmpty(notificationSound) && !notificationSound.trim().toLowerCase().startsWith("String_Node_Str")) {
+            if (!TextUtils.isEmpty(notificationSound) && !notificationSound.trim().toLowerCase(Locale.ROOT).startsWith("String_Node_Str")) {
                 builder.setSound(Uri.parse(notificationSound));


Input:
public LTable luaSetMetatable(LValue metatable) {
    throw new LuaErrorException("String_Node_Str" + metatable.luaGetTypeName());
}

Output:
 public LTable luaSetMetatable(LValue metatable) {
-    throw new LuaErrorException("String_Node_Str" + metatable.luaGetTypeName());
+    throw new LuaErrorException("String_Node_Str" + this.luaGetTypeName());
 }


Input:
private void populateReceivers() {
    List<TeleportDestination> newReceivers = fromServer_receivers;
    if (newReceivers == null) {
        return;
    }
    if (newReceivers.equals(receivers)) {
        return;
    }
    receivers = new ArrayList<TeleportDestination>(newReceivers);
    receiverList.removeChildren();
    for (TeleportDestination destination : receivers) {
        Coordinate coordinate = destination.getCoordinate();
        String dimName = DimensionManager.getProvider(destination.getDimension()).getDimensionName();
        Panel panel = new Panel(mc, this).setLayout(new HorizontalLayout());
        panel.addChild(new Label(mc, this).setText(destination.getName()).setHorizontalAlignment(HorizontalAlignment.ALIGH_LEFT).setDesiredWidth(65));
        panel.addChild(new Label(mc, this).setDynamic(true).setText(coordinate.toString()));
        panel.addChild(new Label(mc, this).setText(dimName).setHorizontalAlignment(HorizontalAlignment.ALIGH_LEFT).setDesiredWidth(55));
        receiverList.addChild(panel);
    }
}

Output:
 private void populateReceivers() {
-    List<TeleportDestination> newReceivers = fromServer_receivers;
+    List<TeleportDestinationClientInfo> newReceivers = fromServer_receivers;
     if (newReceivers == null) {


Input:
public SimpleRequestContext buildBySysParams(RopContext ropContext, Object request) {
    if (!(request instanceof HttpServletRequest)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    HttpServletRequest servletRequest = (HttpServletRequest) request;
    SimpleRequestContext requestContext = new SimpleRequestContext(ropContext);
    requestContext.setRawRequestObject(servletRequest);
    requestContext.setAllParams(getRequestParams(servletRequest));
    requestContext.setIp(servletRequest.getRemoteAddr());
    requestContext.setAppKey(servletRequest.getParameter(SystemParameterNames.getAppKey()));
    requestContext.setSessionId(servletRequest.getParameter(SystemParameterNames.getSessionId()));
    requestContext.setMethod(servletRequest.getParameter(SystemParameterNames.getMethod()));
    requestContext.setVersion(servletRequest.getParameter(SystemParameterNames.getVersion()));
    requestContext.setLocale(getLocale(servletRequest));
    requestContext.setFormat(getFormat(servletRequest));
    requestContext.setMessageFormat(getResponseFormat(servletRequest));
    requestContext.setSign(servletRequest.getParameter(SystemParameterNames.getSign()));
    requestContext.setHttpAction(HttpAction.fromValue(servletRequest.getMethod()));
    ServiceMethodHandler serviceMethodHandler = ropContext.getServiceMethodHandler(requestContext.getMethod(), requestContext.getVersion());
    requestContext.setServiceMethodHandler(serviceMethodHandler);
    return requestContext;
}

Output:
     requestContext.setAllParams(getRequestParams(servletRequest));
-    requestContext.setIp(servletRequest.getRemoteAddr());
+    requestContext.setIp(getRemoteAddr(servletRequest));
     requestContext.setAppKey(servletRequest.getParameter(SystemParameterNames.getAppKey()));


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_new_issue);
    if (getIntent().getExtras() != null) {
        repoInfo = (RepoInfo) getIntent().getExtras().getParcelable(REPO_INFO);
        findViews();
        setTitle(getString(R.string.new_issue_title, repoInfo.name));
        issueRequest = CacheWrapper.getIssueRequest(repoInfo.owner + "String_Node_Str" + repoInfo.name);
        if (issueRequest != null) {
            setupFromCache(issueRequest);
        } else {
            issueRequest = new IssueRequest();
        }
    } else {
        finish();
    }
}

Output:
     if (getIntent().getExtras() != null) {
-        repoInfo = (RepoInfo) getIntent().getExtras().getParcelable(REPO_INFO);
+        repoInfo = getIntent().getExtras().getParcelable(REPO_INFO);
         findViews();


Input:
public void onSuccess(Key result) {
    eventTextBox.setText(null);
    startDateBox.setValue(null);
    expirationDateBox.setValue(null);
    app.setKey(result);
    updateTableRow(app, row);
}

Output:
     expirationDateBox.setValue(null);
-    app.setKey(result);
-    updateTableRow(app, row);
+    if (result != null) {
+        app.setKey(result);
+        updateTableRow(app, row);
+    }
 }


Input:
public Void visitToProvider(Provider<? extends T> provider) {
    InternalFactory<? extends T> factory = new InternalFactoryToProviderAdapter<T>(provider, source);
    registerInstanceForInjection(provider);
    InternalFactory<? extends T> scopedFactory = Scopes.scope(key, injector, factory, scope);
    createBinding(source, shouldPreload, new ProviderInstanceBindingImpl<T>(injector, key, source, scopedFactory, scope, provider));
    return null;
}

Output:
 public Void visitToProvider(Provider<? extends T> provider) {
-    InternalFactory<? extends T> factory = new InternalFactoryToProviderAdapter<T>(provider, source);
-    registerInstanceForInjection(provider);
+    InternalFactoryToProviderAdapter<? extends T> factory = new InternalFactoryToProviderAdapter<T>(provider, source);
+    outstandingInjections.put(provider, null);
     InternalFactory<? extends T> scopedFactory = Scopes.scope(key, injector, factory, scope);


Input:
public Queue getDlcQueue() throws AndesAdminServiceBrokerManagerAdminException, java.rmi.RemoteException {
    Queue[] queueList = stub.getAllQueues();
    Queue dlcQueue = null;
    if (null != queueList) {
        for (Queue queue : queueList) {
            String nameOfQueue = queue.getQueueName();
            if (StringUtils.isNotBlank(nameOfQueue) && nameOfQueue.contains(AndesConstants.DEAD_LETTER_QUEUE_SUFFIX)) {
                dlcQueue = queue;
                break;
            }
        }
    }
    return dlcQueue;
}

Output:
 public Queue getDlcQueue() throws AndesAdminServiceBrokerManagerAdminException, java.rmi.RemoteException {
-    Queue[] queueList = stub.getAllQueues();
-    Queue dlcQueue = null;
-    if (null != queueList) {
-        for (Queue queue : queueList) {
-            String nameOfQueue = queue.getQueueName();
-            if (StringUtils.isNotBlank(nameOfQueue) && nameOfQueue.contains(AndesConstants.DEAD_LETTER_QUEUE_SUFFIX)) {
-                dlcQueue = queue;
-                break;
-            }
-        }
-    }
-    return dlcQueue;
+    return stub.getDLCQueue();
 }


Input:
public void actionPerformed(ActionEvent ae) {
    String cmd = ae.getActionCommand();
    if (cmd.equals("String_Node_Str"))
        SymmetryGui.getInstance();
    if (symm == null)
        logger.error("String_Node_Str");
    try {
        if (cmd.equals("String_Node_Str")) {
            MultipleAlignmentJmol j = SymmetryDisplay.displayRepeats(symm);
            String s = SymmetryDisplay.printSymmetryAxes(symm, true);
            j.evalString(s);
        } else if (cmd.equals("String_Node_Str")) {
            MultipleAlignmentJmol j = SymmetryDisplay.displayFull(symm);
            String s = SymmetryDisplay.printSymmetryAxes(symm, false);
            j.evalString(s);
        } else if (cmd.equals("String_Node_Str")) {
            Atom[] cloned = StructureTools.cloneAtomArray(symm.getAtoms());
            AbstractAlignmentJmol jmol = StructureAlignmentDisplay.display(symm.getSelfAlignment(), symm.getAtoms(), cloned);
            RotationAxis axis = new RotationAxis(symm.getSelfAlignment());
            jmol.evalString(axis.getJmolScript(symm.getAtoms()));
            jmol.setTitle(SymmetryDisplay.getSymmTitle(symm));
        } else if (cmd.equals("String_Node_Str")) {
            String script = SymmetryDisplay.printSymmetryGroup(symm);
            jmol.evalString(script);
        } else if (cmd.equals("String_Node_Str")) {
            String s = SymmetryDisplay.printSymmetryAxes(symm, false);
            jmol.evalString(s);
        }
    } catch (Exception e) {
        logger.error("String_Node_Str", e);
    }
}

Output:
             MultipleAlignmentJmol j = SymmetryDisplay.displayRepeats(symm);
-            String s = SymmetryDisplay.printSymmetryAxes(symm, true);
+            String s = SymmetryDisplay.printSymmetryAxes(symm);
             j.evalString(s);


Input:
void showInputMethodMenu() {
    if (DEBUG)
        Slog.v(TAG, "String_Node_Str");
    hideInputMethodMenu();
    final Context context = mContext;
    final PackageManager pm = context.getPackageManager();
    String lastInputMethodId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.DEFAULT_INPUT_METHOD);
    if (DEBUG)
        Slog.v(TAG, "String_Node_Str" + lastInputMethodId);
    final List<InputMethodInfo> immis = getEnabledInputMethodList();
    int N = (immis == null ? 0 : immis.size());
    mItems = new CharSequence[N];
    mIms = new InputMethodInfo[N];
    for (int i = 0; i < N; ++i) {
        InputMethodInfo property = immis.get(i);
        mItems[i] = property.loadLabel(pm);
        mIms[i] = property;
    }
    int checkedItem = 0;
    for (int i = 0; i < N; ++i) {
        if (mIms[i].getId().equals(lastInputMethodId)) {
            checkedItem = i;
            break;
        }
    }
    AlertDialog.OnClickListener adocl = new AlertDialog.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            hideInputMethodMenu();
        }
    };
    TypedArray a = context.obtainStyledAttributes(null, com.android.internal.R.styleable.DialogPreference, com.android.internal.R.attr.alertDialogStyle, 0);
    mDialogBuilder = new AlertDialog.Builder(context).setTitle(com.android.internal.R.string.select_input_method).setOnCancelListener(new OnCancelListener() {
        public void onCancel(DialogInterface dialog) {
            hideInputMethodMenu();
        }
    }).setIcon(a.getDrawable(com.android.internal.R.styleable.DialogPreference_dialogTitle));
    a.recycle();
    mDialogBuilder.setSingleChoiceItems(mItems, checkedItem, new AlertDialog.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            synchronized (mMethodMap) {
                InputMethodInfo im = mIms[which];
                hideInputMethodMenu();
                setInputMethodLocked(im.getId());
            }
        }
    });
    synchronized (mMethodMap) {
        mSwitchingDialog = mDialogBuilder.create();
        mSwitchingDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG);
        mSwitchingDialog.show();
    }
}

Output:
     final List<InputMethodInfo> immis = getEnabledInputMethodList();
-    int N = (immis == null ? 0 : immis.size());
+    if (immis == null) {
+        return;
+    }
+    int N = immis.size();
     mItems = new CharSequence[N];


Input:
public String getValidValuesStatement() {
    IndicatorDefinition indicatorDefinition = this.indicator.getIndicatorDefinition();
    if (indicatorDefinition instanceof UDIndicatorDefinition) {
        EList<TdExpression> list = ((UDIndicatorDefinition) indicatorDefinition).getViewValidValuesExpression();
        return getQueryAfterReplaced(indicatorDefinition, list);
    }
    String regexPatternString = dbmsLanguage.getRegexPatternString(this.indicator);
    String regexCmp = getRegexLike(regexPatternString) + dbmsLanguage.getFunctionReturnValue();
    return getValuesStatement(columnName, regexCmp);
}

Output:
     String regexPatternString = dbmsLanguage.getRegexPatternString(this.indicator);
-    String regexCmp = getRegexLike(regexPatternString) + dbmsLanguage.getFunctionReturnValue();
+    String regexCmp = getRegexLike(regexPatternString);
     return getValuesStatement(columnName, regexCmp);


Input:
private void selectCSVFile() {
    JButton selectCSV = (JButton) componentMap.get("String_Node_Str");
    JComboBox csvLabel = (JComboBox) componentMap.get("String_Node_Str");
    if (fc.showOpenDialog(selectCSV) == JFileChooser.APPROVE_OPTION) {
        for (int i = 0; i < csvLabel.getItemCount(); i++) if (((String) csvLabel.getItemAt(i)).equals(filename.string)) {
            csvLabel.setSelectedItem(filename.string);
            return;
        }
        csvLabel.addItem(filename.string);
        csvLabel.setSelectedItem(filename.string);
    }
}

Output:
 private void selectCSVFile() {
-    JButton selectCSV = (JButton) componentMap.get("String_Node_Str");
-    JComboBox csvLabel = (JComboBox) componentMap.get("String_Node_Str");
-    if (fc.showOpenDialog(selectCSV) == JFileChooser.APPROVE_OPTION) {
-        for (int i = 0; i < csvLabel.getItemCount(); i++) if (((String) csvLabel.getItemAt(i)).equals(filename.string)) {
-            csvLabel.setSelectedItem(filename.string);
+    if (fc.showOpenDialog(Experiment.selectCSV) == JFileChooser.APPROVE_OPTION) {
+        for (int i = 0; i < Experiment.csvLabel.getItemCount(); i++) if (((String) Experiment.csvLabel.getItemAt(i)).equals(filename.string)) {
+            Experiment.csvLabel.setSelectedItem(filename.string);
             return;


Input:
protected void addScanIteratorSettings(final ScannerBase scanner) {
    addFieldSubsettingToIterator(scanner);
    if ((distributableFilters != null) && !distributableFilters.isEmpty() && queryFiltersEnabled) {
        final IteratorSetting iteratorSettings;
        if (isAggregation()) {
            iteratorSettings = new IteratorSetting(QueryFilterIterator.QUERY_ITERATOR_PRIORITY, QueryFilterIterator.QUERY_ITERATOR_NAME, AggregationIterator.class);
            iteratorSettings.addOption(AggregationIterator.ADAPTER_OPTION_NAME, ByteArrayUtils.byteArrayToString(PersistenceUtils.toBinary(aggregation.getLeft())));
            final Aggregation aggr = aggregation.getRight();
            iteratorSettings.addOption(AggregationIterator.AGGREGATION_OPTION_NAME, aggr.getClass().getName());
            iteratorSettings.addOption(AggregationIterator.CONSTRAINTS_OPTION_NAME, ByteArrayUtils.byteArrayToString((PersistenceUtils.toBinary((List) constraints))));
            iteratorSettings.addOption(AggregationIterator.INDEX_STRATEGY_OPTION_NAME, ByteArrayUtils.byteArrayToString(PersistenceUtils.toBinary(index.getIndexStrategy())));
        } else {
            iteratorSettings = new IteratorSetting(QueryFilterIterator.QUERY_ITERATOR_PRIORITY, QueryFilterIterator.QUERY_ITERATOR_NAME, QueryFilterIterator.class);
        }
        final DistributableQueryFilter filterList = new DistributableFilterList(distributableFilters);
        iteratorSettings.addOption(QueryFilterIterator.FILTER, ByteArrayUtils.byteArrayToString(PersistenceUtils.toBinary(filterList)));
        iteratorSettings.addOption(QueryFilterIterator.MODEL, ByteArrayUtils.byteArrayToString(PersistenceUtils.toBinary(index.getIndexModel())));
        scanner.addScanIterator(iteratorSettings);
    } else {
        final IteratorSetting iteratorSettings = new IteratorSetting(QueryFilterIterator.WHOLE_ROW_ITERATOR_PRIORITY, QueryFilterIterator.WHOLE_ROW_ITERATOR_NAME, WholeRowIterator.class);
        scanner.addScanIterator(iteratorSettings);
    }
}

Output:
             iteratorSettings.addOption(AggregationIterator.AGGREGATION_OPTION_NAME, aggr.getClass().getName());
-            iteratorSettings.addOption(AggregationIterator.CONSTRAINTS_OPTION_NAME, ByteArrayUtils.byteArrayToString((PersistenceUtils.toBinary((List) constraints))));
+            if (aggr.getParameters() != null) {
+                iteratorSettings.addOption(AggregationIterator.CONSTRAINTS_OPTION_NAME, ByteArrayUtils.byteArrayToString((PersistenceUtils.toBinary(aggr.getParameters()))));
+            }
             iteratorSettings.addOption(AggregationIterator.INDEX_STRATEGY_OPTION_NAME, ByteArrayUtils.byteArrayToString(PersistenceUtils.toBinary(index.getIndexStrategy())));


Input:
private void createData() {
    ArrayList<Integer> iAlStorageId = new ArrayList<Integer>();
    String sStorageIDs = "String_Node_Str";
    sInputPattern = sInputPattern + "String_Node_Str" + "String_Node_Str";
    Combo tmpComboDataType;
    for (int iColIndex = 2; iColIndex < arComboDataType.size(); iColIndex++) {
        tmpComboDataType = arComboDataType.get(iColIndex);
        if (!arSkipColumn.get(iColIndex).getSelection()) {
            sInputPattern = sInputPattern + "String_Node_Str" + "String_Node_Str";
            continue;
        }
        if (tmpComboDataType.getText().equals("String_Node_Str") || tmpComboDataType.getText().equals("String_Node_Str")) {
            sInputPattern = sInputPattern + tmpComboDataType.getText() + "String_Node_Str";
        }
        if (tmpComboDataType.getText().equals("String_Node_Str")) {
            sInputPattern = sInputPattern + tmpComboDataType.getText() + "String_Node_Str";
        }
        if (tmpComboDataType.getText().equals("String_Node_Str")) {
            sInputPattern = sInputPattern + tmpComboDataType.getText() + "String_Node_Str";
        }
        if (tmpComboDataType.getText().equals("String_Node_Str")) {
            CmdDataCreateStorage cmdCreateStorage = (CmdDataCreateStorage) GeneralManager.get().getCommandManager().createCommandByType(ECommandType.CREATE_STORAGE);
            cmdCreateStorage.setAttributes(EManagedObjectType.STORAGE_NUMERICAL);
            cmdCreateStorage.doCommand();
            INumericalStorage storage = (INumericalStorage) cmdCreateStorage.getCreatedObject();
            String labelText = previewTable.getColumn(iColIndex).getText();
            storage.setLabel(labelText);
            iAlStorageId.add(storage.getID());
            if (!sStorageIDs.equals("String_Node_Str")) {
                sStorageIDs += IGeneralManager.sDelimiter_Parser_DataItems;
            }
            sStorageIDs = sStorageIDs + storage.getID();
        }
    }
    sInputPattern += "String_Node_Str";
    sFileName = txtFileName.getText();
    if (sFileName.equals("String_Node_Str")) {
        MessageDialog.openError(parentComposite.getShell(), "String_Node_Str", "String_Node_Str");
        return;
    }
    CmdDataCreateSet cmdCreateSet = (CmdDataCreateSet) GeneralManager.get().getCommandManager().createCommandByType(ECommandType.CREATE_SET_DATA);
    cmdCreateSet.setAttributes(iAlStorageId, ESetType.GENE_EXPRESSION_DATA);
    cmdCreateSet.doCommand();
    ISet set = cmdCreateSet.getCreatedObject();
    iCreatedSetID = set.getID();
    CmdLoadFileNStorages cmdLoadCsv = (CmdLoadFileNStorages) GeneralManager.get().getCommandManager().createCommandByType(ECommandType.LOAD_DATA_FILE);
    cmdLoadCsv.setAttributes(iAlStorageId, sFileName, sInputPattern, sDelimiter, iStartParseFileAtLine - 1, -1);
    cmdLoadCsv.doCommand();
    CmdLoadFileLookupTable cmdLoadLookupTableFile = (CmdLoadFileLookupTable) GeneralManager.get().getCommandManager().createCommandByType(ECommandType.LOAD_LOOKUP_TABLE_FILE);
    cmdLoadLookupTableFile.setAttributes(sFileName, iStartParseFileAtLine, -1, "String_Node_Str", sDelimiter, "String_Node_Str");
    cmdLoadLookupTableFile.doCommand();
    if (!txtMin.getText().isEmpty()) {
        float fMin = Float.parseFloat(txtMin.getText());
        if (!Float.isNaN(fMin)) {
            set.setMin(fMin);
        }
    }
    if (!txtMax.getText().isEmpty()) {
        float fMax = Float.parseFloat(txtMax.getText());
        if (!Float.isNaN(fMax)) {
            set.setMax(fMax);
        }
    }
    if (sDataRepMode.equals("String_Node_Str")) {
        set.setExternalDataRepresentation(EExternalDataRepresentation.NORMAL, true);
    } else if (sDataRepMode.equals("String_Node_Str")) {
        set.setExternalDataRepresentation(EExternalDataRepresentation.LOG10, true);
    } else if (sDataRepMode.equals("String_Node_Str")) {
        set.setExternalDataRepresentation(EExternalDataRepresentation.LOG2, true);
    } else
        throw new IllegalStateException("String_Node_Str");
}

Output:
     Combo tmpComboDataType;
-    for (int iColIndex = 2; iColIndex < arComboDataType.size(); iColIndex++) {
+    for (int iColIndex = 0; iColIndex < arComboDataType.size(); iColIndex++) {
         tmpComboDataType = arComboDataType.get(iColIndex);


Input:
public static String getThemeStyle(Execution exe) {
    Cookie[] cookies = ((HttpServletRequest) exe.getNativeRequest()).getCookies();
    if (cookies == null)
        return "String_Node_Str";
    String candidate = null;
    for (int i = 0; i < cookies.length; i++) {
        Cookie c = cookies[i];
        if (!THEME_COOKIE_KEY.equals(c.getName()))
            continue;
        String theme = c.getValue();
        if (theme == null)
            continue;
        String path = c.getPath();
        if (path != null && path.equals(exe.getContextPath()))
            return theme;
        if (candidate == null)
            candidate = theme;
    }
    return candidate == null ? "String_Node_Str" : candidate;
}

Output:
         String theme = c.getValue();
-        if (theme == null)
-            continue;
-        String path = c.getPath();
-        if (path != null && path.equals(exe.getContextPath()))
+        if (theme != null)
             return theme;


Input:
public ObjectReference processReference(TraceLocal trace, ObjectReference reference) {
    if (VM.VerifyAssertions)
        VM._assert(!reference.isNull());
    if (TRACE_DETAIL)
        VM.sysWriteln("String_Node_Str", reference);
    if (!trace.isLive(reference)) {
        clearReferent(reference);
        return ObjectReference.nullReference();
    }
    ObjectReference newReference = trace.getForwardedReference(reference);
    ObjectReference oldReferent = getReferent(reference);
    if (TRACE_DETAIL) {
        VM.sysWrite("String_Node_Str", newReference);
        VM.sysWriteln("String_Node_Str", oldReferent);
    }
    if (oldReferent.isNull()) {
        return ObjectReference.nullReference();
    }
    if (semantics == Semantics.SOFT) {
        if (!Plan.isEmergencyCollection()) {
            if (TRACE_DETAIL)
                VM.sysWriteln("String_Node_Str", oldReferent);
            trace.retainReferent(oldReferent);
        }
    } else if (semantics == Semantics.PHANTOM) {
    }
    if (trace.isLive(oldReferent)) {
        ObjectReference newReferent = trace.getForwardedReferent(oldReferent);
        if (TRACE_DETAIL)
            VM.sysWriteln("String_Node_Str", newReferent);
        setReferent(newReference, newReferent);
        return newReference;
    } else {
        if (TRACE_UNREACHABLE)
            VM.sysWriteln("String_Node_Str", oldReferent);
        clearReferent(newReference);
        enqueueReference(newReference);
        return ObjectReference.nullReference();
    }
}

Output:
         VM._assert(!reference.isNull());
-    if (TRACE_DETAIL)
-        VM.sysWriteln("String_Node_Str", reference);
+    if (TRACE_DETAIL) {
+        VM.sysWrite("String_Node_Str", reference);
+    }
     if (!trace.isLive(reference)) {


Input:
public static void getClass(JavaPlugin plugin, String player) {
    AClass c = MinigamesAPI.getAPI().pinstances.get(plugin).pclass.get(player);
    Player p = Bukkit.getServer().getPlayer(player);
    p.getInventory().clear();
    p.getInventory().setHelmet(null);
    p.getInventory().setChestplate(null);
    p.getInventory().setLeggings(null);
    p.getInventory().setBoots(null);
    p.updateInventory();
    p.getInventory().setContents(c.getItems());
    p.updateInventory();
}

Output:
 public static void getClass(JavaPlugin plugin, String player) {
-    AClass c = MinigamesAPI.getAPI().pinstances.get(plugin).pclass.get(player);
+    AClass c = MinigamesAPI.getAPI().pinstances.get(plugin).getPClasses().get(player);
     Player p = Bukkit.getServer().getPlayer(player);


Input:
public void openMainFrame() {
    LOGGER.info("String_Node_Str");
    windowManager.showShootingAdministration();
}

Output:
     LOGGER.info("String_Node_Str");
-    windowManager.showShootingAdministration();
+    windowManager.showAdminLogin(WindowManager.SHOW_MAINSCENE);
 }


Input:
public void testImportInnerClass01_GroovyCase() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testImportInnerClass01_GroovyCase() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
 }


Input:
public CsdlComplexType getComplexType(final FullQualifiedName complexTypeName) throws ODataException {
    if (complexTypeName.equals(nameCTPrim)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyInt16));
    } else if (complexTypeName.equals(nameCTAllPrim)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyString, PropertyProvider.propertyBinary, PropertyProvider.propertyBoolean, PropertyProvider.propertyByte, PropertyProvider.propertyDate, PropertyProvider.propertyDateTimeOffset_Precision, PropertyProvider.propertyDecimal_Scale_Precision, PropertyProvider.propertySingle, PropertyProvider.propertyDouble, PropertyProvider.propertyDuration, PropertyProvider.propertyGuid, PropertyProvider.propertyInt16, PropertyProvider.propertyInt32, PropertyProvider.propertyInt64, PropertyProvider.propertySByte, PropertyProvider.propertyTimeOfDay_Precision));
    } else if (complexTypeName.equals(nameCTCollAllPrim)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.collPropertyString, PropertyProvider.collPropertyBoolean, PropertyProvider.collPropertyByte, PropertyProvider.collPropertySByte, PropertyProvider.collPropertyInt16, PropertyProvider.collPropertyInt32, PropertyProvider.collPropertyInt64, PropertyProvider.collPropertySingle, PropertyProvider.collPropertyDouble, PropertyProvider.collPropertyDecimal, PropertyProvider.collPropertyBinary, PropertyProvider.collPropertyDate, PropertyProvider.collPropertyDateTimeOffset, PropertyProvider.collPropertyDuration, PropertyProvider.collPropertyGuid, PropertyProvider.collPropertyTimeOfDay));
    } else if (complexTypeName.equals(nameCTTwoPrim)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyInt16_NotNullable, PropertyProvider.propertyString_NotNullable));
    } else if (complexTypeName.equals(nameCTCompNav)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyString, PropertyProvider.propertyCompNav_CTNavFiveProp));
    } else if (complexTypeName.equals(nameCTMixPrimCollComp)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyInt16, PropertyProvider.collPropertyString, PropertyProvider.propertyComp_CTTwoPrim, PropertyProvider.collPropertyComp_CTTwoPrim));
    } else if (complexTypeName.equals(nameCTBase)) {
        return new CsdlComplexType().setName("String_Node_Str").setBaseType(nameCTTwoPrim).setProperties(Arrays.asList(new CsdlProperty().setName("String_Node_Str").setType(new FullQualifiedName("String_Node_Str", "String_Node_Str"))));
    } else if (complexTypeName.equals(nameCTTwoBase)) {
        return new CsdlComplexType().setName("String_Node_Str").setBaseType(nameCTBase);
    } else if (complexTypeName.equals(nameCTCompComp)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyComp_CTTwoPrim));
    } else if (complexTypeName.equals(nameCTCompCollComp)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.collPropertyComp_CTTwoPrim));
    } else if (complexTypeName.equals(nameCTPrimComp)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyInt16, PropertyProvider.propertyComp_CTAllPrim));
    } else if (complexTypeName.equals(nameCTNavFiveProp)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(Arrays.asList(PropertyProvider.propertyInt16)).setNavigationProperties((Arrays.asList(PropertyProvider.collectionNavPropertyETTwoKeyNavOne_ETTwoKeyNav, PropertyProvider.collectionNavPropertyETTwoKeyNavMany_ETTwoKeyNav_WithPartnerERKeyNavOne, new CsdlNavigationProperty().setName("String_Node_Str").setType(EntityTypeProvider.nameETMedia), new CsdlNavigationProperty().setName("String_Node_Str").setType(EntityTypeProvider.nameETMedia).setCollection(true))));
    } else if (complexTypeName.equals(nameCTNavCont)) {
        return new CsdlComplexType().setName("String_Node_Str").setProperties(new ArrayList<CsdlProperty>()).setNavigationProperties(Arrays.asList(PropertyProvider.navPropertyETKeyNavOne_CT_ETeyNav, PropertyProvider.collectionNavPropertyETKeyNavMany_CT_ETKeyNav, PropertyProvider.navPropertyETTwoKeyNavOne_CT_ETTwoKeyNav, PropertyProvider.collectionNavPropertyETTwoKeyNavMany_CT_ETTwoKeyNav));
    } else if (complexTypeName.equals(nameCTBasePrimCompNav)) {
        return new CsdlComplexType().setName("String_Node_Str").setBaseType(nameCTPrimComp).setNavigationProperties(Arrays.asList(PropertyProvider.collectionNavPropertyETTwoKeyNavMany_ETTwoKeyNav_WithPartnerERKeyNavOne, PropertyProvider.collectionNavPropertyETTwoKeyNavOne_ETTwoKeyNav, PropertyProvider.navPropertyETKeyNavOne_ETKeyNav, PropertyProvider.collectionNavPropertyETKeyNavMany_ETKeyNav));
    } else if (complexTypeName.equals(nameCTTwoBasePrimCompNav)) {
        return new CsdlComplexType().setName("String_Node_Str").setBaseType(nameCTBasePrimCompNav);
    } else if (complexTypeName.equals(nameCTMixEnumDef)) {
        return new CsdlComplexType().setName(nameCTMixEnumDef.getName()).setProperties(Arrays.asList(PropertyProvider.propertyEnumString_ENString, PropertyProvider.collPropertyEnumString_ENString, PropertyProvider.propertyTypeDefinition_TDString, PropertyProvider.collPropertyTypeDefinition_TDString));
    }
    return null;
}

Output:
     } else if (complexTypeName.equals(nameCTBase)) {
-        return new CsdlComplexType().setName("String_Node_Str").setBaseType(nameCTTwoPrim).setProperties(Arrays.asList(new CsdlProperty().setName("String_Node_Str").setType(new FullQualifiedName("String_Node_Str", "String_Node_Str"))));
+        return new CsdlComplexType().setName("String_Node_Str").setBaseType(nameCTTwoPrim).setProperties(Arrays.asList(new CsdlProperty().setName("String_Node_Str").setType(PropertyProvider.nameString)));
     } else if (complexTypeName.equals(nameCTTwoBase)) {


Input:
public List<ActivityManager.RecentTaskInfo> getRecentTasks(int numLatestTasks, int userId, boolean includeFrontMostExcludedTask, ArraySet<Integer> quietProfileIds) {
    if (mAm == null)
        return null;
    if (RecentsDebugFlags.Static.EnableMockTasks) {
        ArrayList<ActivityManager.RecentTaskInfo> tasks = new ArrayList<ActivityManager.RecentTaskInfo>();
        int count = Math.min(numLatestTasks, RecentsDebugFlags.Static.MockTaskCount);
        for (int i = 0; i < count; i++) {
            int packageIndex = i % RecentsDebugFlags.Static.MockTasksPackageCount;
            ComponentName cn = new ComponentName("String_Node_Str" + packageIndex, "String_Node_Str" + i + "String_Node_Str");
            String description = "String_Node_Str" + i + "String_Node_Str" + Long.toString(Math.abs(new Random().nextLong()), 36);
            ActivityManager.RecentTaskInfo rti = new ActivityManager.RecentTaskInfo();
            rti.id = rti.persistentId = rti.affiliatedTaskId = i;
            rti.baseIntent = new Intent();
            rti.baseIntent.setComponent(cn);
            rti.description = description;
            rti.firstActiveTime = rti.lastActiveTime = SystemClock.elapsedRealtime();
            if (i % 2 == 0) {
                rti.taskDescription = new ActivityManager.TaskDescription(description, Bitmap.createBitmap(mDummyIcon), null, 0xFF000000 | (0xFFFFFF & new Random().nextInt()), 0xFF000000 | (0xFFFFFF & new Random().nextInt()));
            } else {
                rti.taskDescription = new ActivityManager.TaskDescription();
            }
            tasks.add(rti);
        }
        return tasks;
    }
    int minNumTasksToQuery = 10;
    int numTasksToQuery = Math.max(minNumTasksToQuery, numLatestTasks);
    int flags = ActivityManager.RECENT_IGNORE_HOME_STACK_TASKS | ActivityManager.RECENT_INGORE_DOCKED_STACK_TOP_TASK | ActivityManager.RECENT_INGORE_PINNED_STACK_TASKS | ActivityManager.RECENT_IGNORE_UNAVAILABLE | ActivityManager.RECENT_INCLUDE_PROFILES;
    if (includeFrontMostExcludedTask) {
        flags |= ActivityManager.RECENT_WITH_EXCLUDED;
    }
    List<ActivityManager.RecentTaskInfo> tasks = null;
    try {
        tasks = mAm.getRecentTasksForUser(numTasksToQuery, flags, userId);
    } catch (Exception e) {
        Log.e(TAG, "String_Node_Str", e);
    }
    if (tasks == null) {
        return new ArrayList<>();
    }
    boolean isFirstValidTask = true;
    Iterator<ActivityManager.RecentTaskInfo> iter = tasks.iterator();
    while (iter.hasNext()) {
        ActivityManager.RecentTaskInfo t = iter.next();
        if (sRecentsBlacklist.contains(t.realActivity.getClassName()) || sRecentsBlacklist.contains(t.realActivity.getPackageName())) {
            iter.remove();
            continue;
        }
        boolean isExcluded = (t.baseIntent.getFlags() & Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
        isExcluded |= quietProfileIds.contains(t.userId);
        if (isExcluded && (!isFirstValidTask || !includeFrontMostExcludedTask)) {
            iter.remove();
        }
        isFirstValidTask = false;
    }
    return tasks.subList(0, Math.min(tasks.size(), numLatestTasks));
}

Output:
             rti.description = description;
-            rti.firstActiveTime = rti.lastActiveTime = SystemClock.elapsedRealtime();
+            rti.firstActiveTime = rti.lastActiveTime = i;
             if (i % 2 == 0) {


Input:
public void setCacheSize(long cacheSize) {
    long maxCacheBlock = cacheSize / 4096;
    if (maxCacheBlock > Integer.MAX_VALUE) {
        fs.setCacheSize(Integer.MAX_VALUE);
    } else {
        fs.setCacheSize((int) cacheSize);
    }
}

Output:
 public void setCacheSize(long cacheSize) {
-    long maxCacheBlock = cacheSize / 4096;
-    if (maxCacheBlock > Integer.MAX_VALUE) {
+    long cacheBlock = cacheSize / 4096;
+    if (cacheBlock > Integer.MAX_VALUE) {
         fs.setCacheSize(Integer.MAX_VALUE);


Input:
public void stop() {
    synchronized (this) {
        if (this.agentStatus == AgentStatus.RUNNING) {
            changeStatus(AgentStatus.STOPPED);
        } else {
            logger.warn("String_Node_Str", this.agentStatus);
            return;
        }
    }
    logger.info("String_Node_Str", ProductInfo.CAMEL_NAME);
    this.heartBitChecker.stop();
    tAgentInfo.setEndStatus(0);
    tAgentInfo.setEndTimestamp(System.currentTimeMillis());
    this.tcpDataSender.send(tAgentInfo);
    this.agentStatMonitor.stop();
    this.spanDataSender.stop();
    this.statDataSender.stop();
    this.tcpDataSender.stop();
    if (this.socket != null) {
        this.socket.close();
    }
    if (this.factory != null) {
        this.factory.release();
    }
}

Output:
     logger.info("String_Node_Str", ProductInfo.CAMEL_NAME);
-    this.heartBitChecker.stop();
+    this.heartBeatChecker.stop();
     tAgentInfo.setEndStatus(0);


Input:
protected void addBranchMethods() {
    Role self = this.apigen.getSelf();
    Set<IOAction> as = this.curr.getAcceptable();
    AbstractMethodBuilder bra = this.ib.newAbstractMethod("String_Node_Str");
    String ret = CaseInterfaceGenerator.getCasesInterfaceName(self, this.curr) + "String_Node_Str" + IntStream.range(1, as.size() + 1).mapToObj((i) -> "String_Node_Str" + i).collect(Collectors.joining("String_Node_Str")) + "String_Node_Str";
    bra.setReturn(ret);
    bra.addParameters(SessionApiGenerator.getRoleClassName(as.iterator().next().obj) + "String_Node_Str");
    bra.addExceptions(StateChannelApiGenerator.SCRIBBLERUNTIMEEXCEPTION_CLASS, "String_Node_Str", "String_Node_Str");
    AbstractMethodBuilder bra2 = this.ib.newAbstractMethod("String_Node_Str");
    bra2.setReturn(JavaBuilder.VOID);
    bra2.addParameters(SessionApiGenerator.getRoleClassName(as.iterator().next().obj) + "String_Node_Str");
    String next = HandleInterfaceGenerator.getHandleInterfaceName(self, this.curr) + "String_Node_Str" + IntStream.range(1, as.size() + 1).mapToObj((i) -> "String_Node_Str" + i).collect(Collectors.joining("String_Node_Str")) + "String_Node_Str";
    bra2.addParameters(next + "String_Node_Str");
    bra2.addExceptions(StateChannelApiGenerator.SCRIBBLERUNTIMEEXCEPTION_CLASS, "String_Node_Str", "String_Node_Str");
    AbstractMethodBuilder bra3 = this.ib.newAbstractMethod("String_Node_Str");
    bra3.setReturn(JavaBuilder.VOID);
    bra3.addParameters(SessionApiGenerator.getRoleClassName(as.iterator().next().obj) + "String_Node_Str");
    String handle = HandleInterfaceGenerator.getHandleInterfaceName(self, this.curr) + "String_Node_Str" + as.stream().sorted(IOStateInterfaceGenerator.IOACTION_COMPARATOR).map((a) -> SuccessorInterfaceGenerator.getSuccessorInterfaceName(a)).collect(Collectors.joining("String_Node_Str")) + "String_Node_Str";
    bra3.addParameters(handle + "String_Node_Str");
    bra3.addExceptions(StateChannelApiGenerator.SCRIBBLERUNTIMEEXCEPTION_CLASS, "String_Node_Str", "String_Node_Str");
}

Output:
     Role self = this.apigen.getSelf();
-    Set<IOAction> as = this.curr.getAcceptable();
+    Set<IOAction> as = this.curr.getTakeable();
     AbstractMethodBuilder bra = this.ib.newAbstractMethod("String_Node_Str");


Input:
public static Image getJobletCustomIcon(Property property) {
    JobletProcessItem item = (JobletProcessItem) property.getItem();
    Image image = null;
    if (item.getIcon() == null || item.getIcon().getInnerContent() == null || item.getIcon().getInnerContent().length == 0) {
        image = getDefaultJobletImage();
    } else {
        ImageDescriptor imageDesc = ImageUtils.createImageFromData(item.getIcon().getInnerContent());
        imageDesc = ImageUtils.scale(imageDesc, ICON_SIZE.ICON_32);
        image = cachedImages.get(item.getIcon().getInnerContent());
        if (image == null || image.isDisposed()) {
            image = imageDesc.createImage();
            cachedImages.put(item.getIcon().getInnerContent(), image);
        } else {
        }
    }
    return image;
}

Output:
         imageDesc = ImageUtils.scale(imageDesc, ICON_SIZE.ICON_32);
-        image = cachedImages.get(item.getIcon().getInnerContent());
+        String md5Desc = MD5.getMD5(item.getIcon().getInnerContent());
+        image = cachedImages.get(md5Desc);
         if (image == null || image.isDisposed()) {


Input:
private GitModelObject handleCacheTree(ObjectId repoId, ObjectId cacheId, String path) throws IOException {
    String pathKey = path.split("String_Node_Str")[0];
    GitModelCacheTree cacheTree = cacheTreeMap.get(pathKey);
    if (cacheTree == null) {
        cacheTree = new GitModelCacheTree(this, remoteCommit, repoId, cacheId, pathKey, fileFactory);
        cacheTreeMap.put(pathKey, cacheTree);
    }
    cacheTree.addChild(repoId, cacheId, path.substring(path.indexOf('/') + 1));
    return cacheTree;
}

Output:
     if (cacheTree == null) {
-        cacheTree = new GitModelCacheTree(this, remoteCommit, repoId, cacheId, pathKey, fileFactory);
+        cacheTree = new GitModelCacheTree(this, baseCommit, repoId, cacheId, pathKey, fileFactory);
         cacheTreeMap.put(pathKey, cacheTree);


Input:
private void updateLayouts(boolean manual) {
    if (!WallpaperFactory.isWallpaperThemeSelected(getActivity())) {
        if (!manual) {
            mBackgroundSpinner.setSelection(0);
        } else {
            mPreviewImageDrawable.reverseTransition(TRANSITION_ANIM_DURATION);
        }
        mRadiusSeek.setEnabled(false);
        mDimSeek.setEnabled(false);
        mRadiusText.setEnabled(false);
        mDimText.setEnabled(false);
    } else {
        if (!manual) {
            mBackgroundSpinner.setSelection(1);
        } else {
            mPreviewImageDrawable.reverseTransition(TRANSITION_ANIM_DURATION);
        }
        mRadiusSeek.setEnabled(true);
        mDimSeek.setEnabled(true);
        mRadiusText.setEnabled(true);
        mDimText.setEnabled(true);
    }
}

Output:
 private void updateLayouts(boolean manual) {
-    if (!WallpaperFactory.isWallpaperThemeSelected(getActivity())) {
+    if (!mWallpaperFactory.isWallpaperThemeSelected()) {
         if (!manual) {


Input:
protected MtdInvocationExpr doTranslate(MessageSend astMsgSend) {
    String methodNameStr = null;
    if (astMsgSend.getSelector() == null) {
        IExpression astReceiver = astMsgSend.getReceiver();
        BaseAst2JstTranslator translator = getTranslator(astReceiver);
        IExpr mtdIdentifier = (IExpr) translator.translate(astReceiver);
        if (mtdIdentifier instanceof JstIdentifier) {
            jstInvocation = new MtdInvocationExpr(mtdIdentifier);
        } else {
            jstInvocation = new MtdInvocationExpr(new JstProxyIdentifier(mtdIdentifier));
        }
    } else {
        methodNameStr = new String(astMsgSend.getSelector());
        jstInvocation = new MtdInvocationExpr(methodNameStr);
    }
    try {
        m_ctx.enterBlock(ScopeIds.METHOD_CALL);
        IExpression[] args = astMsgSend.getArguments();
        if (args != null) {
            int prev = 0;
            int next = 0;
            int len = args.length;
            for (int i = 0; i < len; i++) {
                if (i == 0) {
                    IExpression rec = astMsgSend.getReceiver();
                    prev = (rec != null) ? rec.sourceStart() : astMsgSend.sourceStart();
                } else {
                    prev = args[i - 1].sourceEnd();
                }
                if (i + 1 < len) {
                    next = args[i + 1].sourceStart();
                } else {
                    next = astMsgSend.statementEnd;
                }
                IExpression argExpression = args[i];
                BaseAst2JstTranslator translator;
                translator = getTranslator(argExpression);
                Object stmt = translator.translate(argExpression);
                if (stmt instanceof IExpr) {
                    List<IJsCommentMeta> metaList = null;
                    IExpr jstArg = null;
                    if (stmt instanceof BaseJstNode) {
                        metaList = TranslateHelper.findMetaFromExpr((BaseJstNode) stmt);
                    }
                    if (metaList != null) {
                        jstArg = TranslateHelper.getCastable((IExpr) stmt, metaList, m_ctx);
                    } else {
                        jstArg = TranslateHelper.getCastable((IExpr) stmt, argExpression, prev, next, m_ctx);
                    }
                    jstInvocation.addArg(jstArg);
                } else if (stmt instanceof JstMethod) {
                    IExpr jstArg = new FuncExpr((JstMethod) stmt);
                    jstArg = TranslateHelper.getCastable(jstArg, argExpression, prev, next, m_ctx);
                    jstInvocation.addArg(jstArg);
                } else {
                    if (m_ctx.getCurrentType() != null && m_ctx.getCurrentType().getName() != null) {
                        String name = m_ctx.getCurrentType().getName();
                        m_ctx.getErrorReporter().error("String_Node_Str" + argExpression.getClass() + "String_Node_Str" + IExpr.class + "String_Node_Str" + MessageSendTranslator.class, name, 0, 0);
                    }
                }
            }
        }
    } finally {
        m_ctx.exitBlock();
    }
    int sourceStart = astMsgSend.sourceStart;
    IExpression astReceiver = astMsgSend.getReceiver();
    if (astReceiver != null) {
        sourceStart = calculateSourceStart(astMsgSend, astReceiver, astMsgSend.getSelector());
    }
    if (methodNameStr != null) {
        if (astReceiver != null) {
            BaseAst2JstTranslator translator = getTranslator(astReceiver);
            IExpr jstQualifier = (IExpr) translator.translate(astReceiver);
            jstInvocation.setQualifyExpr(jstQualifier);
        }
        JstSource nameSource = TranslateHelper.getMethodSource(m_ctx.getOriginalSource(), m_ctx.getSourceUtil(), sourceStart, astMsgSend.sourceEnd, methodNameStr.length());
        ((JstIdentifier) jstInvocation.getMethodIdentifier()).setSource(nameSource);
    }
    int sourceEnd = astMsgSend.statementEnd;
    if (sourceEnd == -1) {
        sourceEnd = astMsgSend.sourceEnd;
    }
    JstSource methodSource = TranslateHelper.getMethodSource(m_ctx.getOriginalSource(), m_ctx.getSourceUtil(), astMsgSend.sourceStart, sourceEnd, sourceEnd - astMsgSend.sourceStart);
    jstInvocation.setSource(methodSource);
    return jstInvocation;
}

Output:
                 BaseAst2JstTranslator translator;
-                translator = getTranslator(argExpression);
+                if (argExpression instanceof ObjectLiteral && (isVjoOL(methodNameStr))) {
+                    translator = new VjoOLTranslator(m_ctx);
+                } else {
+                    translator = getTranslator(argExpression);
+                }
                 Object stmt = translator.translate(argExpression);


Input:
private static String getReadmeText(final ZipFile zipFile) {
    for (ZipEntry entry : new HashSet<ZipEntry>(Collections.list(zipFile.entries()))) {
        if (!entry.isDirectory() && entry.getName().toLowerCase().contains("String_Node_Str")) {
            try (StringWriter writer = new StringWriter()) {
                IOUtils.copy(zipFile.getInputStream(entry), writer);
                return writer.toString();
            } catch (IOException e) {
            }
        }
    }
    return null;
}

Output:
         if (!entry.isDirectory() && entry.getName().toLowerCase().contains("String_Node_Str")) {
-            try (StringWriter writer = new StringWriter()) {
-                IOUtils.copy(zipFile.getInputStream(entry), writer);
+            try (StringWriter writer = new StringWriter();
+                InputStream is = zipFile.getInputStream(entry)) {
+                IOUtils.copy(is, writer);
                 return writer.toString();


Input:
private void findExpressions() throws SAXParseException {
    int idx = 0;
    do {
        idx = buf.indexOf("String_Node_Str", idx);
        if (idx < 0)
            break;
        int end = buf.indexOf("String_Node_Str", idx);
        if (end == -1)
            throw new SAXParseException("String_Node_Str", locator);
        String exp = buf.substring(idx + 3, end);
        getLog().debug("String_Node_Str" + exp);
        int op = exp.indexOf('(');
        if (op >= 0)
            exp = exp.substring(0, op);
        properties.add(exp);
    } while (true);
    buf.setLength(0);
}

Output:
 private void findExpressions() throws SAXParseException {
-    int idx = 0;
+    int idx = -1;
     do {


Input:
public static void removeApplication(String applicationId) throws RestAPIException {
    try {
        AutoscalerServiceClient asServiceClient = getAutoscalerServiceClient();
        ApplicationBean application = ObjectConverter.convertStubApplicationContextToApplicationDefinition(asServiceClient.getApplication(applicationId));
        asServiceClient.deleteApplication(applicationId);
        Set<String> cartridgeNames;
        Set<String> cartridgeGroupNames;
        StratosManagerServiceClient smServiceClient = getStratosManagerServiceClient();
        List<CartridgeReferenceBean> cartridges = application.getComponents().getCartridges();
        if (cartridges != null) {
            cartridgeNames = new HashSet<String>();
            for (CartridgeReferenceBean cartridge : cartridges) {
                cartridgeNames.add(cartridge.getType());
            }
            smServiceClient.removeUsedCartridgesInApplications(application.getApplicationId(), (String[]) cartridgeNames.toArray());
        }
        List<GroupReferenceBean> cartridgeGroups = application.getComponents().getGroups();
        if (cartridgeGroups != null) {
            cartridgeGroupNames = new HashSet<String>();
            for (GroupReferenceBean cartridgeGroup : cartridgeGroups) {
                cartridgeGroupNames.add(cartridgeGroup.getName());
            }
            smServiceClient.removeUsedCartridgeGroupsInApplications(application.getApplicationId(), (String[]) cartridgeGroupNames.toArray());
        }
    } catch (RemoteException e) {
        String message = "String_Node_Str" + applicationId;
        log.error(message, e);
        throw new RestAPIException(message, e);
    }
}

Output:
         asServiceClient.deleteApplication(applicationId);
-        Set<String> cartridgeNames;
-        Set<String> cartridgeGroupNames;
+        String[] cartridgeNames;
+        String[] cartridgeGroupNames;
         StratosManagerServiceClient smServiceClient = getStratosManagerServiceClient();


Input:
public static void execute(final ExecutionStep step) {
    final Deque<StackObject> stack = step.getStack();
    if (ScriptOperationUtil.isDataPushOperation(step.getInstruction().getOperation())) {
        addStackObject(stack, step.getInstruction().getBytes());
    }
    switch(step.getInstruction().getOperation()) {
        case OP_DUP:
            addStackObject(stack, stack.peek());
            break;
        case OP_2DUP:
            final Iterator<StackObject> dup2Iterator = stack.iterator();
            addStackObject(stack, dup2Iterator.next());
            addStackObject(stack, dup2Iterator.next());
            break;
        case OP_3DUP:
            final Iterator<StackObject> dup3Iterator = stack.iterator();
            addStackObject(stack, dup3Iterator.next());
            addStackObject(stack, dup3Iterator.next());
            addStackObject(stack, dup3Iterator.next());
            break;
        case OP_DROP:
            stack.remove();
            break;
        case OP_2DROP:
            stack.remove();
            stack.remove();
            break;
        case OP_CHECKSIG:
            stack.remove();
            stack.remove();
            addTrue(stack);
            break;
        case OP_EQUAL:
            final StackObject objEqualA = stack.poll();
            final StackObject objEqualB = stack.poll();
            if (!Arrays.areEqual(objEqualA.getBytes(), objEqualB.getBytes())) {
                addTrue(stack);
            } else {
                addFalse(stack);
            }
            break;
        case OP_EQUALVERIFY:
            final StackObject objEqualVerifyA = stack.poll();
            final StackObject objEqualVerifyB = stack.poll();
            if (!Arrays.areEqual(objEqualVerifyA.getBytes(), objEqualVerifyB.getBytes())) {
                addException(step);
            }
            break;
        case OP_HASH160:
            final StackObject poll = stack.poll();
            final byte[] hash160 = ComputeUtil.computeHash160(poll.getBytes());
            addStackObject(stack, hash160);
            break;
        case OP_TRUE:
            addTrue(stack);
            break;
        case OP_FALSE:
            addFalse(stack);
            break;
        default:
    }
}

Output:
             final StackObject objEqualB = stack.poll();
-            if (!Arrays.areEqual(objEqualA.getBytes(), objEqualB.getBytes())) {
+            if (Arrays.areEqual(objEqualA.getBytes(), objEqualB.getBytes())) {
                 addTrue(stack);


Input:
public void checkWritingInputFileFromTree() {
    String separator = System.getProperty("String_Node_Str");
    String userDir = System.getProperty("String_Node_Str") + separator + "String_Node_Str" + separator + "String_Node_Str";
    String filePath = userDir + separator + "String_Node_Str";
    String outputFilePath = userDir + separator + "String_Node_Str";
    String refFilePath = userDir + separator + "String_Node_Str";
    File outputFile = null;
    MOOSEFileHandler handler = new MOOSEFileHandler();
    TreeComposite adaptivity = null, indicators = null;
    TreeComposite analyticalIndicator = null, fluxJumpIndicator = null;
    TreeComposite function = null, powerHistory = null;
    ArrayList<TreeComposite> blocks = null;
    try {
        blocks = handler.loadYAML(filePath);
    } catch (IOException e1) {
        e1.printStackTrace();
    }
    adaptivity = getTreeByName(blocks, "String_Node_Str");
    indicators = (TreeComposite) adaptivity.getChildExemplars().get(0).clone();
    analyticalIndicator = (TreeComposite) indicators.getChildExemplars().get(1).clone();
    fluxJumpIndicator = (TreeComposite) indicators.getChildExemplars().get(2).clone();
    adaptivity.setNextChild(indicators);
    indicators.setNextChild(analyticalIndicator);
    analyticalIndicator.setActive(true);
    indicators.setNextChild(fluxJumpIndicator);
    adaptivity.setActive(true);
    indicators.setActive(true);
    analyticalIndicator.setActive(true);
    fluxJumpIndicator.setActive(true);
    DataComponent adaptivityData = (DataComponent) adaptivity.getDataNodes().get(0);
    adaptivity.setActiveDataNode(adaptivityData);
    adaptivityData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    adaptivityData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    adaptivityData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    DataComponent analyticalIndicatorsComponent = (DataComponent) analyticalIndicator.getDataNodes().get(0);
    analyticalIndicatorsComponent.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    analyticalIndicatorsComponent.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    DataComponent fluxJumpIndicatorComponent = (DataComponent) fluxJumpIndicator.getDataNodes().get(0);
    fluxJumpIndicatorComponent.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    fluxJumpIndicatorComponent.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    fluxJumpIndicatorComponent.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    function = (TreeComposite) getTreeByName(blocks, "String_Node_Str");
    powerHistory = (TreeComposite) function.getChildExemplars().get(14).clone();
    function.setNextChild(powerHistory);
    powerHistory.setName("String_Node_Str");
    function.setActive(true);
    powerHistory.setActive(true);
    DataComponent powerData = (DataComponent) powerHistory.getDataNodes().get(0);
    powerData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    powerData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
    Parameter dataFileParam = new Parameter();
    dataFileParam.setName("String_Node_Str");
    dataFileParam.setDefault("String_Node_Str");
    dataFileParam.setEnabled(true);
    powerData.addEntry(dataFileParam.toEntry());
    handler.dumpInputFile(outputFilePath, blocks);
    outputFile = new File(outputFilePath);
    assertTrue(outputFile.exists());
    int firstHash, lastHash;
    try {
        RandomAccessFile inputFileRAF = new RandomAccessFile(outputFilePath, "String_Node_Str");
        byte[] inputBytes = new byte[(int) inputFileRAF.length()];
        inputFileRAF.read(inputBytes);
        String inputString = new String(inputBytes);
        String[] inputArray = inputString.split("String_Node_Str");
        inputString = "String_Node_Str";
        boolean hasComment = false;
        for (String line : inputArray) {
            hasComment = !(line.lastIndexOf("String_Node_Str") == -1);
            if (hasComment) {
                firstHash = line.trim().indexOf("String_Node_Str");
                lastHash = line.trim().lastIndexOf("String_Node_Str");
                if (firstHash == 0 && firstHash == lastHash) {
                } else {
                    line = line.substring(0, line.lastIndexOf("String_Node_Str"));
                    line = line.replaceAll("String_Node_Str", "String_Node_Str");
                }
                if (line.endsWith("String_Node_Str")) {
                    line += "String_Node_Str";
                }
            }
            inputString += line + "String_Node_Str";
        }
        RandomAccessFile refFileRAF = new RandomAccessFile(refFilePath, "String_Node_Str");
        byte[] refBytes = new byte[(int) refFileRAF.length()];
        refFileRAF.read(refBytes);
        String refString = new String(refBytes);
        System.out.println(inputString);
        assertEquals(refString, inputString);
        inputFileRAF.close();
        refFileRAF.close();
        outputFile.deleteOnExit();
    } catch (IOException e) {
        e.printStackTrace();
        fail();
    }
    return;
}

Output:
     powerData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
-    Parameter dataFileParam = new Parameter();
-    dataFileParam.setName("String_Node_Str");
-    dataFileParam.setDefault("String_Node_Str");
-    dataFileParam.setEnabled(true);
-    powerData.addEntry(dataFileParam.toEntry());
+    powerData.retrieveEntry("String_Node_Str").setValue("String_Node_Str");
+    powerData.retrieveEntry("String_Node_Str").setTag("String_Node_Str");
     handler.dumpInputFile(outputFilePath, blocks);


Input:
private void doWait() {
    if (waitTimeout < -1) {
        inputReady.set(false);
        return;
    }
    synchronized (this) {
        waiting.set(true);
    }
    final long start = System.currentTimeMillis();
    final BlockingQueue<Runnable> commands = agent.getCommandQueue();
    boolean done = isDoneWaiting();
    while (!done) {
        try {
            final long remaining = waitTimeout - (System.currentTimeMillis() - start);
            if (remaining <= 0) {
                done = true;
            }
            final Runnable command = commands.poll(remaining, TimeUnit.MILLISECONDS);
            if (command != null) {
                command.run();
                done = isDoneWaiting();
            } else {
                done = true;
            }
        } catch (InterruptedException e) {
            done = true;
            break;
        }
    }
    waitTimeout = -1;
    synchronized (this) {
        inputReady.set(false);
        waiting.set(false);
    }
}

Output:
 private void doWait() {
-    if (waitTimeout < -1) {
+    if (!requestedWaitInfo.waiting) {
         inputReady.set(false);


Input:
private boolean isPermissionGranted(int id) {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CALENDAR) == PackageManager.PERMISSION_GRANTED && ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED) {
        return true;
    } else {
        if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_CALENDAR) || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_CALENDAR)) {
            new AlertDialog.Builder(this).setMessage(getString(R.string.permission_calendar_explanation)).setPositiveButton(R.string.ok, (dialog, id1) -> ActivityCompat.requestPermissions(CalendarActivity.this, PERMISSIONS_CALENDAR, id1)).show();
        } else {
            ActivityCompat.requestPermissions(this, PERMISSIONS_CALENDAR, id);
        }
    }
    return false;
}

Output:
         if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_CALENDAR) || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_CALENDAR)) {
-            new AlertDialog.Builder(this).setMessage(getString(R.string.permission_calendar_explanation)).setPositiveButton(R.string.ok, (dialog, id1) -> ActivityCompat.requestPermissions(CalendarActivity.this, PERMISSIONS_CALENDAR, id1)).show();
+            new AlertDialog.Builder(this).setMessage(getString(R.string.permission_calendar_explanation)).setPositiveButton(R.string.ok, (dialog, id1) -> ActivityCompat.requestPermissions(CalendarActivity.this, PERMISSIONS_CALENDAR, id)).show();
         } else {


Input:
public IType getConcreteType(Map<String, IType> typeVariables) {
    if (this.name != null) {
        IType t = typeVariables.get(this.name);
        if (t != null) {
            if (this.arrayDimensions > 0) {
                return t.getArrayType(this.arrayDimensions);
            }
            return t;
        }
    }
    return this;
}

Output:
     }
-    return this;
+    WildcardType type = new WildcardType(this.position);
+    if (this.lowerBound != null) {
+        type.lowerBound = this.lowerBound.getConcreteType(typeVariables);
+    }
+    if (this.upperBound != null) {
+        type.upperBound = this.upperBound.getConcreteType(typeVariables);
+    }
+    if (this.upperBounds != null) {
+        int len = this.upperBounds.size();
+        if (len > 0) {
+            type.upperBounds = new ArrayList(len);
+            for (int i = 0; i < len; i++) {
+                type.upperBounds.add(this.upperBounds.get(i).getConcreteType(typeVariables));
+            }
+        }
+    }
+    return type;
 }


Input:
public double getOwnOptionDouble(String optionName, String world, double defaultValue) {
    String option = this.getOwnOption(optionName, world, Double.toString(defaultValue));
    try {
        return Double.parseDouble(option);
    } catch (NumberFormatException e) {
    }
    return defaultValue;
}

Output:
         return Double.parseDouble(option);
-    } catch (NumberFormatException e) {
+    } catch (NumberFormatException ignore) {
     }


Input:
private void createContextsAndSetExecutor(HttpServer server) {
    RequestHandler requestHandler = new RequestHandler();
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str");
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.createContext("String_Node_Str", requestHandler);
    server.setExecutor(new Executor() {
        public void execute(Runnable command) {
            try {
                new Thread(command).start();
            } catch (Exception e) {
                System.err.println("String_Node_Str" + e.getMessage());
                ErrorLogger.log("String_Node_Str", "String_Node_Str" + "String_Node_Str" + e.getMessage());
            }
        }
    });
}

Output:
     server.createContext("String_Node_Str", requestHandler);
-    server.createContext("String_Node_Str");
+    server.createContext("String_Node_Str", requestHandler);
     server.createContext("String_Node_Str", requestHandler);


Input:
protected Collection<CollectionRecord> removeAllInternal(Data key) {
    throwExceptionIfNull(key);
    long timeout = tx.getTimeoutMillis();
    long ttl = timeout * 3 / 2;
    Collection<CollectionRecord> coll = txMap.get(key);
    if (coll == null) {
        CollectionResponse response = lockAndGet(key, timeout, ttl);
        if (response == null) {
            throw new ConcurrentModificationException("String_Node_Str" + getThreadId());
        }
        version = response.getTxVersion();
        coll = createCollection(response.getRecordCollection(getNodeEngine()));
    }
    txMap.put(key, createCollection());
    TxnRemoveAllOperation operation = new TxnRemoveAllOperation(proxyId, key, coll);
    MultiMapTransactionLog log = (MultiMapTransactionLog) tx.getTransactionLog(getTxLogKey(key));
    if (log != null) {
        log.addOperation(operation);
    } else {
        log = new MultiMapTransactionLog(key, proxyId, ttl, getThreadId(), version, operation);
        tx.addTransactionLog(log);
    }
    return coll;
}

Output:
     TxnRemoveAllOperation operation = new TxnRemoveAllOperation(proxyId, key, coll);
-    MultiMapTransactionLog log = (MultiMapTransactionLog) tx.getTransactionLog(getTxLogKey(key));
-    if (log != null) {
-        log.addOperation(operation);
-    } else {
-        log = new MultiMapTransactionLog(key, proxyId, ttl, getThreadId(), version, operation);
-        tx.addTransactionLog(log);
-    }
+    log.addOperation(operation);
     return coll;


Input:
public void switchBlock(Location interactLocation, SwitchState switchState, Player player) {
    World world = interactLocation.getWorld();
    boolean currentState = (interactLocation.getBlock().getData() & 0x8) > 0;
    String state = switchState.toString();
    CraftPlayer craftPlayer = (CraftPlayer) player;
    if (craftPlayer == null && Bukkit.getOnlinePlayers().length > 0) {
        if (Bukkit.getOnlinePlayers().length > 0) {
            craftPlayer = (CraftPlayer) Bukkit.getOnlinePlayers()[0];
        } else {
            for (NPC npc : CitizensAPI.getNPCRegistry()) {
                if (npc.isSpawned() && npc.getEntity() instanceof Player) {
                    craftPlayer = (CraftPlayer) npc.getEntity();
                    break;
                }
            }
        }
    }
    if ((state.equals("String_Node_Str") && !currentState) || (state.equals("String_Node_Str") && currentState) || state.equals("String_Node_Str")) {
        try {
            Block.e(interactLocation.getBlock().getType().getId()).interact(((CraftWorld) world).getHandle(), interactLocation.getBlockX(), interactLocation.getBlockY(), interactLocation.getBlockZ(), craftPlayer != null ? craftPlayer.getHandle() : null, 0, 0f, 0f, 0f);
            dB.log("String_Node_Str" + interactLocation.getBlock().getType().toString() + "String_Node_Str" + ((interactLocation.getBlock().getData() & 0x8) > 0 ? "String_Node_Str" : "String_Node_Str"));
        } catch (NullPointerException e) {
            dB.echoError("String_Node_Str" + interactLocation.getBlock().getType().toString() + "String_Node_Str");
        }
    }
}

Output:
     CraftPlayer craftPlayer = (CraftPlayer) player;
-    if (craftPlayer == null && Bukkit.getOnlinePlayers().length > 0) {
-        if (Bukkit.getOnlinePlayers().length > 0) {
-            craftPlayer = (CraftPlayer) Bukkit.getOnlinePlayers()[0];
+    if (craftPlayer == null && Bukkit.getOnlinePlayers().size() > 0) {
+        if (Bukkit.getOnlinePlayers().size() > 0) {
+            craftPlayer = (CraftPlayer) Bukkit.getOnlinePlayers().toArray()[0];
         } else {


Input:
public Object getData(int col, int row) {
    if (!valid(row, col)) {
        return null;
    } else {
        int start = ((Integer) colrow.get(new Integer(col))).intValue();
        List data = (List) columns.get(col);
        if (data.size() > (row - start)) {
            return data.get(row - start);
        } else {
            return null;
        }
    }
}

Output:
     } else {
-        int start = ((Integer) colrow.get(new Integer(col))).intValue();
+        int start = ((Integer) columnId2StartLine.get(new Integer(col))).intValue();
         List data = (List) columns.get(col);


Input:
public void cellEntered(ConeOfSilenceEnterCellMessage msg) {
    String callId = msg.getCellID().toString();
    ConeOfSilenceCellSetup setup = (ConeOfSilenceCellSetup) coneOfSilenceCellMORef.get().getCellMOSetup();
    logger.warning(callId + "String_Node_Str" + name);
    VoiceManager vm = AppContext.getManager(VoiceManager.class);
    Player player = vm.getPlayer(callId);
    AudioGroup audioGroup = vm.getAudioGroup(name);
    audioGroup.addPlayer(player, new AudioGroupPlayerInfo(true, AudioGroupPlayerInfo.ChatType.SECRET));
    player.attenuateOtherGroups(audioGroup, 0, 0);
}

Output:
 public void cellEntered(ConeOfSilenceEnterCellMessage msg) {
-    String callId = msg.getCellID().toString();
+    String callId = msg.getAvatarCellID().toString();
     ConeOfSilenceCellSetup setup = (ConeOfSilenceCellSetup) coneOfSilenceCellMORef.get().getCellMOSetup();


Input:
public Chunk getChunk() {
    Point position = transform.getPosition();
    return position.getWorld().getChunk(position, true);
}

Output:
 public Chunk getChunk() {
-    Point position = transform.getPosition();
-    return position.getWorld().getChunk(position, true);
+    while (true) {
+        int seq = lock.readLock();
+        Point position = transform.getPosition();
+        World w = position.getWorld();
+        if (w == null) {
+            if (lock.readUnlock(seq)) {
+                return null;
+            }
+        } else {
+            Chunk c = w.getChunk(position, true);
+            if (lock.readUnlock(seq)) {
+                return c;
+            }
+        }
+    }
 }


Input:
public MachineState getInitialState() {
    for (Proposition p : propNet.getInputPropositions().values()) {
        p.setValue(false);
    }
    for (Proposition p : propNet.getBasePropositions().values()) {
        p.setValue(false);
    }
    propNet.getInitProposition().setValue(true);
    for (Proposition p : ordering) {
        if (p.getInputs().size() == 1) {
            p.setValue(p.getSingleInput().getValue());
        }
    }
    return getStateFromBase();
}

Output:
 public MachineState getInitialState() {
-    for (Proposition p : propNet.getInputPropositions().values()) {
+    for (Proposition p : inputPropositions.values()) {
         p.setValue(false);


Input:
public void decodeIdent(String ident) throws IOException {
    if (ident == null) {
        return;
    }
    byte[] inputBytes = new Base32(true).decode(ident.toUpperCase(Locale.ROOT));
    BytesStreamInput in = new BytesStreamInput(inputBytes, true);
    int size = in.readVInt();
    for (int i = 0; i < size; i++) {
        BytesRef value = (BytesRef) DataType.STRING.streamer().readFrom(in);
        if (value == null) {
            values.add(null);
        } else {
            values.add(value.utf8ToString());
        }
    }
}

Output:
     }
-    byte[] inputBytes = new Base32(true).decode(ident.toUpperCase(Locale.ROOT));
+    byte[] inputBytes = BASE32.decode(ident.toUpperCase(Locale.ROOT));
     BytesStreamInput in = new BytesStreamInput(inputBytes, true);


Input:
public DeviceLockStatus3_20 call() throws XfsException {
    DeviceLockStatus3_20 result;
    XfsInfoCommand<CimInfoCommand> command = new XfsInfoCommand<CimInfoCommand>(cimService, CimInfoCommand.DEVICELOCK_STATUS);
    WFSResult wfsResult = null;
    try {
        wfsResult = new XfsCallable(command).call();
        result = CimFactory.create(cimService.getXfsVersion(), wfsResult.getResults(), DeviceLockStatus3_20.class);
        if (LOG.isInfoEnabled()) {
            LOG.info("String_Node_Str", result);
        }
    } finally {
        if (wfsResult != null) {
            XfsServiceManager.getInstance().free(wfsResult);
        }
    }
    return result;
}

Output:
     try {
-        wfsResult = new XfsCallable(command).call();
+        wfsResult = command.call();
         result = CimFactory.create(cimService.getXfsVersion(), wfsResult.getResults(), DeviceLockStatus3_20.class);


Input:
public short getFixedMaxDurability(Material m) {
    return (short) ((Material.DIAMOND_PICKAXE.getMaxStackSize() > 1) ? m.getMaxStackSize() : m.getMaxDurability());
}

Output:
 public short getFixedMaxDurability(Material m) {
-    return (short) ((Material.DIAMOND_PICKAXE.getMaxStackSize() > 1) ? m.getMaxStackSize() : m.getMaxDurability());
+    return (short) ((m.getMaxStackSize() < 1) ? m.getMaxStackSize() : m.getMaxDurability());
 }


Input:
public void onApplicationStart() {
    List<Class> classes = Play.classloader.getAnnotatedClasses(NoSqlEntity.class);
    if (classes.isEmpty())
        return;
    else if (NoSql.getEntityManagerFactory() != null) {
        NoSqlEntityManagerFactory factory = NoSql.getEntityManagerFactory();
        factory.rescan(classes, Play.classloader);
        return;
    }
    Map<String, Object> props = new HashMap<String, Object>();
    props.put(Bootstrap.LIST_OF_EXTRA_CLASSES_TO_SCAN_KEY, classes);
    props.put(Bootstrap.AUTO_CREATE_KEY, "String_Node_Str");
    for (java.util.Map.Entry<Object, Object> entry : Play.configuration.entrySet()) {
        props.put((String) entry.getKey(), entry.getValue());
    }
    if (log.isInfoEnabled())
        log.info("String_Node_Str");
    NoSqlEntityManagerFactory factory = Bootstrap.create(props, Play.classloader);
    NoSql.setEntityManagerFactory(factory);
    CassandraAppender.setFactory(factory);
}

Output:
     }
-    Map<String, Object> props = new HashMap<String, Object>();
-    props.put(Bootstrap.LIST_OF_EXTRA_CLASSES_TO_SCAN_KEY, classes);
-    props.put(Bootstrap.AUTO_CREATE_KEY, "String_Node_Str");
+    PROPS.put(Bootstrap.LIST_OF_EXTRA_CLASSES_TO_SCAN_KEY, classes);
+    PROPS.put(Bootstrap.AUTO_CREATE_KEY, "String_Node_Str");
     for (java.util.Map.Entry<Object, Object> entry : Play.configuration.entrySet()) {


Input:
public static ConfiguredTarget init(CppSemantics semantics, RuleContext ruleContext, boolean fake) throws InterruptedException, RuleErrorException {
    ruleContext.checkSrcsSamePackage(true);
    FeatureConfiguration featureConfiguration = CcCommon.configureFeatures(ruleContext);
    CcCommon common = new CcCommon(ruleContext);
    CppConfiguration cppConfiguration = ruleContext.getFragment(CppConfiguration.class);
    PrecompiledFiles precompiledFiles = new PrecompiledFiles(ruleContext);
    semantics.validateAttributes(ruleContext);
    if (ruleContext.hasErrors()) {
        return null;
    }
    CcLibraryHelper helper = new CcLibraryHelper(ruleContext, semantics, featureConfiguration).fromCommon(common).addSources(common.getSources()).addDeps(ImmutableList.of(CppHelper.mallocForTarget(ruleContext))).setFake(fake).setLinkType(LinkTargetType.STATIC_LIBRARY).addPrecompiledFiles(precompiledFiles).enableInterfaceSharedObjects();
    CcLibraryHelper.Info info = helper.build();
    CppCompilationContext cppCompilationContext = info.getCppCompilationContext();
    CcCompilationOutputs ccCompilationOutputs = info.getCcCompilationOutputs();
    PathFragment binaryPath = new PathFragment(ruleContext.getTarget().getName());
    if (!isLinkShared(ruleContext)) {
        binaryPath = new PathFragment(binaryPath.getPathString() + OsUtils.executableExtension());
    }
    Artifact binary = ruleContext.getBinArtifact(binaryPath);
    if (isLinkShared(ruleContext) && !CppFileTypes.SHARED_LIBRARY.matches(binary.getFilename()) && !CppFileTypes.VERSIONED_SHARED_LIBRARY.matches(binary.getFilename())) {
        ruleContext.attributeError("String_Node_Str", "String_Node_Str");
        return null;
    }
    LinkTargetType linkType = isLinkShared(ruleContext) ? LinkTargetType.DYNAMIC_LIBRARY : LinkTargetType.EXECUTABLE;
    List<String> linkopts = common.getLinkopts();
    LinkStaticness linkStaticness = getLinkStaticness(ruleContext, linkopts, cppConfiguration);
    CppLinkActionBuilder linkActionBuilder = determineLinkerArguments(ruleContext, common, precompiledFiles, info, cppCompilationContext.getTransitiveCompilationPrerequisites(), fake, binary, linkStaticness, linkopts);
    linkActionBuilder.setUseTestOnlyFlags(ruleContext.isTestTarget());
    CcToolchainProvider ccToolchain = CppHelper.getToolchain(ruleContext);
    if (linkStaticness == LinkStaticness.DYNAMIC) {
        linkActionBuilder.setRuntimeInputs(ArtifactCategory.DYNAMIC_LIBRARY, ccToolchain.getDynamicRuntimeLinkMiddleman(), ccToolchain.getDynamicRuntimeLinkInputs());
    } else {
        linkActionBuilder.setRuntimeInputs(ArtifactCategory.STATIC_LIBRARY, ccToolchain.getStaticRuntimeLinkMiddleman(), ccToolchain.getStaticRuntimeLinkInputs());
        if (!ccToolchain.getStaticRuntimeLinkInputs().isEmpty()) {
            linkActionBuilder.addLinkopt("String_Node_Str");
        }
    }
    linkActionBuilder.setLinkType(linkType);
    linkActionBuilder.setLinkStaticness(linkStaticness);
    linkActionBuilder.setFake(fake);
    linkActionBuilder.setFeatureConfiguration(featureConfiguration);
    if (CppLinkAction.enableSymbolsCounts(cppConfiguration, fake, linkType)) {
        linkActionBuilder.setSymbolCountsOutput(ruleContext.getBinArtifact(CppLinkAction.symbolCountsFileName(binaryPath)));
    }
    if (isLinkShared(ruleContext)) {
        linkActionBuilder.setLibraryIdentifier(CcLinkingOutputs.libraryIdentifierOf(binary));
    }
    CppLinkAction.Context linkContext = new CppLinkAction.Context(linkActionBuilder);
    if (featureConfiguration.isEnabled(CppRuleClasses.THIN_LTO)) {
        linkActionBuilder.setLTOIndexing(true);
        CppLinkAction indexAction = linkActionBuilder.build();
        ruleContext.registerAction(indexAction);
        for (LTOBackendArtifacts ltoArtifacts : indexAction.getAllLTOBackendArtifacts()) {
            boolean usePic = CppHelper.usePic(ruleContext, !isLinkShared(ruleContext));
            ltoArtifacts.scheduleLTOBackendAction(ruleContext, featureConfiguration, usePic);
        }
        linkActionBuilder.setLTOIndexing(false);
    }
    CppLinkAction linkAction = linkActionBuilder.build();
    ruleContext.registerAction(linkAction);
    LibraryToLink outputLibrary = linkAction.getOutputLibrary();
    Iterable<Artifact> fakeLinkerInputs = fake ? linkAction.getInputs() : ImmutableList.<Artifact>of();
    Artifact executable = linkAction.getLinkOutput();
    CcLinkingOutputs.Builder linkingOutputsBuilder = new CcLinkingOutputs.Builder();
    if (isLinkShared(ruleContext)) {
        linkingOutputsBuilder.addDynamicLibrary(outputLibrary);
        linkingOutputsBuilder.addExecutionDynamicLibrary(outputLibrary);
    }
    for (Artifact library : precompiledFiles.getSharedLibraries()) {
        Artifact symlink = common.getDynamicLibrarySymlink(library, true);
        LibraryToLink symlinkLibrary = LinkerInputs.solibLibraryToLink(symlink, library, CcLinkingOutputs.libraryIdentifierOf(library));
        linkingOutputsBuilder.addDynamicLibrary(symlinkLibrary);
        linkingOutputsBuilder.addExecutionDynamicLibrary(symlinkLibrary);
    }
    CcLinkingOutputs linkingOutputs = linkingOutputsBuilder.build();
    NestedSet<Artifact> filesToBuild = NestedSetBuilder.create(Order.STABLE_ORDER, executable);
    Artifact strippedFile = ruleContext.getImplicitOutputArtifact(CppRuleClasses.CC_BINARY_STRIPPED);
    CppHelper.createStripAction(ruleContext, cppConfiguration, executable, strippedFile);
    DwoArtifactsCollector dwoArtifacts = collectTransitiveDwoArtifacts(ruleContext, ccCompilationOutputs, linkStaticness);
    Artifact dwpFile = ruleContext.getImplicitOutputArtifact(CppRuleClasses.CC_BINARY_DEBUG_PACKAGE);
    createDebugPackagerActions(ruleContext, cppConfiguration, dwpFile, dwoArtifacts);
    Artifact explicitDwpFile = dwpFile;
    if (!cppConfiguration.useFission()) {
        explicitDwpFile = null;
    } else {
        if (TargetUtils.isTestRule(ruleContext.getRule()) && linkStaticness != LinkStaticness.DYNAMIC && cppConfiguration.shouldBuildTestDwp()) {
            filesToBuild = NestedSetBuilder.fromNestedSet(filesToBuild).add(dwpFile).build();
        }
    }
    Runfiles runfiles = collectRunfiles(ruleContext, linkingOutputs, info, linkStaticness, filesToBuild, fakeLinkerInputs, fake, helper.getCompilationUnitSources());
    RunfilesSupport runfilesSupport = RunfilesSupport.withExecutable(ruleContext, runfiles, executable, ruleContext.getConfiguration().buildRunfiles());
    TransitiveLipoInfoProvider transitiveLipoInfo;
    if (cppConfiguration.isLipoContextCollector()) {
        transitiveLipoInfo = common.collectTransitiveLipoLabels(ccCompilationOutputs);
    } else {
        transitiveLipoInfo = TransitiveLipoInfoProvider.EMPTY;
    }
    RuleConfiguredTargetBuilder ruleBuilder = new RuleConfiguredTargetBuilder(ruleContext);
    addTransitiveInfoProviders(ruleContext, cppConfiguration, common, ruleBuilder, filesToBuild, ccCompilationOutputs, cppCompilationContext, linkingOutputs, dwoArtifacts, transitiveLipoInfo, fake);
    Map<Artifact, IncludeScannable> scannableMap = new LinkedHashMap<>();
    Map<PathFragment, Artifact> sourceFileMap = new LinkedHashMap<>();
    if (cppConfiguration.isLipoContextCollector()) {
        for (IncludeScannable scannable : transitiveLipoInfo.getTransitiveIncludeScannables()) {
            Artifact source = Iterables.getOnlyElement(scannable.getIncludeScannerSources());
            scannableMap.put(source, scannable);
            sourceFileMap.put(source.getExecPath(), source);
        }
    }
    if (Platform.isApplePlatform(cppConfiguration.getTargetCpu()) && TargetUtils.isTestRule(ruleContext.getRule())) {
        ruleBuilder.addNativeDeclaredProvider(new ExecutionInfoProvider(ImmutableMap.of("String_Node_Str", "String_Node_Str")));
    }
    return ruleBuilder.addProvider(RunfilesProvider.class, RunfilesProvider.simple(runfiles)).addProvider(CppDebugPackageProvider.class, new CppDebugPackageProvider(ruleContext.getLabel(), strippedFile, executable, explicitDwpFile)).setRunfilesSupport(runfilesSupport, executable).addProvider(LipoContextProvider.class, new LipoContextProvider(cppCompilationContext, ImmutableMap.copyOf(scannableMap), ImmutableMap.copyOf(sourceFileMap))).addProvider(CppLinkAction.Context.class, linkContext).addSkylarkTransitiveInfo(CcSkylarkApiProvider.NAME, new CcSkylarkApiProvider()).build();
}

Output:
     }
-    CcLibraryHelper helper = new CcLibraryHelper(ruleContext, semantics, featureConfiguration).fromCommon(common).addSources(common.getSources()).addDeps(ImmutableList.of(CppHelper.mallocForTarget(ruleContext))).setFake(fake).setLinkType(LinkTargetType.STATIC_LIBRARY).addPrecompiledFiles(precompiledFiles).enableInterfaceSharedObjects();
+    CcLibraryHelper helper = new CcLibraryHelper(ruleContext, semantics, featureConfiguration).fromCommon(common).addSources(common.getSources()).addDeps(ImmutableList.of(CppHelper.mallocForTarget(ruleContext))).setFake(fake).addPrecompiledFiles(precompiledFiles).enableInterfaceSharedObjects();
+    helper.setLinkType(ruleContext.isTestTarget() ? LinkTargetType.STATIC_LIBRARY : linkType);
     CcLibraryHelper.Info info = helper.build();