Input:
public Object getFieldValue(Object attributeValue, AbstractSession session, XMLRecord record) {
    Object fieldValue = attributeValue;
    if ((this.nullValue != null) && (this.nullValue.equals(fieldValue))) {
        return null;
    }
    if (hasConverter()) {
        if (getConverter() instanceof XMLConverter) {
            fieldValue = ((XMLConverter) getConverter()).convertObjectValueToDataValue(fieldValue, session, record.getMarshaller());
        } else {
            fieldValue = getConverter().convertObjectValueToDataValue(fieldValue, session);
        }
    }
    Class fieldClassification = getFieldClassification(getField());
    if ((fieldValue != null) && (fieldClassification != fieldValue.getClass())) {
        try {
            fieldValue = session.getPlatform(descriptor.getJavaClass()).convertObject(fieldValue, fieldClassification);
        } catch (ConversionException exception) {
            throw ConversionException.couldNotBeConverted(this, descriptor, exception);
        }
    }
    return fieldValue;
}

Output:
     Object fieldValue = attributeValue;
-    if ((this.nullValue != null) && (this.nullValue.equals(fieldValue))) {
+    if ((this.nullValue != null) && (this.nullValue.equals(fieldValue)) && !((XMLField) getField()).isRequired()) {
         return null;


Input:
static void updateAppWidget(Context context, AppWidgetManager appWidgetManager, int appWidgetId, Bundle options) {
    Tools.HangarLog("String_Node_Str");
    prefs = new PrefsGet(context.getSharedPreferences("String_Node_Str", Context.MODE_PRIVATE));
    SharedPreferences mPrefs = prefs.prefsGet();
    int rowLayout = R.layout.apps_widget_row;
    int itemLayout = R.layout.apps_widget_item;
    int itemHeight = ICON_MEDIUM_HEIGHT;
    int itemWidth = ICON_MEDIUM_WIDTH;
    int iconSize = Integer.parseInt(mPrefs.getString(Settings.ICON_SIZE_PREFERENCE, Integer.toString(Settings.ICON_SIZE_DEFAULT)));
    switch(iconSize) {
        case SMALL_ICONS:
            rowLayout = R.layout.apps_widget_row_small;
            itemHeight = ICON_SMALL_HEIGHT;
            itemWidth = ICON_SMALL_WIDTH;
            break;
        case LARGE_ICONS:
            rowLayout = R.layout.apps_widget_row_large;
            itemHeight = ICON_LARGE_HEIGHT;
            itemWidth = ICON_LARGE_WIDTH;
            break;
    }
    boolean appsNoByWidgetSize = mPrefs.getBoolean(Settings.APPS_BY_WIDGET_SIZE_PREFERENCE, Settings.APPS_BY_WIDGET_SIZE_DEFAULT);
    int appsNoH;
    int appsNoW;
    boolean autoHeight = true;
    Tools.HangarLog("String_Node_Str" + options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT));
    Tools.HangarLog("String_Node_Str" + options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT));
    Tools.HangarLog("String_Node_Str" + options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH));
    Tools.HangarLog("String_Node_Str" + options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH));
    appsNoH = (int) Math.floor((options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT) - ICON_ROW_BUFFER) / itemHeight);
    appsNoW = (int) Math.floor((options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH) - ICON_ROW_BUFFER) / itemWidth);
    Tools.HangarLog("String_Node_Str" + appsNoH + "String_Node_Str" + appsNoW);
    if (appsNoH == 0) {
        appsNoH = 1;
        autoHeight = false;
    }
    if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
        appsNoH = (int) Math.floor((options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT) - ICON_ROW_BUFFER) / itemHeight);
        float widgetHeight = (options.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT) - ICON_ROW_BUFFER);
        if (appsNoH == 0) {
            if (widgetHeight > 0) {
                Tools.HangarLog("String_Node_Str");
                rowLayout = R.layout.apps_widget_row_small;
                itemWidth = ICON_SMALL_WIDTH;
            }
            appsNoH = 1;
            autoHeight = false;
        }
        appsNoW = (int) Math.floor((options.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH) - ICON_ROW_BUFFER) / itemWidth);
        if (appsNoByWidgetSize && appsNoW > 0) {
            Tools.HangarLog("String_Node_Str" + appsNoW);
        } else {
            appsNoW = Integer.parseInt(mPrefs.getString(Settings.STATS_WIDGET_APPSNO_LS_PREFERENCE, Integer.toString(Settings.STATS_WIDGET_APPSNO_LS_DEFAULT)));
        }
        Tools.HangarLog("String_Node_Str");
    } else {
        if (appsNoByWidgetSize && appsNoW > 0) {
            Tools.HangarLog("String_Node_Str" + appsNoH);
        } else {
            appsNoW = Integer.parseInt(mPrefs.getString(Settings.STATS_WIDGET_APPSNO_PREFERENCE, Integer.toString(Settings.STATS_WIDGET_APPSNO_DEFAULT)));
        }
    }
    int getBackgroundColor = mPrefs.getInt(Settings.BACKGROUND_COLOR_PREFERENCE, Settings.BACKGROUND_COLOR_DEFAULT);
    int getColor = mPrefs.getInt(Settings.ICON_COLOR_PREFERENCE, Settings.ICON_COLOR_DEFAULT);
    RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.apps_widget);
    views.removeAllViews(R.id.viewCont);
    PackageManager pkgm = context.getPackageManager();
    if (db == null) {
        db = new TasksDataSource(context);
        db.open();
    }
    ArrayList<Tools.TaskInfo> appList = new ArrayList<Tools.TaskInfo>();
    int gridSize = (appsNoH * appsNoW);
    int numOfIcons = (appsNoH * appsNoW);
    int lookUpNum = numOfIcons + 3;
    if (autoHeight && !appsNoByWidgetSize) {
        numOfIcons = appsNoW;
        lookUpNum = appsNoW + 3;
    }
    List<TasksModel> tasks = db.getAllTasks((lookUpNum < MAX_DB_LOOKUPS) ? MAX_DB_LOOKUPS : lookUpNum);
    for (TasksModel taskM : tasks) {
        String taskPackage = taskM.getPackageName();
        if (isBlacklisted(taskPackage))
            continue;
        Tools.TaskInfo dbTask = new Tools.TaskInfo();
        dbTask.appName = taskM.getName();
        dbTask.packageName = taskPackage;
        dbTask.className = taskM.getClassName();
        dbTask.launches = taskM.getLaunches();
        dbTask.totalseconds = taskM.getSeconds();
        try {
            pkgm.getApplicationInfo(dbTask.packageName, 0);
        } catch (PackageManager.NameNotFoundException e) {
            db.deleteTask(taskM);
            continue;
        }
        try {
            Intent intent = pkgm.getLaunchIntentForPackage(taskPackage);
            if (intent == null)
                throw new PackageManager.NameNotFoundException();
        } catch (PackageManager.NameNotFoundException e) {
            db.deleteTask(taskM);
        }
        appList.add(dbTask);
    }
    String taskPackage = context.getPackageName();
    boolean isColorized = mPrefs.getBoolean(Settings.COLORIZE_PREFERENCE, Settings.COLORIZE_DEFAULT);
    boolean weightedRecents = mPrefs.getBoolean(Settings.WEIGHTED_RECENTS_PREFERENCE, Settings.WEIGHTED_RECENTS_DEFAULT);
    int weightPriority = Integer.parseInt(mPrefs.getString(Settings.WEIGHT_PRIORITY_PREFERENCE, Integer.toString(Settings.WEIGHT_PRIORITY_DEFAULT)));
    if (weightedRecents) {
        Tools.HangarLog("String_Node_Str" + weightPriority);
        appList = Tools.reorderTasks(appList, db, weightPriority);
    }
    RemoteViews row = new RemoteViews(context.getPackageName(), rowLayout);
    row.setInt(R.id.viewRow, "String_Node_Str", getBackgroundColor);
    if (autoHeight && !appsNoByWidgetSize) {
        appsNoW = (int) Math.ceil((double) appsNoW / appsNoH);
        Tools.HangarLog("String_Node_Str" + appsNoW);
    }
    int filledConts = 0;
    int filledRows = 1;
    Tools.HangarLog("String_Node_Str" + appsNoW + "String_Node_Str" + appList.size() + "String_Node_Str" + numOfIcons);
    for (int i = 0; i <= gridSize; i++) {
        RemoteViews item = new RemoteViews(context.getPackageName(), itemLayout);
        if (filledConts == appsNoW || i == (gridSize)) {
            Tools.HangarLog("String_Node_Str" + i + "String_Node_Str" + filledConts);
            views.addView(R.id.viewCont, row);
            if (filledRows < appsNoH && (filledConts < numOfIcons && appList.size() > i)) {
                row = new RemoteViews(context.getPackageName(), rowLayout);
                row.setInt(R.id.viewRow, "String_Node_Str", getBackgroundColor);
                filledConts = 0;
                filledRows++;
            } else {
                break;
            }
        }
        filledConts += 1;
        int resID = context.getResources().getIdentifier("String_Node_Str", "String_Node_Str", taskPackage);
        int contID = context.getResources().getIdentifier("String_Node_Str", "String_Node_Str", taskPackage);
        if (i >= numOfIcons || i >= appList.size()) {
            item.setViewVisibility(contID, View.INVISIBLE);
            row.addView(R.id.viewRow, item);
            continue;
        }
        Tools.HangarLog("String_Node_Str" + filledConts + "String_Node_Str" + appList.get(i).appName + "String_Node_Str");
        Drawable taskIcon, d;
        try {
            ApplicationInfo appInfo = pkgm.getApplicationInfo(appList.get(i).packageName, 0);
            taskIcon = appInfo.loadIcon(pkgm);
        } catch (Exception e) {
            Tools.HangarLog("String_Node_Str" + e);
            continue;
        }
        if (isColorized) {
            d = new BitmapDrawable(ColorHelper.getColoredBitmap(taskIcon, getColor));
        } else {
            d = taskIcon;
        }
        Bitmap bmpIcon = ((BitmapDrawable) d).getBitmap();
        item.setImageViewBitmap(resID, bmpIcon);
        Intent intent;
        PackageManager manager = context.getPackageManager();
        try {
            intent = manager.getLaunchIntentForPackage(appList.get(i).packageName);
            if (intent == null) {
                Tools.HangarLog("String_Node_Str" + appList.get(i).packageName + "String_Node_Str" + appList.get(i).className);
                filledConts--;
                item.setViewVisibility(contID, View.GONE);
                row.addView(R.id.viewRow, item);
                throw new PackageManager.NameNotFoundException();
            }
            intent.addCategory(Intent.CATEGORY_LAUNCHER);
            intent.setAction("String_Node_Str" + (i));
            PendingIntent activity = PendingIntent.getActivity(context, appWidgetId, intent, PendingIntent.FLAG_CANCEL_CURRENT);
            item.setOnClickPendingIntent(contID, activity);
        } catch (PackageManager.NameNotFoundException e) {
            numOfIcons++;
        }
        row.addView(R.id.viewRow, item);
    }
    appWidgetManager.updateAppWidget(appWidgetId, views);
}

Output:
         RemoteViews item = new RemoteViews(context.getPackageName(), itemLayout);
-        if (filledConts == appsNoW || i == (gridSize)) {
+        if (filledConts == appsNoW || (i == gridSize)) {
             Tools.HangarLog("String_Node_Str" + i + "String_Node_Str" + filledConts);


Input:
private void addMissingResSpecs() throws AndrolibException {
    int resId = mResId & 0xffff0000;
    for (int i = 0; i < mMissingResSpecs.length; i++) {
        if (!mMissingResSpecs[i]) {
            continue;
        }
        ResResSpec spec = new ResResSpec(new ResID(resId | i), String.format("String_Node_Str", i), mPkg, mTypeSpec);
        if (!mPkg.hasResSpec(new ResID(resId | i))) {
            mPkg.addResSpec(spec);
            mTypeSpec.addResSpec(spec);
            if (mType == null) {
                mType = mPkg.getOrCreateConfig(new ResConfigFlags());
            }
            ResValue value = new ResBoolValue(false, 0, null);
            ResResource res = new ResResource(mType, spec, value);
            mPkg.addResource(res);
            mType.addResource(res);
            spec.addResource(res);
        }
    }
}

Output:
         }
-        ResResSpec spec = new ResResSpec(new ResID(resId | i), String.format("String_Node_Str", i), mPkg, mTypeSpec);
+        ResResSpec spec = new ResResSpec(new ResID(resId | i), "String_Node_Str" + Integer.toHexString(i), mPkg, mTypeSpec);
         if (!mPkg.hasResSpec(new ResID(resId | i))) {


Input:
public Set<String> getReferencedNamespaces() {
    TreeSet<String> namespaces = new TreeSet<String>();
    Collection<WebMessage> messages = getMessages();
    for (WebMessage message : messages) {
        for (WebMessagePart part : message.getParts()) {
            namespaces.add(part.getElementQName().getNamespaceURI());
            if (part instanceof ImplicitSchemaElement) {
                ImplicitSchemaElement implicitElement = (ImplicitSchemaElement) part;
                QName typeQName = implicitElement.getTypeQName();
                if (typeQName != null) {
                    namespaces.add(typeQName.getNamespaceURI());
                }
                if (implicitElement instanceof ImplicitRootElement) {
                    for (ImplicitChildElement childElement : ((ImplicitRootElement) implicitElement).getChildElements()) {
                        namespaces.add(childElement.getTypeQName().getNamespaceURI());
                    }
                }
            }
        }
    }
    return namespaces;
}

Output:
 public Set<String> getReferencedNamespaces() {
-    TreeSet<String> namespaces = new TreeSet<String>();
+    HashSet<String> namespaces = new HashSet<String>();
     Collection<WebMessage> messages = getMessages();


Input:
public void setUp() throws Exception {
    super.setUp();
    requestControl = MockControl.createControl(DavServletRequest.class);
    request = (DavServletRequest) requestControl.getMock();
    responseControl = MockControl.createControl(DavServletResponse.class);
    response = (DavServletResponse) responseControl.getMock();
    responseControl.setDefaultMatcher(MockControl.ALWAYS_MATCHER);
    archivaConfigurationControl = MockControl.createControl(ArchivaConfiguration.class);
    archivaConfiguration = (ArchivaConfiguration) archivaConfigurationControl.getMock();
    config = new Configuration();
    archivaConfiguration.getConfiguration();
    archivaConfigurationControl.setReturnValue(config, 5, 20);
    archivaConfiguration.save(config);
    archivaConfigurationControl.setVoidCallable(1, 4);
    archivaConfigurationControl.replay();
    defaultManagedRepositoryAdmin.setArchivaConfiguration(archivaConfiguration);
    defaultManagedRepositoryAdmin.getRepositoryCommonValidator().setArchivaConfiguration(archivaConfiguration);
    if (defaultManagedRepositoryAdmin.getManagedRepository(RELEASES_REPO) == null) {
        defaultManagedRepositoryAdmin.addManagedRepository(createManagedRepository(RELEASES_REPO, new File("String_Node_Str" + RELEASES_REPO).getPath(), "String_Node_Str"), false, null);
    }
    if (defaultManagedRepositoryAdmin.getManagedRepository(INTERNAL_REPO) == null) {
        defaultManagedRepositoryAdmin.addManagedRepository(createManagedRepository(INTERNAL_REPO, new File("String_Node_Str" + INTERNAL_REPO).getPath(), "String_Node_Str"), false, null);
    }
    RepositoryGroup repoGroupConfig = new RepositoryGroup();
    repoGroupConfig.setId(LOCAL_REPO_GROUP);
    repoGroupConfig.addRepository(RELEASES_REPO);
    repoGroupConfig.addRepository(INTERNAL_REPO);
    defaultRepositoryGroupAdmin.setArchivaConfiguration(archivaConfiguration);
    if (defaultManagedRepositoryAdmin.getManagedRepository(LOCAL_REPO_GROUP) == null) {
        defaultRepositoryGroupAdmin.addRepositoryGroup(repoGroupConfig, null);
    }
    repoContentFactoryControl = MockClassControl.createControl(RepositoryContentFactory.class);
    repoFactory = (RepositoryContentFactory) repoContentFactoryControl.getMock();
    repoRequestControl = MockClassControl.createControl(RepositoryRequest.class);
    repoRequest = (RepositoryRequest) repoRequestControl.getMock();
    resourceFactory = new OverridingArchivaDavResourceFactory(applicationContext, plexusSisuBridge, archivaConfiguration);
    resourceFactory.setArchivaConfiguration(archivaConfiguration);
    resourceFactory.setRepositoryFactory(repoFactory);
    resourceFactory.setRepositoryRequest(repoRequest);
    resourceFactory.setConnectors(new OverridingRepositoryProxyConnectors());
}

Output:
     defaultManagedRepositoryAdmin.setArchivaConfiguration(archivaConfiguration);
-    defaultManagedRepositoryAdmin.getRepositoryCommonValidator().setArchivaConfiguration(archivaConfiguration);
+    ((DefaultRepositoryCommonValidator) defaultManagedRepositoryAdmin.getRepositoryCommonValidator()).setArchivaConfiguration(archivaConfiguration);
     if (defaultManagedRepositoryAdmin.getManagedRepository(RELEASES_REPO) == null) {


Input:
private static String[] getArgs(String[] codeLines) {
    List<String> args = new ArrayList<String>();
    for (String codeLine : codeLines) {
        args.add("String_Node_Str");
        args.add(codeLine);
    }
    return args.toArray(new String[0]);
}

Output:
         args.add("String_Node_Str");
-        args.add(codeLine);
+        args.add("String_Node_Str" + codeLine + "String_Node_Str");
     }


Input:
public void visitCode(MethodInfo methodInfo, Code code) {
    visitConstantUtf8(code.getNameIndex());
    InstructionList il = new InstructionList(code.getCode());
    visitInstructionList(il);
    il.dispose();
    for (CodeException ce : code.getExceptionTable()) {
        visitConstantClass(ce.getCatchType());
    }
    new DescendingClassTraverser(this).visitAttributes(methodInfo, code.getAttributes());
}

Output:
     for (CodeException ce : code.getExceptionTable()) {
-        visitConstantClass(ce.getCatchType());
+        if (ce.getCatchType() != 0) {
+            visitConstantClass(ce.getCatchType());
+        }
     }


Input:
public void testContentCreated() throws Exception {
    Product product = TestUtil.createProduct(owner);
    addContentTo(product);
    String json = getJsonForProduct(product);
    Reader reader = new StringReader(json);
    Product created = importer.createObject(mapper, reader);
    Content c = created.getProductContent().iterator().next().getContent();
    Set<Product> storeThese = new HashSet<Product>();
    storeThese.add(created);
    importer.store(storeThese);
    verify(contentCuratorMock).createOrUpdate(c);
    assertEquals(new Long(1000), c.getMetadataExpire());
}

Output:
     storeThese.add(created);
-    importer.store(storeThese);
+    importer.store(storeThese, owner);
     verify(contentCuratorMock).createOrUpdate(c);


Input:
public boolean remove(Object o) {
    Entry entry = findEntry((E) o);
    if (entry == null) {
        return false;
    } else {
        if (entry == _head) {
            _head = entry._next;
        }
        if (entry == _tail) {
            _tail = entry._previous;
        }
        if (entry._previous != null) {
            entry._previous._next = entry._next;
        }
        if (entry._next != null) {
            entry._next._previous = entry._previous;
        }
        _size--;
        return true;
    }
}

Output:
     } else {
-        if (entry == _head) {
-            _head = entry._next;
-        }
-        if (entry == _tail) {
-            _tail = entry._previous;
-        }
-        if (entry._previous != null) {
-            entry._previous._next = entry._next;
-        }
-        if (entry._next != null) {
-            entry._next._previous = entry._previous;
-        }
-        _size--;
-        return true;
+        _head = _next;
     }


Input:
public void testExtendingInterface1() {
    this.runNegativeTest(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");
}

Output:
 public void testExtendingInterface1() {
-    this.runNegativeTest(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");
+    runNegativeTest(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");
 }


Input:
public void checkTypes(MarkerList markers, IContext context) {
    super.checkTypes(markers, context);
    for (int i = 0; i < this.parameterCount; i++) {
        this.parameters[i].checkTypes(markers, context);
    }
    if (this.value != null) {
        this.value.checkTypes(markers, context);
    } else if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
        this.modifiers |= Modifiers.ABSTRACT;
    }
    if ((this.modifiers & Modifiers.STATIC) == 0) {
        this.checkOverride(markers, context);
    }
}

Output:
     if (this.value != null) {
-        this.value.checkTypes(markers, context);
+        this.value.checkTypes(markers, this);
     } else if ((this.modifiers & Modifiers.ABSTRACT) == 0) {


Input:
public void execute() throws BuildException {
    final boolean fail = nestedConditionPresent() ? testNestedCondition() : (testIfCondition() && testUnlessCondition());
    if (!fail) {
        return;
    }
    if (id == null) {
        throw new BuildException("String_Node_Str");
    }
    final ArrayList<String> prop = new ArrayList<String>();
    for (final Param p : params) {
        if (!p.isValid()) {
            throw new BuildException("String_Node_Str");
        }
        final String ifProperty = p.getIf();
        final String unlessProperty = p.getUnless();
        if ((ifProperty == null || getProject().getProperties().containsKey(ifProperty)) && (unlessProperty == null || !getProject().getProperties().containsKey(unlessProperty))) {
            final int idx = Integer.parseInt(p.getName()) - 1;
            prop.set(idx, p.getValue());
        }
    }
    final MessageBean msgBean = MessageUtils.getInstance().getMessage(id, prop.toArray(new String[prop.size()]));
    final DITAOTLogger logger = new DITAOTAntLogger(getProject());
    if (msgBean != null) {
        final String type = msgBean.getType();
        if (FATAL.equals(type)) {
            setMessage(msgBean.toString());
            try {
                super.execute();
            } catch (final BuildException ex) {
                throw new BuildException(msgBean.toString(), new DITAOTException(msgBean, ex, msgBean.toString()));
            }
        } else if (ERROR.equals(type)) {
            logger.logError(msgBean.toString());
        } else if (WARN.equals(type)) {
            logger.logWarn(msgBean.toString());
        } else if (INFO.equals(type)) {
            logger.logInfo(msgBean.toString());
        } else if (DEBUG.equals(type)) {
            logger.logDebug(msgBean.toString());
        }
    }
}

Output:
     }
-    final ArrayList<String> prop = new ArrayList<String>();
-    for (final Param p : params) {
-        if (!p.isValid()) {
-            throw new BuildException("String_Node_Str");
-        }
-        final String ifProperty = p.getIf();
-        final String unlessProperty = p.getUnless();
-        if ((ifProperty == null || getProject().getProperties().containsKey(ifProperty)) && (unlessProperty == null || !getProject().getProperties().containsKey(unlessProperty))) {
-            final int idx = Integer.parseInt(p.getName()) - 1;
-            prop.set(idx, p.getValue());
-        }
-    }
-    final MessageBean msgBean = MessageUtils.getInstance().getMessage(id, prop.toArray(new String[prop.size()]));
+    final MessageBean msgBean = MessageUtils.getInstance().getMessage(id, readParamValues());
     final DITAOTLogger logger = new DITAOTAntLogger(getProject());


Input:
public void testReopen() throws Exception {
    expect(mockStore.openHDFSConnection()).andReturn(mockFs);
    expect(mockStore.getId()).andReturn(new URI("String_Node_Str"));
    mockFs.close();
    mockStore.releaseHDFSConnection(mockFs);
    replay(mockStore, mockFs);
    HDFSBlobStoreConnection connection = createTestConnection();
    assertFalse(connection.isClosed());
    connection.close();
}

Output:
 public void testReopen() throws Exception {
-    expect(mockStore.openHDFSConnection()).andReturn(mockFs);
-    expect(mockStore.getId()).andReturn(new URI("String_Node_Str"));
+    expect(mockStore.getFilesystem()).andReturn(mockFs);
+    expect(mockStore.getId()).andReturn(mockId);
     mockFs.close();


Input:
public void setInt(Property property, int value) {
    convertValueAndSet(property, new Integer(value));
}

Output:
 public void setInt(Property property, int value) {
-    convertValueAndSet(property, new Integer(value));
+    convertValueAndSet(property, value);
 }


Input:
public void rhoDRDownTest2() throws ParseException {
    ReasonerComponent reasoner = TestOntologies.getTestOntology(TestOntology.EPC_OE);
    baseURI = reasoner.getBaseURI();
    RhoDRDown op = new RhoDRDown(reasoner);
    Description concept = KBParser.parseConcept("String_Node_Str");
    Set<Description> results = op.refine(concept, 6);
    for (Description result : results) {
        System.out.println(result);
    }
    int desiredResultSize = 141;
    if (results.size() != desiredResultSize) {
        System.out.println(results.size() + "String_Node_Str" + desiredResultSize + "String_Node_Str");
    }
    assertTrue(results.size() == desiredResultSize);
}

Output:
     Description concept = KBParser.parseConcept("String_Node_Str");
-    Set<Description> results = op.refine(concept, 6);
+    Set<Description> results = op.refine(concept, 10);
     for (Description result : results) {


Input:
protected JFreeChart createGraph() {
    final CategoryDataset dataset = createDataSet(obj).build();
    final JFreeChart chart = ChartFactory.createLineChart(null, null, "String_Node_Str", dataset, PlotOrientation.VERTICAL, true, true, false);
    final LegendTitle legend = chart.getLegend();
    legend.setPosition(RectangleEdge.RIGHT);
    chart.setBackgroundPaint(Color.white);
    final CategoryPlot plot = chart.getCategoryPlot();
    plot.setBackgroundPaint(Color.WHITE);
    plot.setOutlinePaint(null);
    plot.setRangeGridlinesVisible(true);
    plot.setRangeGridlinePaint(Color.black);
    CategoryAxis domainAxis = new ShiftedCategoryAxis(null);
    plot.setDomainAxis(domainAxis);
    domainAxis.setCategoryLabelPositions(CategoryLabelPositions.UP_90);
    domainAxis.setLowerMargin(0.0);
    domainAxis.setUpperMargin(0.0);
    domainAxis.setCategoryMargin(0.0);
    final NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
    rangeAxis.setUpperBound(100);
    rangeAxis.setLowerBound(0);
    final LineAndShapeRenderer renderer = (LineAndShapeRenderer) plot.getRenderer();
    renderer.setBaseStroke(new BasicStroke(4.0f));
    ColorPalette.apply(renderer);
    plot.setInsets(new RectangleInsets(5.0, 0, 0, 5.0));
    return chart;
}

Output:
     rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
-    rangeAxis.setUpperBound(100);
+    rangeAxis.setUpperBound(maxLine);
     rangeAxis.setLowerBound(0);


Input:
public boolean equals(Object object) {
    if (null == object) {
        return false;
    } else if (this == object) {
        return true;
    }
    try {
        XPathFragment xPathFragment = (XPathFragment) object;
        if (nameIsText && xPathFragment.nameIsText) {
            return true;
        }
        if (nameIsText != xPathFragment.nameIsText) {
            return false;
        }
        if ((null == localName && null != xPathFragment.localName) || (null != localName && null == xPathFragment.localName)) {
            return false;
        }
        if (null != localName && !localName.equals(xPathFragment.localName)) {
            return false;
        }
        if (namespaceAware && xPathFragment.isNamespaceAware()) {
            if ((null == namespaceURI && null != xPathFragment.namespaceURI) || (null != namespaceURI && null == xPathFragment.namespaceURI)) {
                return false;
            }
            if (null != namespaceURI && !namespaceURI.equals(xPathFragment.namespaceURI)) {
                return false;
            }
        }
        if (indexValue != xPathFragment.indexValue) {
            return false;
        }
        if (null == predicate && null != xPathFragment.predicate) {
            return false;
        }
        if (null != predicate && !predicate.equals(xPathFragment.predicate)) {
            return false;
        }
    } catch (ClassCastException e) {
        return false;
    }
    return true;
}

Output:
         }
-        if (null == predicate && null != xPathFragment.predicate) {
-            return false;
-        }
-        if (null != predicate && !predicate.equals(xPathFragment.predicate)) {
-            return false;
+        if (!ignorePredicate) {
+            if (null == predicate && null != xPathFragment.predicate) {
+                return false;
+            }
+            if (null != predicate && !predicate.equals(xPathFragment.predicate)) {
+                return false;
+            }
         }


Input:
public void declareToMaster() throws NotEnoughAvailableSlavesException, IOException, ONCRPCException, InterruptedException, BabuDBException {
    if (dispatcher.isMaster)
        return;
    DispatcherState state = stop();
    if (state.requestQueue != null)
        for (StageRequest rq : state.requestQueue) rq.free();
    state.requestQueue = null;
    this.dispatcher = new SlaveRequestDispatcher(this.dispatcher);
    SlaveRequestDispatcher lDisp = (SlaveRequestDispatcher) dispatcher;
    List<InetSocketAddress> slaves = new LinkedList<InetSocketAddress>(dispatcher.configuration.getParticipants());
    slaves.remove(dispatcher.configuration.getInetSocketAddress());
    if (slaves.size() > 0) {
        Map<InetSocketAddress, LSN> states = stopAll(slaves);
        if (states.size() < dispatcher.configuration.getSyncN())
            throw new NotEnoughAvailableSlavesException("String_Node_Str");
        if (states.size() > 0) {
            List<LSN> values = new LinkedList<LSN>(states.values());
            Collections.sort(values);
            LSN latest = values.get(values.size() - 1);
            if (latest.compareTo(state.latest) > 0) {
                for (Entry<InetSocketAddress, LSN> entry : states.entrySet()) {
                    if (entry.getValue().equals(latest)) {
                        lDisp.coin(entry.getKey());
                        StateClient c = new StateClient(dispatcher.rpcClient, entry.getKey());
                        RPCResponse<Object> rp = null;
                        try {
                            rp = c.toMaster();
                            rp.get();
                        } finally {
                            if (rp != null)
                                rp.freeBuffers();
                        }
                        lDisp.synchronize(state.latest, latest);
                        RPCResponse<LSN> rps = null;
                        try {
                            rps = c.remoteStop();
                            rps.get();
                        } finally {
                            if (rps != null)
                                rps.freeBuffers();
                        }
                        break;
                    }
                }
            }
        }
        allToSlaves(slaves, dispatcher.configuration.getSyncN(), dispatcher.configuration.getInetSocketAddress());
    }
    this.dispatcher = new MasterRequestDispatcher(dispatcher, dispatcher.configuration.getInetSocketAddress());
    restart(state);
}

Output:
         return;
-    DispatcherState state = stop();
+    DispatcherState state = null;
+    if (isRunning()) {
+        state = stop();
+    } else {
+        state = dispatcher.getState();
+    }
     if (state.requestQueue != null)


Input:
private void checkForTimers() {
    long now = TimeSync.getLocalSystemTime();
    if (now >= lastCheck + TIMEOUT_GRANULARITY) {
        synchronized (connections) {
            Iterator<ServerConnection> conIter = connections.values().iterator();
            while (conIter.hasNext()) {
                final ServerConnection con = conIter.next();
                if (con.getLastUsed() < (TimeSync.getLocalSystemTime() - connectionTimeout)) {
                    if (Logging.isDebug()) {
                        Logging.logMessage(Logging.LEVEL_DEBUG, this, "String_Node_Str");
                    }
                    try {
                        conIter.remove();
                        closeConnection(con.getChannel().keyFor(selector), null);
                    } catch (Exception ex) {
                    }
                } else {
                    List<ONCRPCRequest> cancelRq = new LinkedList();
                    synchronized (con) {
                        Iterator<ONCRPCRequest> iter = con.getRequests().values().iterator();
                        while (iter.hasNext()) {
                            final ONCRPCRequest rq = iter.next();
                            if (rq.getTimeQueued() + requestTimeout < TimeSync.getLocalSystemTime()) {
                                cancelRq.add(rq);
                                iter.remove();
                            }
                        }
                        iter = con.getSendQueue().iterator();
                        while (iter.hasNext()) {
                            final ONCRPCRequest rq = iter.next();
                            if (rq.getTimeQueued() + requestTimeout < TimeSync.getLocalSystemTime()) {
                                cancelRq.add(rq);
                                iter.remove();
                            } else {
                                break;
                            }
                        }
                    }
                    for (ONCRPCRequest rq : cancelRq) {
                        rq.getListener().requestFailed(rq, new IOException("String_Node_Str"));
                    }
                }
            }
            lastCheck = now;
        }
    }
}

Output:
 private void checkForTimers() {
-    long now = TimeSync.getLocalSystemTime();
+    long now = System.currentTimeMillis();
     if (now >= lastCheck + TIMEOUT_GRANULARITY) {


Input:
public DirectBuffer writeFloat(int byteIndex, float value) {
    view.setFloat32(byteIndex, value);
    return this;
}

Output:
 public DirectBuffer writeFloat(int byteIndex, float value) {
-    view.setFloat32(byteIndex, value);
+    view.setFloat32(byteIndex, value, littleEndian);
     return this;


Input:
private void writeOrbitStateVectors(final PrintStream p) {
    final OrbitStateVector[] osvList = AbstractMetadata.getOrbitStateVectors(absRoot);
    if (osvList != null && osvList.length > 0) {
        double seconds = (osvList[0].time_mjd - dateDay.getMJD()) * daysToSeconds;
        double seconds2 = (osvList[1].time_mjd - dateDay.getMJD()) * daysToSeconds;
        double interval = seconds2 - seconds;
        p.println(GammaConstants.HEADER_KEY_NUM_STATE_VECTORS + sep + osvList.length);
        p.println(GammaConstants.HEADER_KEY_TIME_FIRST_STATE_VECTORS + sep + seconds + sep + "String_Node_Str");
        p.println(GammaConstants.HEADER_KEY_STATE_VECTOR_INTERVAL + sep + interval + sep + "String_Node_Str");
        int num = 1;
        for (OrbitStateVector osv : osvList) {
            p.println(GammaConstants.HEADER_KEY_STATE_VECTOR_POSITION + '_' + num + sep + osv.x_pos + sep + osv.y_pos + sep + osv.z_pos + sep + "String_Node_Str");
            p.println(GammaConstants.HEADER_KEY_STATE_VECTOR_VELOCITY + '_' + num + sep + osv.x_vel + sep + osv.y_vel + sep + osv.z_vel + sep + "String_Node_Str");
            ++num;
        }
    }
}

Output:
         p.println(GammaConstants.HEADER_KEY_NUM_STATE_VECTORS + sep + osvList.length);
-        p.println(GammaConstants.HEADER_KEY_TIME_FIRST_STATE_VECTORS + sep + seconds + sep + "String_Node_Str");
-        p.println(GammaConstants.HEADER_KEY_STATE_VECTOR_INTERVAL + sep + interval + sep + "String_Node_Str");
+        p.println(GammaConstants.HEADER_KEY_TIME_FIRST_STATE_VECTORS + sep + seconds + tab + "String_Node_Str");
+        p.println(GammaConstants.HEADER_KEY_STATE_VECTOR_INTERVAL + sep + interval + tab + "String_Node_Str");
         int num = 1;


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle extras = getIntent().getExtras();
    String title = extras.getString(GraphView.TITLE);
    if (title == null) {
        requestWindowFeature(Window.FEATURE_NO_TITLE);
    } else if (title.length() > 0) {
        setTitle(title);
    }
    String html = extras.getString(GraphView.HTML);
    GraphView view = new GraphView(this, title, true);
    try {
        WebView view = (WebView) mView.getView(html);
        setContentView(view);
    } catch (InvalidStateException e) {
        e.printStackTrace();
        finish();
    }
}

Output:
     String html = extras.getString(GraphView.HTML);
-    GraphView view = new GraphView(this, title, true);
+    GraphView graphView = new GraphView(this, title, true);
     try {


Input:
public void write(ItemRecord[] records, IProgressMonitor monitor) {
    if (monitor == null) {
        monitor = new NullProgressMonitor();
    }
    try {
        for (ItemRecord record : records) {
            if (monitor.isCanceled()) {
                break;
            }
            Map<IPath, IPath> toImportMap = mapping(record);
            monitor.subTask("String_Node_Str" + record.getName());
            if (record.isValid()) {
                log.info("String_Node_Str" + record.getFile().getAbsolutePath());
                if (record.getElement() != null) {
                    ModelElement element = record.getElement();
                    Property property = record.getProperty();
                    EResourceConstant typedConstant = EResourceConstant.getTypedConstant(element);
                    if (typedConstant != null) {
                        IPath folderPath = new Path(typedConstant.getPath());
                        ItemState state = property.getItem().getState();
                        if (state != null && state.getPath() != null) {
                            folderPath.append(state.getPath());
                        }
                        IFolder folder = ResourceManager.getRootProject().getFolder(folderPath);
                        AElementPersistance creator = ElementWriterFactory.getInstance().create(element);
                        if (creator != null) {
                            creator.create(element, folder);
                        } else {
                            log.error("String_Node_Str" + element.getName());
                        }
                    }
                }
            } else {
                for (String error : record.getErrors()) {
                    log.error(error);
                }
            }
            monitor.worked(1);
        }
        if (commonTasks != null) {
            MigrationTaskManager.doMigrationTask(commonTasks, monitor);
        }
        finish(records, monitor);
    } catch (Exception e) {
        log.error(e, e);
    }
}

Output:
                 log.info("String_Node_Str" + record.getFile().getAbsolutePath());
-                if (record.getElement() != null) {
-                    ModelElement element = record.getElement();
+                ModelElement element = record.getElement();
+                if (element != null && element instanceof Connection) {
                     Property property = record.getProperty();


Input:
public void onChildEvent(MonitorStatusEvent statusEvent) {
    String id = statusEvent.getId();
    LifeCycleState status1 = statusEvent.getStatus();
    if (status1 == ClusterStatus.Active || status1 == GroupStatus.Active) {
        onChildActivatedEvent(id);
    } else if (status1 == ClusterStatus.Inactive || status1 == GroupStatus.Inactive) {
        onChildInactiveEvent(id);
    } else if (status1 == ClusterStatus.Created || status1 == GroupStatus.Created) {
        if (this.aliasToInactiveMonitorsMap.containsKey(id)) {
            this.aliasToInactiveMonitorsMap.remove(id);
        }
        if (this.status == GroupStatus.Terminating) {
            StatusChecker.getInstance().onChildStatusChange(id, this.id, this.appId);
        } else {
            onChildTerminatedEvent(id);
        }
    } else if (status1 == ClusterStatus.Terminating || status1 == GroupStatus.Terminating) {
        this.markMonitorAsInactive(id);
    } else if (status1 == ClusterStatus.Terminated || status1 == GroupStatus.Terminated) {
        if (this.aliasToInactiveMonitorsMap.containsKey(id)) {
            this.aliasToInactiveMonitorsMap.remove(id);
        } else {
            log.warn("String_Node_Str" + id + "String_Node_Str");
        }
        if (this.status == GroupStatus.Terminating || this.status == GroupStatus.Terminated) {
            StatusChecker.getInstance().onChildStatusChange(id, this.id, this.appId);
            log.info("String_Node_Str" + id);
        }
    }
}

Output:
     } else if (status1 == ClusterStatus.Created || status1 == GroupStatus.Created) {
-        if (this.aliasToInactiveMonitorsMap.containsKey(id)) {
-            this.aliasToInactiveMonitorsMap.remove(id);
+        if (this.inactiveMonitorsList.contains(id)) {
+            this.inactiveMonitorsList.remove(id);
         }


Input:
private void replicate(AtomicBoolean hasLeadership) {
    long sequence = getLastUpdated();
    if (sequence == ChannelUtils.NOT_FOUND) {
        return;
    }
    logger.info("String_Node_Str" + channel.getUrl() + "String_Node_Str" + sequence);
    iterator = sequenceIteratorFactory.create(sequence, channel);
    long lastReplicated = 0;
    try {
        while (iterator.hasNext() && hasLeadership.get()) {
            Optional<Content> optionalContent = iterator.next();
            if (optionalContent.isPresent()) {
                Content content = optionalContent.get();
                ContentKey key = content.getContentKey().get();
                if (key.getMillis() < lastReplicated) {
                    key = new ContentKey(new DateTime(lastReplicated), key.getHash());
                    content.setContentKey(key);
                }
                channelService.insert(channel.getName(), content);
                lastReplicated = key.getMillis();
            } else {
                logger.warn("String_Node_Str" + channel.getUrl());
            }
        }
    } finally {
        logger.info("String_Node_Str" + channel.getUrl() + "String_Node_Str");
        closeIterator();
    }
}

Output:
                 Content content = optionalContent.get();
-                ContentKey key = content.getContentKey().get();
-                if (key.getMillis() < lastReplicated) {
-                    key = new ContentKey(new DateTime(lastReplicated), key.getHash());
-                    content.setContentKey(key);
+                ContentKey nextKey = content.getContentKey().get();
+                ContentKey lastCompletedKey = lastContentKey.get(channel.getName(), nextKey, V1_REPLICATE_LAST_COMPLETED);
+                if (nextKey.compareTo(lastCompletedKey) < 0) {
+                    nextKey = new ContentKey(lastCompletedKey.getTime(), nextKey.getHash());
+                    content.setContentKey(nextKey);
                 }


Input:
public static String getFullAtomSequence(List<Group> groups, Map<Integer, Integer> positionIndex) {
    StringBuffer sequence = new StringBuffer();
    int seqIndex = 0;
    for (int i = 0; i < groups.size(); i++) {
        Group g = groups.get(i);
        if (g instanceof AminoAcid) {
            AminoAcid a = (AminoAcid) g;
            char oneLetter = a.getAminoType();
            if (oneLetter == '?')
                oneLetter = 'X';
            positionIndex.put(seqIndex, i);
            sequence.append(oneLetter);
            seqIndex++;
        } else {
            if (g.isWater())
                continue;
            if (g.size() == 1) {
                Atom a = g.getAtom(0);
                if (a == null)
                    continue;
                if (a.getElement().isMetal())
                    continue;
            }
            ChemComp cc = g.getChemComp();
            if (cc == null) {
                logger.debug("String_Node_Str", g.toString());
                continue;
            }
            if (ResidueType.lPeptideLinking.equals(cc.getResidueType()) || PolymerType.PROTEIN_ONLY.contains(cc.getPolymerType()) || PolymerType.POLYNUCLEOTIDE_ONLY.contains(cc.getPolymerType())) {
                String c = cc.getOne_letter_code();
                if (c.equals("String_Node_Str"))
                    c = "String_Node_Str";
                if (c.length() > 1) {
                    logger.info("String_Node_Str", g.toString(), c);
                }
                for (int cIdx = 0; cIdx < c.length(); cIdx++) {
                    positionIndex.put(seqIndex, i);
                    sequence.append(c.charAt(cIdx));
                    seqIndex++;
                }
            } else {
                logger.debug("String_Node_Str", g.toString());
                continue;
            }
        }
    }
    return sequence.toString();
}

Output:
                 String c = cc.getOne_letter_code();
-                if (c.equals("String_Node_Str"))
-                    c = "String_Node_Str";
+                if (c.equals("String_Node_Str")) {
+                    if (isNucleotideChain && PolymerType.POLYNUCLEOTIDE_ONLY.contains(cc.getPolymerType())) {
+                        c = "String_Node_Str";
+                    } else {
+                        c = "String_Node_Str";
+                    }
+                }
                 if (c.length() > 1) {


Input:
public void inotTest7() {
    System.out.println("String_Node_Str");
    final short[] content = new short[32768 - 5];
    content[0] = 0;
    content[1] = 2;
    content[2] = 4;
    content[3] = 6;
    content[4] = 8;
    for (int i = 10; i <= 32767; ++i) content[i - 10 + 5] = (short) i;
    MappeableContainer c = makeContainer(content);
    c = c.inot(5, 31000);
    if (c.getCardinality() <= MappeableArrayContainer.DEFAULT_MAX_SIZE)
        assertTrue(c instanceof MappeableArrayContainer);
    else
        assertTrue(c instanceof MappeableBitmapContainer);
    assertEquals(1773, c.getCardinality());
    c = c.inot(5, 31000);
    if (c.getCardinality() <= MappeableArrayContainer.DEFAULT_MAX_SIZE)
        assertTrue(c instanceof MappeableArrayContainer);
    else
        assertTrue(c instanceof MappeableBitmapContainer);
    assertTrue(checkContent(c, content));
}

Output:
     MappeableContainer c = makeContainer(content);
-    c = c.inot(5, 31000);
+    c = c.inot(5, 31001);
     if (c.getCardinality() <= MappeableArrayContainer.DEFAULT_MAX_SIZE)


Input:
public static ResourceManagementService getResources() {
    if (resourceService == null) {
        ServiceReference serviceReference = bundleContext.getServiceReference(ResourceManagementService.class.getName());
        if (serviceReference == null)
            return null;
        resourceService = (ResourceManagementService) bundleContext.getService(serviceReference);
    }
    return resourceService;
}

Output:
 public static ResourceManagementService getResources() {
-    if (resourceService == null) {
-        ServiceReference serviceReference = bundleContext.getServiceReference(ResourceManagementService.class.getName());
-        if (serviceReference == null)
-            return null;
-        resourceService = (ResourceManagementService) bundleContext.getService(serviceReference);
-    }
+    if (resourceService == null)
+        resourceService = ResourceManagementServiceUtils.getService(bundleContext);
     return resourceService;


Input:
protected void createContents(Composite parent) {
    Browser browser = new Browser(parent, SWT.NONE);
}

Output:
 protected void createContents(Composite parent) {
-    Browser browser = new Browser(parent, SWT.NONE);
+    GridLayout gridLayout = new GridLayout(1, false);
+    parent.setLayout(gridLayout);
+    browser = new Browser(parent, SWT.NONE);
+    browser.setLayoutData(new GridData(GridData.FILL_BOTH));
 }


Input:
private int decodeBlackCodeWord() {
    int current, entry, bits, isT, twoBits, code = -1;
    int runLength = 0;
    boolean isWhite = false;
    while (!isWhite) {
        current = nextLesserThan8Bits(4);
        entry = initBlack[current];
        isT = entry & 0x0001;
        bits = (entry >>> 1) & 0x000f;
        code = (entry >>> 5) & 0x07ff;
        if (code == 100) {
            current = nextNBits(9);
            entry = black[current];
            isT = entry & 0x0001;
            bits = (entry >>> 1) & 0x000f;
            code = (entry >>> 5) & 0x07ff;
            if (bits == 12) {
                updatePointer(5);
                current = nextLesserThan8Bits(4);
                entry = additionalMakeup[current];
                bits = (entry >>> 1) & 0x07;
                code = (entry >>> 4) & 0x0fff;
                runLength += code;
                updatePointer(4 - bits);
            } else if (bits == 15) {
                throw new Error(JaiI18N.getString("String_Node_Str"));
            } else {
                runLength += code;
                updatePointer(9 - bits);
                if (isT == 0) {
                    isWhite = true;
                }
            }
        } else if (code == 200) {
            current = nextLesserThan8Bits(2);
            entry = twoBitBlack[current];
            code = (entry >>> 5) & 0x07ff;
            runLength += code;
            bits = (entry >>> 1) & 0x0f;
            updatePointer(2 - bits);
            isWhite = true;
        } else {
            runLength += code;
            updatePointer(4 - bits);
            isWhite = true;
        }
    }
    return runLength;
}

Output:
             } else if (bits == 15) {
-                throw new Error(JaiI18N.getString("String_Node_Str"));
+                throw new RuntimeException(JaiI18N.getString("String_Node_Str"));
             } else {


Input:
public boolean stripConstIfReplaced() {
    return removeConstness;
}

Output:
 public boolean stripConstIfReplaced() {
-    return removeConstness;
+    return delegate.stripConstIfReplaced();
 }


Input:
private void initConstruction() {
    stacks = createConstructionStacks();
    placeAdditionalMapObjects(grid, pos, true);
    this.state = EBuildingState.IN_FLATTERNING;
    RescheduleTimer.add(this, IS_FLATTENED_RECHECK_PERIOD);
    requestDiggers();
}

Output:
     placeAdditionalMapObjects(grid, pos, true);
-    this.state = EBuildingState.IN_FLATTERNING;
-    RescheduleTimer.add(this, IS_FLATTENED_RECHECK_PERIOD);
-    requestDiggers();
+    this.state = EBuildingState.CREATED;
+    RescheduleTimer.add(this, IS_UNSTOPPED_RECHECK_PERIOD);
 }


Input:
public void testFailOnSecondErrorXMLStreamWriter() throws Exception {
    CustomErrorValidationEventHandler eventHandler = new CustomErrorValidationEventHandler();
    marshaller.setEventHandler(eventHandler);
    try {
        if (null == XML_OUTPUT_FACTORY) {
            return;
        }
        XMLStreamWriter xmlStreamWriter = XML_OUTPUT_FACTORY.createXMLStreamWriter(new ByteArrayOutputStream());
        marshaller.marshal(employee, xmlStreamWriter);
    } catch (MarshalException ex) {
        assertEquals(2, eventHandler.getErrorCount());
        return;
    } catch (XMLStreamException e) {
        return;
    } catch (Exception e) {
        throw e;
    }
    fail("String_Node_Str");
}

Output:
         marshaller.marshal(employee, xmlStreamWriter);
-    } catch (MarshalException ex) {
+    } catch (JAXBException ex) {
         assertEquals(2, eventHandler.getErrorCount());


Input:
public static List<String> getTableCatalogAndSchema(DatabaseConnection dbConnection, String tableName) {
    String catalogName = null;
    String schemaName = null;
    List<String> catalogAndSchema = new ArrayList<String>();
    List<Catalog> catalogs = ConnectionHelper.getCatalogs(dbConnection);
    if (catalogs.isEmpty()) {
        List<Schema> schemas = ConnectionHelper.getSchema(dbConnection);
        if (schemas.isEmpty()) {
        } else {
            for (Schema s : schemas) {
                EList<ModelElement> ownedElement = null;
                if (s != null) {
                    ownedElement = s.getOwnedElement();
                    if (ownedElement != null) {
                        for (ModelElement m : ownedElement) {
                            if (m instanceof org.talend.core.model.metadata.builder.connection.MetadataTable) {
                                String label = ((org.talend.core.model.metadata.builder.connection.MetadataTable) m).getLabel();
                                if (label.equals(tableName)) {
                                    schemaName = s.getName();
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    } else {
        for (Catalog c : catalogs) {
            EList<ModelElement> ownedElement = null;
            List<Schema> schemas = CatalogHelper.getSchemas(c);
            if (schemas.isEmpty()) {
                if (c != null) {
                    ownedElement = c.getOwnedElement();
                    if (ownedElement != null) {
                        for (ModelElement m : ownedElement) {
                            if (m instanceof org.talend.core.model.metadata.builder.connection.MetadataTable) {
                                String label = ((org.talend.core.model.metadata.builder.connection.MetadataTable) m).getLabel();
                                if (label.equals(tableName)) {
                                    catalogName = c.getName();
                                    break;
                                }
                            }
                        }
                    }
                }
            } else {
                for (Schema s : schemas) {
                    if (s != null) {
                        ownedElement = s.getOwnedElement();
                        if (ownedElement != null) {
                            for (ModelElement m : ownedElement) {
                                if (m instanceof org.talend.core.model.metadata.builder.connection.MetadataTable) {
                                    String label = ((org.talend.core.model.metadata.builder.connection.MetadataTable) m).getLabel();
                                    if (label.equals(tableName)) {
                                        catalogName = c.getName();
                                        schemaName = s.getName();
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    catalogAndSchema.add(catalogName);
    catalogAndSchema.add("String_Node_Str".equals(schemaName) ? null : schemaName);
    return catalogAndSchema;
}

Output:
     }
-    catalogAndSchema.add(catalogName);
-    catalogAndSchema.add("String_Node_Str".equals(schemaName) ? null : schemaName);
+    catalogAndSchema.add("String_Node_Str".equals(catalogName) ? null : catalogName);
+    catalogAndSchema.add(("String_Node_Str".equals(schemaName) || "String_Node_Str".equals(schemaName)) ? null : schemaName);
     return catalogAndSchema;


Input:
private void incomprehensiveColumnBinding() throws BirtException, DataException, IOException {
    this.GEN_add_group = true;
    this.GEN_add_subquery = true;
    this.GEN_print = true;
    this.USE_DATE_IN_COLUMNBINDING = false;
    this.genBasicIV();
    this.closeArchiveWriter();
    DataEngineContext deContext2 = newContext(DataEngineContext.MODE_UPDATE, fileName, fileName);
    if (myPreDataEngine != null) {
        myPreDataEngine.shutdown();
        myGenDataEngine.clearCache(dataSource, dataSet);
    }
    myPreDataEngine = DataEngine.newDataEngine(deContext2);
    this.UPDATE_add_same_group = true;
    this.UPDATE_add_subquery = 1;
    this.updatePreBasicIV();
    this.closeArchiveReader();
    this.closeArchiveWriter();
    myPreDataEngine.shutdown();
    DataEngineContext deContext3 = newContext(DataEngineContext.MODE_PRESENTATION, fileName, fileName);
    myPreDataEngine = DataEngine.newDataEngine(deContext3);
    this.PRE_execute_query = false;
    this.preBasicIV();
    this.checkOutputFile();
    myPreDataEngine.shutdown();
}

Output:
         myPreDataEngine.shutdown();
-        myGenDataEngine.clearCache(dataSource, dataSet);
+        myPreDataEngine.clearCache(dataSource, dataSet);
     }


Input:
public Object[] currentState() {
    if (expiredEventChunk != null) {
        return new Object[] { currentEventChunk.getFirst(), endTime, startTime, isStartTimeEnabled, schedulerTimeout, resetEvent, expiredEventChunk.getFirst() };
    } else {
        return new Object[] { currentEventChunk.getFirst(), endTime, startTime, isStartTimeEnabled, schedulerTimeout, resetEvent };
    }
}

Output:
 public Object[] currentState() {
-    if (expiredEventChunk != null) {
-        return new Object[] { currentEventChunk.getFirst(), endTime, startTime, isStartTimeEnabled, schedulerTimeout, resetEvent, expiredEventChunk.getFirst() };
-    } else {
-        return new Object[] { currentEventChunk.getFirst(), endTime, startTime, isStartTimeEnabled, schedulerTimeout, resetEvent };
-    }
+    return new Object[] { currentEventChunk.getFirst(), expiredEventChunk != null ? expiredEventChunk.getFirst() : null, resetEvent, endTime, startTime, lastScheduledTime, lastCurrentEventTime, flushed };
 }


Input:
public String generateVariableInitialization() throws IllegalActionException {
    StringBuffer code = new StringBuffer();
    code.append(super.generateVariableInitialization());
    ptolemy.actor.sched.StaticSchedulingDirector director = (ptolemy.actor.sched.StaticSchedulingDirector) getComponent();
    Schedule schedule = director.getScheduler().getSchedule();
    Iterator<?> actorsToFire = schedule.firingIterator();
    while (actorsToFire.hasNext()) {
        Firing firing = (Firing) actorsToFire.next();
        Actor actor = firing.getActor();
        if (actor instanceof ModularCodeGenTypedCompositeActor || actor instanceof ModularCompiledSDFTypedCompositeActor) {
            String className = NamedProgramCodeGeneratorAdapter.generateName((NamedObj) actor);
            String actorName = ModularCodeGenTypedCompositeActor.classToActorName(className);
            code.append(actorName + "String_Node_Str" + className + "String_Node_Str" + _eol);
            code.append(actorName + "String_Node_Str" + _eol);
        }
    }
    return code.toString();
}

Output:
     StringBuffer code = new StringBuffer();
-    code.append(super.generateVariableInitialization());
+    CompositeActor container = (CompositeActor) _director.getContainer();
+    GenericCodeGenerator codeGenerator = getCodeGenerator();
+    {
+        NamedProgramCodeGeneratorAdapter adapterObject = (NamedProgramCodeGeneratorAdapter) codeGenerator.getAdapter(container);
+        code.append(_generateVariableInitialization(adapterObject));
+    }
+    Iterator<?> actors = container.deepEntityList().iterator();
+    while (actors.hasNext()) {
+        Actor actor = (Actor) actors.next();
+        NamedProgramCodeGeneratorAdapter adapterObject = (NamedProgramCodeGeneratorAdapter) codeGenerator.getAdapter(actor);
+        code.append(_generateVariableInitialization(adapterObject));
+    }
     ptolemy.actor.sched.StaticSchedulingDirector director = (ptolemy.actor.sched.StaticSchedulingDirector) getComponent();


Input:
public OngoingFinalSetOperationCTECriteriaBuilder<Z> endSetWith() {
    subListener.verifyBuilderEnded();
    listener.onBuilderEnded(this);
    return (OngoingFinalSetOperationCTECriteriaBuilder<Z>) finalSetOperationBuilder;
}

Output:
     listener.onBuilderEnded(this);
-    return (OngoingFinalSetOperationCTECriteriaBuilder<Z>) finalSetOperationBuilder;
+    return (OngoingFinalSetOperationCTECriteriaBuilder<Z>) (OngoingFinalSetOperationCTECriteriaBuilder) finalSetOperationBuilder;
 }