Input:
public static List readAjAttributes(Attribute[] as, ISourceContext context, IMessageHandler msgHandler) {
    List l = new ArrayList();
    for (int i = as.length - 1; i >= 0; i--) {
        Attribute a = as[i];
        if (a instanceof Unknown) {
            Unknown u = (Unknown) a;
            String name = u.getName();
            if (name.startsWith(AjAttribute.AttributePrefix)) {
                AjAttribute attr = AjAttribute.read(name, u.getBytes(), context, msgHandler);
                if (attr != null)
                    l.add(attr);
            }
        }
    }
    return l;
}

Output:
             if (name.startsWith(AjAttribute.AttributePrefix)) {
-                AjAttribute attr = AjAttribute.read(name, u.getBytes(), context, msgHandler);
+                AjAttribute attr = AjAttribute.read(version, name, u.getBytes(), context, msgHandler);
+                if (attr != null && attr instanceof AjAttribute.WeaverVersionInfo) {
+                    version = (AjAttribute.WeaverVersionInfo) attr;
+                    if (version.getMajorVersion() > WeaverVersionInfo.getCurrentWeaverMajorVersion()) {
+                        throw new BCException("String_Node_Str" + WeaverVersionInfo.toCurrentVersionString() + "String_Node_Str" + classname + "String_Node_Str" + version.toString());
+                    }
+                }
                 if (attr != null)


Input:
protected void handleUnregister(ID containerID, Long serviceId) {
    Trace.entering(Activator.PLUGIN_ID, IRemoteServiceProviderDebugOptions.METHODS_ENTERING, this.getClass(), "String_Node_Str", new Object[] { containerID, serviceId });
    synchronized (remoteRegistrys) {
        final RemoteServiceRegistryImpl serviceRegistry = (RemoteServiceRegistryImpl) remoteRegistrys.get(containerID);
        if (serviceRegistry != null) {
            final RemoteServiceRegistrationImpl registration = serviceRegistry.findRegistrationForServiceId(serviceId.longValue());
            if (registration != null) {
                serviceRegistry.unpublishService(registration);
                unpublishServiceRegistration(registration.getContainerID());
                fireRemoteServiceListeners(createUnregisteredEvent(registration));
            }
        }
    }
    Trace.exiting(Activator.PLUGIN_ID, IRemoteServiceProviderDebugOptions.METHODS_EXITING, this.getClass(), "String_Node_Str");
}

Output:
                 serviceRegistry.unpublishService(registration);
-                unpublishServiceRegistration(registration.getContainerID());
+                unpublishServiceRegistrationsForContainer(registration.getContainerID());
                 fireRemoteServiceListeners(createUnregisteredEvent(registration));


Input:
public void setup() {
    this.jobPersistenceService = Mockito.mock(JobPersistenceService.class);
    this.jobKillService = Mockito.mock(JobKillService.class);
    this.jobStateService = Mockito.mock(JobStateService.class);
    this.jobSearchService = Mockito.mock(JobSearchService.class);
    this.jobsProperties = new JobsProperties();
    this.jobsProperties.getLocations().setArchives(BASE_ARCHIVE_LOCATION);
    this.jobsProperties.getMemory().setDefaultJobMemory(MEMORY);
    this.jobsProperties.getUsers().getActiveLimit().setEnabled(ACTIVE_JOBS_LIMIT_ENABLED);
    this.applicationService = Mockito.mock(ApplicationService.class);
    this.clusterService = Mockito.mock(ClusterService.class);
    this.commandService = Mockito.mock(CommandService.class);
    this.clusterLoadBalancer1 = Mockito.mock(ClusterLoadBalancer.class);
    this.clusterLoadBalancer2 = Mockito.mock(ClusterLoadBalancer.class);
    this.clusterLoadBalancer3 = Mockito.mock(ClusterLoadBalancer.class);
    this.clusterLoadBalancer4 = Mockito.mock(ClusterLoadBalancer.class);
    this.registry = Mockito.mock(Registry.class);
    this.tagsCaptor = ArgumentCaptor.forClass(Map.class);
    this.coordinationTimerId = Mockito.mock(Id.class);
    this.coordinationTimer = Mockito.mock(Timer.class);
    Mockito.when(this.registry.createId("String_Node_Str")).thenReturn(coordinationTimerId);
    Mockito.when(coordinationTimerId.withTags(Mockito.any(Map.class))).thenReturn(coordinationTimerId);
    Mockito.when(this.registry.timer(Mockito.eq(coordinationTimerId))).thenReturn(coordinationTimer);
    this.selectClusterTimerId = Mockito.mock(Id.class);
    this.selectClusterTimer = Mockito.mock(Timer.class);
    Mockito.when(this.registry.createId("String_Node_Str")).thenReturn(selectClusterTimerId);
    Mockito.when(selectClusterTimerId.withTags(Mockito.any(Map.class))).thenReturn(selectClusterTimerId);
    Mockito.when(this.registry.timer(Mockito.eq(selectClusterTimerId))).thenReturn(selectClusterTimer);
    this.selectCommandTimerId = Mockito.mock(Id.class);
    this.selectCommandTimer = Mockito.mock(Timer.class);
    Mockito.when(this.registry.createId("String_Node_Str")).thenReturn(selectCommandTimerId);
    Mockito.when(selectCommandTimerId.withTags(Mockito.any(Map.class))).thenReturn(selectCommandTimerId);
    Mockito.when(this.registry.timer(Mockito.eq(selectCommandTimerId))).thenReturn(selectCommandTimer);
    this.selectApplicationTimerId = Mockito.mock(Id.class);
    this.selectApplicationTimer = Mockito.mock(Timer.class);
    Mockito.when(this.registry.createId("String_Node_Str")).thenReturn(selectApplicationTimerId);
    Mockito.when(selectApplicationTimerId.withTags(Mockito.any(Map.class))).thenReturn(selectApplicationTimerId);
    Mockito.when(this.registry.timer(Mockito.eq(selectApplicationTimerId))).thenReturn(selectApplicationTimer);
    this.setJobEnvironmentTimerId = Mockito.mock(Id.class);
    this.setJobEnvironmentTimer = Mockito.mock(Timer.class);
    Mockito.when(this.registry.createId("String_Node_Str")).thenReturn(setJobEnvironmentTimerId);
    Mockito.when(setJobEnvironmentTimerId.withTags(Mockito.any(Map.class))).thenReturn(setJobEnvironmentTimerId);
    Mockito.when(this.registry.timer(Mockito.eq(setJobEnvironmentTimerId))).thenReturn(setJobEnvironmentTimer);
    this.noClusterSelectedCounter = Mockito.mock(Counter.class);
    Mockito.when(this.registry.counter("String_Node_Str")).thenReturn(noClusterSelectedCounter);
    this.noMatchingClusterCounter = Mockito.mock(Counter.class);
    Mockito.when(registry.counter("String_Node_Str")).thenReturn(noMatchingClusterCounter);
    this.loadBalancerCounterId = Mockito.mock(Id.class);
    this.loadBalancerCounter = Mockito.mock(Counter.class);
    Mockito.when(this.registry.createId("String_Node_Str")).thenReturn(loadBalancerCounterId);
    Mockito.when(loadBalancerCounterId.withTags(Mockito.any(Map.class))).thenReturn(loadBalancerCounterId);
    Mockito.when(this.registry.counter(Mockito.eq(loadBalancerCounterId))).thenReturn(loadBalancerCounter);
    this.jobCoordinatorService = new JobCoordinatorServiceImpl(this.jobPersistenceService, this.jobKillService, this.jobStateService, jobsProperties, this.applicationService, this.jobSearchService, this.clusterService, this.commandService, Lists.newArrayList(this.clusterLoadBalancer1, this.clusterLoadBalancer2, this.clusterLoadBalancer3, this.clusterLoadBalancer4), this.registry, HOST_NAME);
}

Output:
     this.clusterLoadBalancer4 = Mockito.mock(ClusterLoadBalancer.class);
-    this.registry = Mockito.mock(Registry.class);
-    this.tagsCaptor = ArgumentCaptor.forClass(Map.class);
+    final Registry registry = Mockito.mock(Registry.class);
     this.coordinationTimerId = Mockito.mock(Id.class);


Input:
private void updateEventStatusAndPassEventToUser(BluetoothEnablerListener.Status newStatus) {
    m_currentEvent = new BluetoothEnablerListener.BluetoothEnablerEvent(m_currentEvent.stage(), newStatus);
    m_lastPlease = m_startupListener.onEvent(m_currentEvent);
    handlePleaseResponse();
}

Output:
 private void updateEventStatusAndPassEventToUser(BluetoothEnablerListener.Status newStatus) {
-    m_currentEvent = new BluetoothEnablerListener.BluetoothEnablerEvent(m_currentEvent.stage(), newStatus);
-    m_lastPlease = m_startupListener.onEvent(m_currentEvent);
+    BluetoothEnablerListener.BluetoothEnablerEvent currentEvent = new BluetoothEnablerListener.BluetoothEnablerEvent(m_currentStage, newStatus);
+    m_lastPlease = m_startupListener.onEvent(currentEvent);
     handlePleaseResponse();


Input:
protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buf) throws Exception {
    if (buf.readableBytes() < 12) {
        return null;
    }
    int length = 0;
    switch(buf.getUnsignedByte(buf.readerIndex())) {
        case MSG_LOGIN:
            length = 19;
            break;
        case MSG_LOCATION:
            length = 34;
            break;
    }
    if (length != 0 && buf.readableBytes() >= length) {
        return buf.readBytes(length);
    }
    return null;
}

Output:
     }
-    int length = 0;
+    int length;
     switch(buf.getUnsignedByte(buf.readerIndex())) {


Input:
private void parseTableExtraSpanRows(ContainerArea table) {
    int additionalrowheight = 0;
    int additionalrowspan = 0;
    for (int rowidx = table.getChildrenCount() - 1; rowidx >= 0; rowidx--) {
        ContainerArea child = (ContainerArea) table.getChild(rowidx);
        if (child instanceof TableGroupArea) {
            parseTableExtraSpanRows(child);
        } else {
            RowArea row = (RowArea) child;
            if (row.getChildrenCount() == 0) {
                additionalrowheight += row.getHeight();
                additionalrowspan++;
            } else if (additionalrowspan > 0) {
                row.setHeight(additionalrowheight + row.getHeight());
                Iterator<IArea> iter = row.getChildren();
                while (iter.hasNext()) {
                    CellArea cell = (CellArea) iter.next();
                    cell.setRowSpan(cell.getRowSpan() - additionalrowspan);
                }
                additionalrowheight = 0;
                additionalrowspan = 0;
            }
        }
    }
}

Output:
             RowArea row = (RowArea) child;
-            if (row.getChildrenCount() == 0) {
+            int numOfCells = row.getChildrenCount();
+            if (numOfCells == 0) {
                 additionalrowheight += row.getHeight();


Input:
private float getContentHeight(IContent content) {
    return ExcelUtil.convertDimensionType(content.getHeight(), 0, context.getDpi()) / 1000;
}

Output:
 private float getContentHeight(IContent content) {
-    return ExcelUtil.convertDimensionType(content.getHeight(), 0, context.getDpi()) / 1000;
+    return ExcelUtil.convertDimensionType(content.getHeight(), 0, context.getDpi()) / 1000f;
 }


Input:
private Node getNodeFor(Tab targetTab) throws StepExecutionException {
    EventThreadQueuerJavaFXImpl.checkEventThread();
    Skin<?> tabPaneSkin = getRealComponent().getSkin();
    if (!(tabPaneSkin instanceof SkinBase)) {
        throw new StepExecutionException("String_Node_Str" + tabPaneSkin.getClass(), EventFactory.createActionError(TestErrorEvent.RENDERER_NOT_SUPPORTED));
    }
    ClassLoader skinClassLoader = targetTab.getClass().getClassLoader();
    try {
        Class<?> tabHeaderAreaClass = skinClassLoader.loadClass(TAB_HEADER_AREA_CLASSNAME);
        for (Node tabPaneSkinChild : ((SkinBase<?>) tabPaneSkin).getChildren()) {
            if (tabHeaderAreaClass.isInstance(tabPaneSkinChild)) {
                Method method = tabHeaderAreaClass.getDeclaredMethod(GET_TAB_HEADER_SKIN_METHOD_NAME, GET_TAB_HEADER_SKIN_PARAMETER_TYPES);
                method.setAccessible(true);
                Object tabHeaderSkin = method.invoke(tabPaneSkinChild, new Object[] { targetTab });
                if (tabHeaderSkin == null || tabHeaderSkin instanceof Node) {
                    return (Node) tabHeaderSkin;
                }
                throw new StepExecutionException("String_Node_Str" + tabHeaderSkin.getClass(), EventFactory.createActionError(TestErrorEvent.RENDERER_NOT_SUPPORTED));
            }
        }
    } catch (ClassNotFoundException | NoSuchMethodException e) {
    } catch (IllegalAccessException | InvocationTargetException e) {
        throw new StepExecutionException(e);
    }
    throw new StepExecutionException("String_Node_Str" + tabPaneSkin.getClass(), EventFactory.createActionError(TestErrorEvent.RENDERER_NOT_SUPPORTED));
}

Output:
     try {
-        Class<?> tabHeaderAreaClass = skinClassLoader.loadClass(TAB_HEADER_AREA_CLASSNAME);
+        Class<?> tabHeaderAreaClass = null;
+        if (SystemUtils.JAVA_VERSION_FLOAT > 1.8f) {
+            tabHeaderAreaClass = skinClassLoader.loadClass(TAB_HEADER_AREA_CLASSNAME_JAVA9);
+        } else {
+            tabHeaderAreaClass = skinClassLoader.loadClass(TAB_HEADER_AREA_CLASSNAME);
+        }
         for (Node tabPaneSkinChild : ((SkinBase<?>) tabPaneSkin).getChildren()) {


Input:
public PsiElement getNameIdentifier() {
    return findChildByType(CSharpTokens.IDENTIFIER);
}

Output:
 public PsiElement getNameIdentifier() {
-    return findChildByType(CSharpTokens.IDENTIFIER);
+    return findNotNullChildByClass(CSharpIdentifier.class);
 }


Input:
public static JsonArray get(String roadName) throws EniroMapException {
    HttpClient client = new DefaultHttpClient();
    HttpGet get = null;
    try {
        URIBuilder builder = new URIBuilder(url);
        builder.setParameter("String_Node_Str", "String_Node_Str");
        builder.setParameter("String_Node_Str", "String_Node_Str");
        builder.setParameter("String_Node_Str", "String_Node_Str");
        builder.setParameter("String_Node_Str", "String_Node_Str");
        builder.setParameter("String_Node_Str", "String_Node_Str");
        builder.setParameter("String_Node_Str", roadName);
        get = new HttpGet(builder.build());
    } catch (URISyntaxException e) {
        throw new EniroMapException(e);
    }
    HttpResponse response = null;
    try {
        response = client.execute(get);
    } catch (IOException e) {
        throw new EniroMapException(e);
    }
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        JsonElement jelement = null;
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent()));
            String jsonLine = br.readLine();
            jelement = new JsonParser().parse(jsonLine);
        } catch (IOException e) {
            throw new EniroMapException(e);
        }
        if (jelement.getAsJsonObject().getAsJsonObject("String_Node_Str").getAsJsonObject("String_Node_Str").getAsJsonArray("String_Node_Str") == null) {
            throw new EniroMapException("String_Node_Str" + roadName);
        }
        JsonObject geometry = null;
        try {
            geometry = jelement.getAsJsonObject().getAsJsonObject("String_Node_Str").getAsJsonObject("String_Node_Str").getAsJsonArray("String_Node_Str").get(0).getAsJsonObject().getAsJsonObject("String_Node_Str");
        } catch (Exception e) {
            throw new EniroMapException("String_Node_Str", e);
        }
        JsonArray coords = geometry.getAsJsonArray("String_Node_Str");
        return coords;
    } else {
        throw new EniroMapException("String_Node_Str" + response.getStatusLine().toString());
    }
}

Output:
         try {
-            BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent()));
+            BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent(), "String_Node_Str"));
             String jsonLine = br.readLine();


Input:
public void widgetSelected(SelectionEvent e) {
    testButton.setEnabled(false);
    try {
        if (testConnection()) {
            MessageDialog.openInformation(getShell(), JdbcPlugin.getResourceString("String_Node_Str"), JdbcPlugin.getResourceString("String_Node_Str"));
        } else {
            OdaException ex = new OdaException(JdbcPlugin.getResourceString("String_Node_Str"));
            ExceptionHandler.showException(getShell(), JdbcPlugin.getResourceString("String_Node_Str"), JdbcPlugin.getResourceString("String_Node_Str"), ex);
        }
    } catch (OdaException e1) {
        ExceptionHandler.showException(getShell(), JdbcPlugin.getResourceString("String_Node_Str"), JdbcPlugin.getResourceString(e1.getLocalizedMessage()), e1);
    }
    testButton.setEnabled(true);
}

Output:
     } catch (OdaException e1) {
-        ExceptionHandler.showException(getShell(), JdbcPlugin.getResourceString("String_Node_Str"), JdbcPlugin.getResourceString(e1.getLocalizedMessage()), e1);
+        ExceptionHandler.showException(getShell(), JdbcPlugin.getResourceString("String_Node_Str"), e1.getLocalizedMessage(), e1);
     }


Input:
public void testConstructors() {
    LttngEvent testEvent = null;
    LTTngTrace testTrace = null;
    LttngEvent testAnotherEvent = null;
    LttngTimestamp testTime = null;
    String testSource = null;
    LttngEventType testType = null;
    LttngEventContent testContent = null;
    String testReference = null;
    JniEvent testJniEvent = null;
    String[] testMarkerFields = null;
    try {
        testMarkerFields = new String[] { "String_Node_Str" };
        testEvent = null;
        testTime = new LttngTimestamp(0L);
        testSource = "String_Node_Str";
        testType = new LttngEventType("String_Node_Str", 0L, "String_Node_Str", 0, testMarkerFields);
        testContent = new LttngEventContent(testEvent);
        testReference = "String_Node_Str";
    } catch (Exception e) {
        fail("String_Node_Str");
    }
    try {
        testEvent = new LttngEvent(testTrace, testTime, testSource, testType, testContent, testReference, testJniEvent);
    } catch (Exception e) {
        fail("String_Node_Str");
    }
    try {
        testAnotherEvent = new LttngEvent(null);
        fail("String_Node_Str");
    } catch (Exception e) {
    }
    testEvent = prepareToTest();
    try {
        testAnotherEvent = new LttngEvent(testEvent);
    } catch (Exception e) {
        fail("String_Node_Str");
    }
}

Output:
     try {
-        testAnotherEvent = new LttngEvent(null);
+        new LttngEvent(null);
         fail("String_Node_Str");


Input:
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((comparator == null) ? 0 : comparator.hashCode());
    result = prime * result + ((decisionTree == null) ? 0 : decisionTree.hashCode());
    result = prime * result + ((registry == null) ? 0 : registry.hashCode());
    return result;
}

Output:
     int result = 1;
-    result = prime * result + ((comparator == null) ? 0 : comparator.hashCode());
-    result = prime * result + ((decisionTree == null) ? 0 : decisionTree.hashCode());
-    result = prime * result + ((registry == null) ? 0 : registry.hashCode());
+    result = (prime * result) + ((comparator == null) ? 0 : comparator.hashCode());
+    result = (prime * result) + ((decisionTree == null) ? 0 : decisionTree.hashCode());
+    result = (prime * result) + ((registry == null) ? 0 : registry.hashCode());
     return result;


Input:
public void testSampleTimerSummaryParceling() throws Exception {
    final MockClocks clocks = new MockClocks();
    clocks.realtime = 0;
    clocks.uptime = 0;
    final BatteryStatsImpl.TimeBase timeBase = new BatteryStatsImpl.TimeBase();
    timeBase.init(clocks.uptimeMillis(), clocks.elapsedRealtime());
    BatteryStatsImpl.SamplingTimer timer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
    timeBase.setRunning(true, clocks.uptimeMillis(), clocks.elapsedRealtime());
    timer.add(10, 1);
    timer.add(10, 1);
    clocks.realtime = 20;
    clocks.uptime = 20;
    assertEquals(10, timer.getTotalTimeLocked(clocks.elapsedRealtime(), BatteryStats.STATS_SINCE_CHARGED));
    assertEquals(1, timer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
    final Parcel onBatterySummaryParcel = Parcel.obtain();
    timer.writeSummaryFromParcelLocked(onBatterySummaryParcel, clocks.elapsedRealtime() * 1000);
    onBatterySummaryParcel.setDataPosition(0);
    timeBase.setRunning(false, clocks.uptimeMillis(), clocks.elapsedRealtime());
    assertEquals(10, timer.getTotalTimeLocked(clocks.elapsedRealtime(), BatteryStats.STATS_SINCE_CHARGED));
    assertEquals(1, timer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
    final Parcel offBatterySummaryParcel = Parcel.obtain();
    timer.writeSummaryFromParcelLocked(offBatterySummaryParcel, clocks.elapsedRealtime() * 1000);
    offBatterySummaryParcel.setDataPosition(0);
    BatteryStatsImpl.SamplingTimer unparceledTimer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
    unparceledTimer.readSummaryFromParcelLocked(onBatterySummaryParcel);
    assertEquals(10, unparceledTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
    assertEquals(1, unparceledTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
    unparceledTimer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
    unparceledTimer.readSummaryFromParcelLocked(offBatterySummaryParcel);
    assertEquals(10, unparceledTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
    assertEquals(1, unparceledTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
}

Output:
     offBatterySummaryParcel.setDataPosition(0);
-    BatteryStatsImpl.SamplingTimer unparceledTimer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
-    unparceledTimer.readSummaryFromParcelLocked(onBatterySummaryParcel);
-    assertEquals(10, unparceledTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
-    assertEquals(1, unparceledTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
-    unparceledTimer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
-    unparceledTimer.readSummaryFromParcelLocked(offBatterySummaryParcel);
-    assertEquals(10, unparceledTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
-    assertEquals(1, unparceledTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
+    timeBase.setRunning(true, clocks.uptimeMillis(), clocks.elapsedRealtime());
+    BatteryStatsImpl.SamplingTimer unparceledOnBatteryTimer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
+    unparceledOnBatteryTimer.readSummaryFromParcelLocked(onBatterySummaryParcel);
+    assertEquals(10, unparceledOnBatteryTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
+    assertEquals(1, unparceledOnBatteryTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
+    BatteryStatsImpl.SamplingTimer unparceledOffBatteryTimer = new BatteryStatsImpl.SamplingTimer(clocks, timeBase);
+    unparceledOffBatteryTimer.readSummaryFromParcelLocked(offBatterySummaryParcel);
+    assertEquals(10, unparceledOffBatteryTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
+    assertEquals(1, unparceledOffBatteryTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
+    unparceledOnBatteryTimer.update(10, 10);
+    assertEquals(10, unparceledOnBatteryTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
+    assertEquals(1, unparceledOnBatteryTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
+    unparceledOffBatteryTimer.update(10, 10);
+    assertEquals(10, unparceledOffBatteryTimer.getTotalTimeLocked(0, BatteryStats.STATS_SINCE_CHARGED));
+    assertEquals(1, unparceledOffBatteryTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED));
 }


Input:
public boolean evaluate(JSONObject jsonObject) {
    if (indicator == null) {
        return false;
    }
    boolean result = false;
    try {
        JSONArray indicators = getRMIndicators(jsonObject);
        if (indicators != null) {
            if (indicators.contains(indicator)) {
                result = true;
            }
        }
    } catch (Exception err) {
        throw new AlfrescoRuntimeException("String_Node_Str" + err);
    }
    return (result == expected);
}

Output:
         JSONArray indicators = getRMIndicators(jsonObject);
-        if (indicators != null) {
-            if (indicators.contains(indicator)) {
-                result = true;
-            }
+        if (indicators != null && indicators.contains(indicator)) {
+            result = true;
         }


Input:
public List<String> validateQuestionDetails() {
    List<String> errors = new ArrayList<String>();
    if (!isValidDescriptionSize()) {
        errors.add(ERROR_RUBRIC_DESC_INVALID_SIZE);
    }
    if (this.numOfRubricChoices < MIN_NUM_OF_RUBRIC_CHOICES) {
        errors.add(ERROR_NOT_ENOUGH_RUBRIC_CHOICES + MIN_NUM_OF_RUBRIC_CHOICES);
    }
    if (this.numOfRubricChoices < MIN_NUM_OF_RUBRIC_SUB_QUESTIONS) {
        errors.add(ERROR_NOT_ENOUGH_RUBRIC_SUB_QUESTIONS + MIN_NUM_OF_RUBRIC_SUB_QUESTIONS);
    }
    for (String choice : this.rubricChoices) {
        if (choice.trim().isEmpty()) {
            errors.add(ERROR_RUBRIC_EMPTY_CHOICE);
            break;
        }
    }
    for (String subQn : this.rubricSubQuestions) {
        if (subQn.trim().isEmpty()) {
            errors.add(ERROR_RUBRIC_EMPTY_SUB_QUESTION);
            break;
        }
    }
    return errors;
}

Output:
     }
-    if (this.numOfRubricChoices < MIN_NUM_OF_RUBRIC_SUB_QUESTIONS) {
+    if (this.numOfRubricSubQuestions < MIN_NUM_OF_RUBRIC_SUB_QUESTIONS) {
         errors.add(ERROR_NOT_ENOUGH_RUBRIC_SUB_QUESTIONS + MIN_NUM_OF_RUBRIC_SUB_QUESTIONS);


Input:
static WithValue id(String id, Iterable<GoogRequire> requires) {
    CodeChunkUtils.checkId(id);
    return Leaf.create(id, requires);
}

Output:
     CodeChunkUtils.checkId(id);
-    return Leaf.create(id, requires);
+    return Leaf.create(id, true, requires);
 }


Input:
public Set<Entry<K, V>> entrySet() {
    HashSet<Entry<K, V>> entrySet = new HashSet<Entry<K, V>>(map1.entrySet());
    entrySet.addAll(map2.entrySet());
    return unmodifiableSet(entrySet);
}

Output:
 public Set<Entry<K, V>> entrySet() {
-    HashSet<Entry<K, V>> entrySet = new HashSet<Entry<K, V>>(map1.entrySet());
-    entrySet.addAll(map2.entrySet());
-    return unmodifiableSet(entrySet);
+    Set<Entry<K, V>> entrySet1 = map1.entrySet();
+    Set<Entry<K, V>> entrySet2 = map2.entrySet();
+    HashSet<Entry<K, V>> aggregatedEntrySet = new HashSet<Entry<K, V>>();
+    copyEntries(entrySet1, aggregatedEntrySet);
+    copyEntries(entrySet2, aggregatedEntrySet);
+    return unmodifiableSet(aggregatedEntrySet);
 }


Input:
public static void dump(String fileName, PrintWriter writer) {
    if (!FileUtils.exists(fileName)) {
        writer.println("String_Node_Str" + fileName);
        return;
    }
    FileChannel file = null;
    try {
        file = FilePath.get(fileName).open("String_Node_Str");
        long fileLength = file.size();
        file.position(0);
        byte[] header = new byte[blockSize];
        file.read(ByteBuffer.wrap(header));
        Properties prop = new Properties();
        prop.load(new ByteArrayInputStream(header));
        prop.load(new StringReader(new String(header, "String_Node_Str")));
        writer.println("String_Node_Str" + fileName);
        writer.println("String_Node_Str" + fileLength);
        writer.println("String_Node_Str" + prop);
        ByteBuffer block = ByteBuffer.wrap(new byte[32]);
        for (long pos = 0; pos < fileLength; ) {
            file.position(pos);
            block.rewind();
            FileUtils.readFully(file, block);
            block.rewind();
            if (block.get() != 'c') {
                pos += blockSize;
                continue;
            }
            int chunkLength = block.getInt();
            int chunkId = block.getInt();
            long metaRootPos = block.getLong();
            writer.println("String_Node_Str" + chunkId + "String_Node_Str" + pos + "String_Node_Str" + chunkLength + "String_Node_Str" + metaRootPos);
            ByteBuffer chunk = ByteBuffer.allocate(chunkLength);
            file.position(pos);
            FileUtils.readFully(file, chunk);
            int p = block.position();
            pos = (pos + chunkLength + blockSize) / blockSize * blockSize;
            chunkLength -= p;
            while (chunkLength > 0) {
                chunk.position(p);
                int pageLength = chunk.getInt();
                chunk.getShort();
                long mapId = DataUtils.readVarInt(chunk);
                int len = DataUtils.readVarInt(chunk);
                int type = chunk.get();
                boolean compressed = (type & 2) != 0;
                boolean node = (type & 1) != 0;
                writer.println("String_Node_Str" + mapId + "String_Node_Str" + p + "String_Node_Str" + (node ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + (compressed ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + pageLength + "String_Node_Str" + len);
                p += pageLength;
                chunkLength -= pageLength;
            }
        }
    } catch (IOException e) {
        writer.println("String_Node_Str" + e);
    } finally {
        try {
            file.close();
        } catch (IOException e) {
        }
    }
    writer.println();
    writer.flush();
}

Output:
     } finally {
-        try {
-            file.close();
-        } catch (IOException e) {
+        if (file != null) {
+            try {
+                file.close();
+            } catch (IOException e) {
+            }
         }


Input:
public static API GetRightApiForVersion(String appVersion, Context context) {
    API api;
    int majorVersion = 0;
    int minorVersion = 0;
    if (appVersion != null) {
        majorVersion = Integer.parseInt(appVersion.substring(0, 1));
        appVersion = appVersion.substring(2);
        appVersion = appVersion.replace("String_Node_Str", "String_Node_Str");
        minorVersion = Integer.parseInt(appVersion);
    }
    switch(majorVersion) {
        case 1:
            if (minorVersion >= 101) {
                api = new APIv2(context);
            } else {
                api = new APIv1(context);
            }
            break;
        case 2:
            api = new APIv2(context);
            break;
        case 3:
            api = new APIv2(context);
            break;
        case 4:
            api = new APIv2(context);
            break;
        default:
            api = new APIv2(context);
            break;
    }
    return api;
}

Output:
             if (minorVersion >= 101) {
-                api = new APIv2(context);
+                api = new APIv2(baseUrl);
             } else {


Input:
protected ScriptRunner createSqlPlusScriptRunner(Class<ScriptRunner> clazz) {
    String sqlPlusCommand = PropertyUtils.getString(PROPERTY_SQL_PLUS_COMMAND, configuration);
    return createInstanceOfType(clazz, false, new Class<?>[] { DbSupport.class, Map.class, String.class }, new Object[] { defaultDbSupport, nameDbSupportMap, sqlPlusCommand });
}

Output:
     String sqlPlusCommand = PropertyUtils.getString(PROPERTY_SQL_PLUS_COMMAND, configuration);
-    return createInstanceOfType(clazz, false, new Class<?>[] { DbSupport.class, Map.class, String.class }, new Object[] { defaultDbSupport, nameDbSupportMap, sqlPlusCommand });
+    return createInstanceOfType(clazz, false, new Class<?>[] { DbSupport.class, Map.class, String.class }, new Object[] { getDefaultDbSupport(), getNameDbSupportMap(), sqlPlusCommand });
 }


Input:
public static List<TdView> getViews(Collection<? extends EObject> elements, String viewFilter) {
    List<TdView> views = new ArrayList<TdView>();
    boolean filter = (viewFilter == null || "String_Node_Str".equals(viewFilter)) ? false : true;
    for (EObject elt : elements) {
        TdView view = SwitchHelpers.VIEW_SWITCH.doSwitch(elt);
        if (view != null) {
            if (filter) {
                if (view.getName().toLowerCase().indexOf(viewFilter.toLowerCase()) > -1) {
                    views.add(view);
                }
            } else {
                views.add(view);
            }
        }
    }
    return views;
}

Output:
     for (EObject elt : elements) {
-        TdView view = SwitchHelpers.VIEW_SWITCH.doSwitch(elt);
-        if (view != null) {
-            if (filter) {
-                if (view.getName().toLowerCase().indexOf(viewFilter.toLowerCase()) > -1) {
-                    views.add(view);
-                }
-            } else {
-                views.add(view);
-            }
+        TdView table = SwitchHelpers.VIEW_SWITCH.doSwitch(elt);
+        if (table != null) {
+            views.add(table);
         }


Input:
private void migrate(Module jcrModule) {
    POM pom = new POM();
    Path modulePath = migrationPathManager.generateRootPath();
    projectService.newProject(makeRepository(modulePath), jcrModule.getName(), pom, "String_Node_Str");
}

Output:
 private void migrate(Module jcrModule) {
-    POM pom = new POM();
+    GAV gav = new GAV(jcrModule.getName(), jcrModule.getName(), "String_Node_Str");
+    POM pom = new POM(gav);
     Path modulePath = migrationPathManager.generateRootPath();


Input:
private static void addTypeAdaptersForDate(String datePattern, int dateStyle, ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers, ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers) {
    DefaultDateTypeAdapter dateTypeAdapter = null;
    if (datePattern != null && !"String_Node_Str".equals(datePattern.trim())) {
        dateTypeAdapter = new DefaultDateTypeAdapter(datePattern);
    } else if (dateStyle != DateFormat.DEFAULT) {
        dateTypeAdapter = new DefaultDateTypeAdapter(dateStyle);
    }
    if (dateTypeAdapter != null && !serializers.hasAnyHandlerFor(Date.class) && !deserializers.hasAnyHandlerFor(Date.class)) {
        serializers.register(Date.class, dateTypeAdapter);
        deserializers.register(Date.class, dateTypeAdapter);
    }
}

Output:
         dateTypeAdapter = new DefaultDateTypeAdapter(datePattern);
-    } else if (dateStyle != DateFormat.DEFAULT) {
-        dateTypeAdapter = new DefaultDateTypeAdapter(dateStyle);
+    } else if (dateStyle != DateFormat.DEFAULT && timeStyle != DateFormat.DEFAULT) {
+        dateTypeAdapter = new DefaultDateTypeAdapter(dateStyle, timeStyle);
     }


Input:
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
    sentenceView.giveFingerPosition((int) (progress + seekBar.getX()));
    SeekEvent e = new SeekEvent();
    e.time = System.currentTimeMillis();
    if (result.seekEvents.size() > 0) {
        e.tDelta = e.time - result.seekEvents.lastElement().time;
    } else {
        e.tDelta = e.time - baseSeekTime;
    }
    int fingerXPos = progress - seekBarMargin;
    if (fingerXPos < 0) {
        e.relativePosition = SeekEvent.ANTE_SENTENTIUM;
    } else if (fingerXPos >= seekBarMax - 2 * seekBarMargin) {
        e.relativePosition = SeekEvent.POST_SENTENTIUM;
    } else {
        e.relativePosition = SeekEvent.IN_SENTENTIUM;
    }
    e.x = fingerXPos;
    e.word = sentenceView.getWord();
    e.character = sentenceView.getChar();
    e.wordIndex = sentenceView.getWordIndex();
    e.charIndex = sentenceView.getCharIndex();
    if (result.seekEvents.size() > 0) {
        e.xDelta = e.x - result.seekEvents.lastElement().x;
        e.wordIndexDelta = e.wordIndex - result.seekEvents.lastElement().wordIndex;
        e.charIndexDelta = e.charIndex - result.seekEvents.lastElement().charIndex;
    }
    result.seekEvents.add(e);
}

Output:
     e.time = System.currentTimeMillis();
-    if (result.seekEvents.size() > 0) {
-        e.tDelta = e.time - result.seekEvents.lastElement().time;
+    if (result.getNumCharEvents() > 0) {
+        e.tDelta = e.time - result.getLastSeekEvent().time;
     } else {


Input:
public <P extends Record> P edit(P record) {
    P returnRecordImpl = (P) ((RecordImpl) record).getSchema().create(((RecordImpl) record).asJso());
    ((RecordImpl) returnRecordImpl).setDeltaValueStore(deltaValueStore);
    return returnRecordImpl;
}

Output:
 public <P extends Record> P edit(P record) {
-    P returnRecordImpl = (P) ((RecordImpl) record).getSchema().create(((RecordImpl) record).asJso());
+    P returnRecordImpl = (P) ((RecordImpl) record).getSchema().create(((RecordImpl) record).asJso(), ((RecordImpl) record).isFuture());
     ((RecordImpl) returnRecordImpl).setDeltaValueStore(deltaValueStore);


Input:
public static List<TreeObject> getChildrenObj(TreeParent xObject) {
    List<TreeObject> objs = new ArrayList<TreeObject>();
    if (xObject.getChildren() != null)
        for (TreeObject obj : xObject.getChildren()) {
            if (obj instanceof TreeParent) {
                TreeParent parent = (TreeParent) obj;
                if (parent != null)
                    objs.addAll(getChildrenObj(parent));
            } else {
                if (obj.isXObject())
                    objs.add(obj);
            }
        }
    return objs;
}

Output:
                 TreeParent parent = (TreeParent) obj;
-                if (parent != null)
+                if (parent != null) {
+                    if (obj.getType() == TreeObject.CATEGORY_FOLDER) {
+                        if (obj.getParent().getType() == TreeObject.DATA_CLUSTER) {
+                            for (TreeObject chld : ((TreeParent) obj).getChildren()) {
+                                if (chld.getName().equals(XSystemObjects.DC_PROVISIONING.getName()))
+                                    objs.add(chld);
+                                if (chld.getName().equals(XSystemObjects.DC_CONF.getName()))
+                                    objs.add(chld);
+                            }
+                            continue;
+                        } else {
+                            continue;
+                        }
+                    }
+                    if (obj.getType() == TreeObject.RESOURCES) {
+                        for (TreeObject child : ((TreeParent) obj).getChildren()) {
+                            if (child.getType() == TreeObject.PICTURES_RESOURCE) {
+                                objs.add(child);
+                            }
+                        }
+                        continue;
+                    }
                     objs.addAll(getChildrenObj(parent));


Input:
public void doSave(OutputStream outputStream, Map cacheRequestMap) throws DataException {
    DataOutputStream dos = new DataOutputStream(outputStream);
    Set resultSetNameSet = ResultSetUtil.getRsColumnRequestMap(cacheRequestMap);
    try {
        int rowCount = this.resultObjects.length;
        int colCount = this.rsMeta.getFieldCount();
        IOUtil.writeInt(dos, rowCount);
        for (int i = 0; i < rowCount; i++) {
            ResultSetUtil.writeResultObject(dos, resultObjects[i], colCount, resultSetNameSet);
        }
        dos.close();
    } catch (IOException e) {
        throw new DataException(ResourceConstants.RD_SAVE_ERROR, e);
    }
}

Output:
         for (int i = 0; i < rowCount; i++) {
-            ResultSetUtil.writeResultObject(dos, resultObjects[i], colCount, resultSetNameSet);
+            IOUtil.writeLong(rowLensStream, offset);
+            offset += ResultSetUtil.writeResultObject(dos, resultObjects[i], colCount, resultSetNameSet);
         }


Input:
private boolean resend() {
    reSendCount++;
    if (reSendCount > MAX_RESEND_COUNT) {
        return false;
    }
    executionService.execute(new ReSendTask());
    return true;
}

Output:
 private boolean resend() {
-    reSendCount++;
-    if (reSendCount > MAX_RESEND_COUNT) {
+    if (reSendCount.incrementAndGet() > MAX_RESEND_COUNT) {
         return false;


Input:
protected boolean loadedFromEclipseLinkXML() {
    if (loadedFromXML()) {
        return getLocation().toString().contains(MetadataHelper.ECLIPSELINK_ORM_FILE);
    }
    return false;
}

Output:
     if (loadedFromXML()) {
-        return getLocation().toString().contains(MetadataHelper.ECLIPSELINK_ORM_FILE);
+        return m_entityMappings.isEclipseLinkORMFile();
     }


Input:
public void init(String[] players) {
    float ypos = MARGIN;
    TextFormat titleFormat = new TextFormat().withFont(graphics().createFont("String_Node_Str", Font.Style.BOLD, 24));
    Font nameFont = graphics().createFont("String_Node_Str", Font.Style.PLAIN, 16);
    TextFormat nameFormat = new TextFormat().withFont(nameFont);
    TextFormat numberFormat = new TextFormat().withFont(nameFont).withAlignment(TextFormat.Alignment.RIGHT);
    TextGlyph title = TextGlyph.forText("String_Node_Str", titleFormat);
    title.layer.setTranslation(MARGIN, ypos);
    layer.add(title.layer);
    ypos += title.layer.canvas().height();
    _turnHolder = graphics().createCanvasLayer(WIDTH, PLAYER_HEIGHT);
    _turnHolder.canvas().setFillColor(0xFF99CCFF);
    _turnHolder.canvas().fillRect(0, 0, WIDTH, PLAYER_HEIGHT);
    layer.add(_turnHolder);
    _turnHolder.setVisible(false);
    _playersY = ypos;
    _piecens = new TextGlyph[players.length];
    _scores = new TextGlyph[players.length];
    int pidx = 0;
    for (String player : players) {
        TextGlyph score = (_scores[pidx] = TextGlyph.forTemplate("String_Node_Str", numberFormat));
        TextGlyph piecens = (_piecens[pidx] = TextGlyph.forTemplate("String_Node_Str", numberFormat));
        ImageLayer piecen = Atlantis.media.getPiecenTile(pidx++);
        int hgap = 4, vgap = 4, nameWidth = WIDTH - 2 * MARGIN - Media.PIECEN_WIDTH - score.layer.canvas().width() - piecens.layer.canvas().width() - 3 * hgap;
        TextGlyph name = TextGlyph.forWidth(nameWidth, nameFormat);
        name.setText(player);
        float xpos = MARGIN;
        name.layer.setTranslation(xpos, ypos + vgap / 2);
        xpos += nameWidth + hgap;
        piecen.setTranslation(xpos + Media.PIECEN_WIDTH / 2, ypos + PLAYER_HEIGHT / 2 - 2);
        xpos += Media.PIECEN_WIDTH + hgap;
        piecens.layer.setTranslation(xpos, ypos + vgap / 2);
        xpos += piecens.layer.canvas().width() + hgap;
        score.layer.setTranslation(xpos, ypos + vgap / 2);
        layer.add(name.layer);
        layer.add(piecen);
        layer.add(piecens.layer);
        layer.add(score.layer);
        ypos += Media.PIECEN_HEIGHT + vgap;
    }
    ypos += MARGIN;
    _remaining = TextGlyph.forTemplate("String_Node_Str", nameFormat);
    _remaining.layer.setTranslation(MARGIN, ypos);
    layer.add(_remaining.layer);
    ypos += _remaining.layer.canvas().height();
    ypos += MARGIN / 2;
    _nextLabel = TextGlyph.forText("String_Node_Str", nameFormat);
    _nextLabel.layer.setTranslation(MARGIN, ypos);
    layer.add(_nextLabel.layer);
    _nextLabel.layer.setVisible(false);
    ypos += _nextLabel.layer.canvas().height();
    _nextTileY = ypos;
    ypos += Media.TERRAIN_HEIGHT;
    ypos += MARGIN;
    CanvasLayer bg = graphics().createCanvasLayer(WIDTH, (int) Math.ceil(ypos));
    bg.canvas().setFillColor(0xFFCCCCCC);
    bg.canvas().fillRect(0, 0, WIDTH, ypos);
    layer.add(0, bg);
}

Output:
     bg.canvas().fillRect(0, 0, WIDTH, ypos);
-    layer.add(0, bg);
+    bg.setDepth(-1);
+    layer.add(bg);
 }


Input:
private Map<QName, Serializable> getMissingProperties(Map<QName, Serializable> existingProperties, Set<QName> classQNames) {
    Map<QName, Serializable> allDefaultProperties = new HashMap<QName, Serializable>(17);
    for (QName classQName : classQNames) {
        ClassDefinition classDefinition = dictionaryService.getClass(classQName);
        if (classDefinition == null) {
            continue;
        }
        Map<QName, Serializable> defaultProperties = getDefaultProperties(classQName);
        if (defaultProperties.size() > 0) {
            allDefaultProperties.putAll(defaultProperties);
        }
    }
    Map<QName, Serializable> missingProperties = new HashMap<QName, Serializable>(allDefaultProperties);
    missingProperties.entrySet().removeAll(existingProperties.entrySet());
    return missingProperties;
}

Output:
     Map<QName, Serializable> missingProperties = new HashMap<QName, Serializable>(allDefaultProperties);
-    missingProperties.entrySet().removeAll(existingProperties.entrySet());
+    missingProperties.keySet().removeAll(existingProperties.keySet());
     return missingProperties;


Input:
public void execute(Tuple input) {
    try {
        int speed = input.getIntegerByField(Field.SPEED);
        int bearing = input.getIntegerByField(Field.BEARING);
        double latitude = input.getDoubleByField(Field.LATITUDE);
        double longitude = input.getDoubleByField(Field.LONGITUDE);
        if (speed <= 0)
            return;
        if (longitude > lonMin || longitude < lonMax || latitude > latMin || latitude < latMax)
            return;
        GPSRecord record = new GPSRecord(longitude, latitude, speed, bearing);
        int roadID = sectors.fetchRoadID(record);
        if (roadID != -1) {
            List<Object> values = input.getValues();
            values.add(roadID);
            collector.emit(values);
        }
        collector.ack(input);
    } catch (SQLException ex) {
        LOG.error("String_Node_Str", ex);
    }
}

Output:
             return;
-        if (longitude > lonMin || longitude < lonMax || latitude > latMin || latitude < latMax)
+        if (longitude > lonMax || longitude < lonMin || latitude > latMax || latitude < latMin)
             return;


Input:
private void emitColumnAssignment(JavaWriter javaWriter, String valueStatement) throws IOException {
    boolean isContainerFieldDefinition = accessModel.isModelContainerAdapter;
    boolean fieldIsAModelContainer = accessModel.fieldIsAModelContainer;
    boolean isNull = valueStatement.equals("String_Node_Str");
    AdapterQueryBuilder queryBuilder = new AdapterQueryBuilder();
    if (isModelContainerAdapter) {
        if (accessModel.isForeignKeyField) {
            queryBuilder.append(modelContainerName);
        } else {
            queryBuilder.append(ModelUtils.getVariable(true));
        }
    } else {
        queryBuilder.appendVariable(isContainerFieldDefinition);
    }
    if (fieldIsAModelContainer && isModelContainerAdapter) {
        queryBuilder.appendPut(accessModel.getReferencedColumnFieldName());
    } else if (fieldIsAModelContainer) {
        queryBuilder.append("String_Node_Str").append(accessModel.columnFieldName).appendPut(accessModel.getReferencedColumnFieldName());
    } else if (isModelContainerAdapter && accessModel.isForeignKeyField) {
        queryBuilder.appendPut(accessModel.getReferencedColumnFieldName());
    }
    if (isContainerFieldDefinition) {
        queryBuilder.appendPut(accessModel.containerKeyName);
    } else if (!fieldIsAModelContainer && !isModelContainerAdapter) {
        queryBuilder.append("String_Node_Str").append(accessModel.getSetterReferenceColumnFieldName());
        if (!accessModel.isPrivate) {
            queryBuilder.appendSpaceSeparated("String_Node_Str");
        }
    }
    if (accessModel.isEnum) {
        if (!isNull) {
            queryBuilder.append(accessModel.castedClass).append("String_Node_Str");
        }
    } else {
        if (accessModel.requiresTypeConverter && !isNull) {
            queryBuilder.appendTypeConverter(accessModel.columnFieldBoxedType, accessModel.columnFieldBoxedType, true);
        } else if (accessModel.isABlob) {
            queryBuilder.append(String.format("String_Node_Str", Blob.class.getName()));
        }
    }
    queryBuilder.append(valueStatement);
    if (accessModel.requiresTypeConverter && !isNull && !accessModel.isEnum || (accessModel.isEnum && isContainerFieldDefinition && !isNull)) {
        queryBuilder.append("String_Node_Str");
    } else if (isModelContainerAdapter || isContainerFieldDefinition || fieldIsAModelContainer || accessModel.isABlob || (accessModel.isEnum && !isNull)) {
        queryBuilder.append("String_Node_Str");
    }
    if (accessModel.isPrivate && !isContainerFieldDefinition) {
        queryBuilder.append("String_Node_Str");
    }
    if (accessModel.requiresTypeConverter && !accessModel.isEnum() && isModelContainerAdapter && !isNull) {
        queryBuilder.append("String_Node_Str");
    }
    javaWriter.emitStatement(queryBuilder.toString());
}

Output:
     }
-    if (accessModel.requiresTypeConverter && !accessModel.isEnum() && isModelContainerAdapter && !isNull) {
+    if ((accessModel.requiresTypeConverter) && !accessModel.isEnum() && isModelContainerAdapter && !isNull || isModelContainerAdapter && accessModel.isABlob) {
         queryBuilder.append("String_Node_Str");


Input:
public void testTopologicalEvents() throws IOException, InterruptedException {
    final BlockingQueue<TopologicalEvent> eventsQueue = new LinkedBlockingQueue<>();
    yamlLoggger(() -> {
        try {
            YamlLogging.writeMessage("String_Node_Str" + "String_Node_Str");
            Subscriber<TopologicalEvent> subscription = eventsQueue::add;
            clientAssetTree.registerSubscriber("String_Node_Str", TopologicalEvent.class, subscription);
            {
                TopologicalEvent take = eventsQueue.poll(1, SECONDS);
                Assert.assertEquals(ExistingAssetEvent.of(null, "String_Node_Str"), take);
            }
            {
                clientAssetTree.acquireMap("String_Node_Str" + NAME, String.class, String.class).size();
                {
                    TopologicalEvent take = eventsQueue.poll(1, SECONDS);
                    Assert.assertEquals(ExistingAssetEvent.of("String_Node_Str", "String_Node_Str"), take);
                }
                {
                    TopologicalEvent take = eventsQueue.poll(1, SECONDS);
                    Assert.assertEquals(AddedAssetEvent.of("String_Node_Str", "String_Node_Str"), take);
                }
                {
                    TopologicalEvent take = eventsQueue.poll(1, SECONDS);
                    Assert.assertEquals(AddedAssetEvent.of("String_Node_Str", NAME), take);
                }
            }
            {
                serverAssetTree.acquireMap("String_Node_Str" + NAME + 2, String.class, String.class);
                TopologicalEvent take3 = eventsQueue.poll(1, SECONDS);
                Assert.assertEquals(AddedAssetEvent.of("String_Node_Str", NAME + 2), take3);
            }
            {
                serverAssetTree.acquireAsset("String_Node_Str").removeChild(NAME);
                TopologicalEvent take4 = eventsQueue.poll(1, SECONDS);
                Assert.assertEquals(RemovedAssetEvent.of("String_Node_Str", NAME), take4);
            }
            clientAssetTree.unregisterSubscriber(NAME, subscription);
        } catch (Exception e) {
            throw Jvm.rethrow(e);
        }
    });
}

Output:
                 TopologicalEvent take = eventsQueue.poll(1, SECONDS);
-                Assert.assertEquals(ExistingAssetEvent.of(null, "String_Node_Str"), take);
+                Assert.assertEquals(ExistingAssetEvent.of(null, "String_Node_Str", Collections.emptySet()), take);
             }


Input:
public void handleMessage(Message msg) {
    friendListAdapter = new FriendListAdapter(FriendList.this, friends);
    friendListView = (ListView) findViewById(R.id.friend_list);
    friendListView.setAdapter(friendListAdapter);
    downloadProfilePictures_async();
    dialog.cancel();
}

Output:
 public void handleMessage(Message msg) {
-    friendListAdapter = new FriendListAdapter(FriendList.this, friends);
-    friendListView = (ListView) findViewById(R.id.friend_list);
-    friendListView.setAdapter(friendListAdapter);
+    friendListAdapter.notifyDataSetChanged();
     downloadProfilePictures_async();


Input:
protected static void baseRemove(HandlerManager manager, EventListener listener, Type... keys) {
    if (manager != null) {
        for (Type key : keys) {
            int handlerCount = manager.getHandlerCount(key);
            for (int i = 0; i < handlerCount; i++) {
                EventHandler handler = manager.getHandler(key, i);
                if (handler instanceof ListenerWrapper && ((ListenerWrapper) handler).listener.equals(listener)) {
                    manager.removeHandler(key, handler);
                }
            }
        }
    }
}

Output:
     if (manager != null) {
-        for (Type key : keys) {
+        for (Type<H> key : keys) {
             int handlerCount = manager.getHandlerCount(key);


Input:
public MediaDirection getDirection() {
    return direction == null ? MediaDirection.SENDRECV : direction;
}

Output:
 public MediaDirection getDirection() {
-    return direction == null ? MediaDirection.SENDRECV : direction;
+    return (direction == null) ? MediaDirection.SENDRECV : direction;
 }


Input:
public void run() {
    List<String> jvmOpts = new ArrayList<String>();
    if (!parent.getConfig().getProperty("String_Node_Str", "String_Node_Str").isEmpty()) {
        jvmOpts = Arrays.asList(parent.getConfig().getProperty("String_Node_Str").split("String_Node_Str"));
    }
    String javaBin = "String_Node_Str";
    File binDir;
    if (System.getProperty("String_Node_Str").startsWith("String_Node_Str")) {
        binDir = new Path(new File(jrePath)).resolve("String_Node_Str").toFile();
    } else {
        binDir = new Path(new File(jrePath)).resolve("String_Node_Str").toFile();
    }
    if (binDir.exists()) {
        javaBin = new Path(binDir).resolve("String_Node_Str").toString();
    }
    List<String> args = new ArrayList<String>();
    if (!parent.getConfig().getProperty("String_Node_Str", "String_Node_Str").isEmpty()) {
        args.add(parent.getConfig().getProperty("String_Node_Str"));
    }
    args.add(javaBin);
    args.add("String_Node_Str");
    args.add("String_Node_Str");
    args.add("String_Node_Str");
    if (System.getProperty("String_Node_Str").startsWith("String_Node_Str")) {
        args.add("String_Node_Str" + server.getName());
    }
    args.addAll(jvmOpts);
    args.add("String_Node_Str" + this.minMem);
    args.add("String_Node_Str" + this.maxMem);
    args.add("String_Node_Str");
    args.add(MCUpdater.getJarFile().toString());
    args.add("String_Node_Str");
    args.add(session.getUserName());
    args.add(session.getSessionId());
    args.add(server.getName());
    args.add(MCUpdater.getInstance().getInstanceRoot().resolve(server.getServerId()).toString());
    args.add(MCUpdater.getInstance().getInstanceRoot().resolve(server.getServerId()).resolve("String_Node_Str").toString());
    args.add((server.getIconUrl().equals("String_Node_Str")) ? "String_Node_Str" : server.getIconUrl());
    args.add(parent.getConfig().getProperty("String_Node_Str"));
    args.add(parent.getConfig().getProperty("String_Node_Str"));
    args.add(server.getAddress());
    if (!Version.isMasterBranch()) {
        parent.log("String_Node_Str");
        Iterator<String> itArgs = args.iterator();
        while (itArgs.hasNext()) {
            String entry = itArgs.next();
            parent.log(entry);
        }
    }
    ProcessBuilder pb = new ProcessBuilder(args);
    parent.baseLogger.fine("String_Node_Str" + System.getProperty("String_Node_Str"));
    if (System.getProperty("String_Node_Str").startsWith("String_Node_Str")) {
        if (new Path(new File(jrePath)).resolve("String_Node_Str").resolve("String_Node_Str").toFile().exists()) {
            pb.environment().put("String_Node_Str", new Path(new File(jrePath)).resolve("String_Node_Str").resolve("String_Node_Str").toString());
        } else {
            pb.environment().put("String_Node_Str", new Path(new File(jrePath)).resolve("String_Node_Str").resolve("String_Node_Str").toString());
        }
    }
    pb.redirectErrorStream(true);
    BufferedWriter buffWrite = null;
    try {
        buffWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(output)));
    } catch (FileNotFoundException e) {
        parent.baseLogger.log(Level.SEVERE, "String_Node_Str", e);
    }
    try {
        task = pb.start();
        BufferedReader buffRead = new BufferedReader(new InputStreamReader(task.getInputStream()));
        String line;
        buffRead.mark(1024);
        final String firstLine = buffRead.readLine();
        setReady();
        if (firstLine == null || firstLine.startsWith("String_Node_Str") || firstLine.startsWith("String_Node_Str")) {
            parent.baseLogger.severe("String_Node_Str");
            StringBuilder err = new StringBuilder(firstLine);
            while ((line = buffRead.readLine()) != null) {
                err.append('\n');
                err.append(line);
                parent.baseLogger.severe(line);
            }
            JOptionPane.showMessageDialog(null, err);
        } else {
            buffRead.reset();
            minimizeFrame();
            parent.baseLogger.info("String_Node_Str");
            int counter = 0;
            while ((line = buffRead.readLine()) != null) {
                if (buffWrite != null) {
                    buffWrite.write(line);
                    buffWrite.newLine();
                    counter++;
                    if (counter >= 20) {
                        buffWrite.flush();
                        counter = 0;
                    }
                } else {
                    parent.baseLogger.fine(line);
                }
                if (line.length() > 0) {
                    Style lineStyle = null;
                    if (line.contains("String_Node_Str")) {
                        lineStyle = console.warnStyle;
                    }
                    if (line.contains("String_Node_Str")) {
                        lineStyle = console.errorStyle;
                    }
                    console.log(line, lineStyle);
                    parent.baseLogger.info(line);
                }
            }
        }
        buffWrite.flush();
        buffWrite.close();
        restoreFrame();
        parent.baseLogger.info("String_Node_Str" + (forceKilled ? "String_Node_Str" : "String_Node_Str"));
    } catch (IOException ioe) {
        parent.baseLogger.log(Level.SEVERE, "String_Node_Str", ioe);
    }
}

Output:
                     }
-                    console.log(line, lineStyle);
-                    parent.baseLogger.info(line);
+                    console.log(line + "String_Node_Str", lineStyle);
                 }


Input:
void setIcon(IconTip iconTip) {
    synchronized (this) {
        this.iconTip = iconTip;
    }
    SwingUtilities.invokeLater(new Runnable() {

        public void run() {
            model.fireTreeNodesChanged(JobTreeNode.this);
        }
    });
}

Output:
     }
-    SwingUtilities.invokeLater(new Runnable() {
+    executor.execute(new Runnable() {


Input:
private void helpPressed() {
    Program.launch(Messages.getString("String_Node_Str"));
}

Output:
 private void helpPressed() {
-    Program.launch(Messages.getString("String_Node_Str"));
+    openURL(Messages.getString("String_Node_Str"));
 }


Input:
public boolean onPreferenceClick(Preference preference) {
    particleState = ((CheckBoxPreference) particlesPref).isChecked();
    musicState = ((CheckBoxPreference) musicPref).isChecked();
    soundState = ((CheckBoxPreference) soundsPref).isChecked();
    XmlWriter writer = new XmlWriter();
    writer.saveSettings(particleState, musicState, soundState);
    return true;
}

Output:
     soundState = ((CheckBoxPreference) soundsPref).isChecked();
-    XmlWriter writer = new XmlWriter();
+    Options.music = ((CheckBoxPreference) soundsPref).isChecked();
     writer.saveSettings(particleState, musicState, soundState);


Input:
private String fixGroupOrdinal(String ruleExpression, String targetExpression, List<ItemDataBean> itemData, EventCRFBean eventCrf) {
    String returnedRuleExpression = ruleExpression;
    if (getItemGroupOid(ruleExpression).equals(getItemGroupOid(targetExpression))) {
        if (getGroupOrdninalCurated(ruleExpression).equals("String_Node_Str") && !getGroupOrdninalCurated(targetExpression).equals("String_Node_Str")) {
            returnedRuleExpression = replaceGroupOidOrdinalInExpression(ruleExpression, Integer.valueOf(getGroupOrdninalCurated(targetExpression)));
        }
    } else {
        EventCRFBean theEventCrfBean = null;
        if (eventCrf != null) {
            theEventCrfBean = eventCrf;
        } else if (!itemData.isEmpty()) {
            theEventCrfBean = (EventCRFBean) getEventCRFDao().findByPK(itemData.get(0).getEventCRFId());
        } else {
            return returnedRuleExpression;
        }
        Integer itemId = itemData.isEmpty() ? getItemDao().findByOid(getItemOid(ruleExpression)).get(0).getId() : itemData.get(0).getItemId();
        ItemGroupMetadataBean itemGroupMetadataBean = (ItemGroupMetadataBean) getItemGroupMetadataDao().findByItemAndCrfVersion(itemId, theEventCrfBean.getCRFVersionId());
        if (isGroupRepeating(itemGroupMetadataBean) && getGroupOrdninalCurated(ruleExpression).equals("String_Node_Str")) {
            returnedRuleExpression = replaceGroupOidOrdinalInExpression(ruleExpression, Integer.valueOf(getGroupOrdninalCurated(targetExpression)));
        }
    }
    return returnedRuleExpression;
}

Output:
         }
-        Integer itemId = itemData.isEmpty() ? getItemDao().findByOid(getItemOid(ruleExpression)).get(0).getId() : itemData.get(0).getItemId();
+        Integer itemId = itemData.isEmpty() ? ((EntityBean) getItemDao().findByOid(getItemOid(ruleExpression)).get(0)).getId() : itemData.get(0).getItemId();
         ItemGroupMetadataBean itemGroupMetadataBean = (ItemGroupMetadataBean) getItemGroupMetadataDao().findByItemAndCrfVersion(itemId, theEventCrfBean.getCRFVersionId());


Input:
public void setState(final StepState state) {
    if (state == null)
        return;
    if (this.step.getType() == WorkflowStep.StepType.ROOT_STEP && state == StepState.WAITING)
        this.stepState = StepState.READY;
    else
        this.stepState = state;
    if (this.stepState == StepState.DONE)
        for (AbstractWorkflowStep step : this.stepsToInform) step.getStepStateObserver().updateStatus();
    step.getAbstractWorkflow().updateStepState(this.step);
    for (WorkflowStepObserver o : WorkflowStepObserverRegistry.getInstance().getObservers()) o.notifyStepState(this.step);
}

Output:
         return;
-    if (this.step.getType() == WorkflowStep.StepType.ROOT_STEP && state == StepState.WAITING)
-        this.stepState = StepState.READY;
-    else
-        this.stepState = state;
+    synchronized (this) {
+        if (this.step.getType() == WorkflowStep.StepType.ROOT_STEP && state == StepState.WAITING)
+            this.stepState = StepState.READY;
+        else
+            this.stepState = state;
+    }
     if (this.stepState == StepState.DONE)


Input:
private JMenu createDemosMenu(String menuTitle) {
    JMenu menu = new JMenu(menuTitle);
    Tree<MenuEntry> menuTree = myMain.getDemoMenu();
    if (menuTree == null) {
        VerticalGridLayout menuGrid = new VerticalGridLayout(MAX_MENU_ROWS, 0);
        menu.getPopupMenu().setLayout(menuGrid);
        String[] demoNames = myMain.getDemoNames();
        for (int i = 0; i < demoNames.length; i++) {
            JMenuItem item = makeMenuItem(demoNames[i], demoNames[i]);
            item.setToolTipText(myMain.getDemoClassName(demoNames[i]));
            menu.add(item);
        }
    } else {
        if (menuTree.getRootElement().getChildren().size() > MAX_MENU_ROWS) {
            VerticalGridLayout menuGrid = new VerticalGridLayout(MAX_MENU_ROWS, 0);
            menu.getPopupMenu().setLayout(menuGrid);
        }
        for (Node<MenuEntry> node : menuTree.getRootElement().getChildren()) {
            if (numModelEntries(node) > 0) {
                buildMenu(menu, node);
            }
        }
    }
    return menu;
}

Output:
         for (Node<MenuEntry> node : menuTree.getRootElement().getChildren()) {
-            if (numModelEntries(node) > 0) {
+            if (!isMenuEmpty(node)) {
                 buildMenu(menu, node);


Input:
public void setDefaultValue(Element romProp, String defaultValue) {
    NodeList list = romProp.getElementsByTagName("String_Node_Str");
    Element valueNode = null;
    if (list.getLength() == 0) {
        valueNode = document.createElement("String_Node_Str");
        romProp.appendChild(valueNode);
    } else
        valueNode = (Element) list.item(0);
    valueNode.setTextContent(defaultValue);
}

Output:
         valueNode = (Element) list.item(0);
-    valueNode.setTextContent(defaultValue);
+    valueNode.setNodeValue(defaultValue);
 }


Input:
protected void initView(Bundle savedInstanceState) {
    super.initView(savedInstanceState);
    setToolbarBackEnable();
    setToolbarTitle(getString(title));
    MarkdownEditorFragment editorFragment = MarkdownEditorFragment.create(text);
    markdownEditor = editorFragment;
    MarkdownPreviewFragment previewFragment = MarkdownPreviewFragment.create(markdownEditor);
    pagerAdapter.setPagerList(Arrays.asList(new FragmentPagerModel(getString(R.string.write), editorFragment), new FragmentPagerModel(getString(R.string.preview), previewFragment)));
    tabLayout.setVisibility(View.VISIBLE);
    tabLayout.setupWithViewPager(viewPager);
    viewPager.setAdapter(pagerAdapter);
}

Output:
     setToolbarTitle(getString(title));
-    MarkdownEditorFragment editorFragment = MarkdownEditorFragment.create(text);
-    markdownEditor = editorFragment;
-    MarkdownPreviewFragment previewFragment = MarkdownPreviewFragment.create(markdownEditor);
-    pagerAdapter.setPagerList(Arrays.asList(new FragmentPagerModel(getString(R.string.write), editorFragment), new FragmentPagerModel(getString(R.string.preview), previewFragment)));
+    pagerAdapter.setPagerList(FragmentPagerModel.createMarkdownEditorPagerList(getActivity(), text, getFragments()));
     tabLayout.setVisibility(View.VISIBLE);


Input:
private void dropKeyspaces() {
    List<KeyspaceDefinition> keyspaces = cluster.describeKeyspaces();
    for (KeyspaceDefinition keyspaceDefinition : keyspaces) {
        String keyspaceName = keyspaceDefinition.getName();
        if (!INTERNAL_CASSANDRA_KEYSPACE.equals(keyspaceName)) {
            cluster.dropKeyspace(keyspaceName);
        }
    }
    List<KeyspaceDefinition> keyspaces2 = cluster.describeKeyspaces();
}

Output:
         if (!INTERNAL_CASSANDRA_KEYSPACE.equals(keyspaceName)) {
-            cluster.dropKeyspace(keyspaceName);
+            cluster.dropKeyspace(keyspaceName, true);
         }


Input:
public int hashCode() {
    final List<String> list = stack.get();
    final int prime = 31;
    int result = 1;
    result = prime * result + ((list == null) ? 0 : list.hashCode());
    return result;
}

Output:
 public int hashCode() {
-    final List<String> list = stack.get();
+    final MutableThreadContextStack values = stack.get();
     final int prime = 31;


Input:
private Map getConfigVars() {
    HashMap configVars = new HashMap();
    String configFileName = getConfigFileName(this.getFileUri());
    if (configFileName == null)
        return configVars;
    ReportDesignHandle handle = null;
    try {
        SessionHandle sessionHandle = SessionHandleAdapter.getInstance().getSessionHandle();
        File configFile = new File(configFileName);
        if (configFile != null && configFile.exists() && configFile.isFile()) {
            handle = sessionHandle.openDesign(configFileName);
            if (handle != null) {
                Iterator it = handle.configVariablesIterator();
                while (it != null && it.hasNext()) {
                    ConfigVariableHandle configVar = (ConfigVariableHandle) it.next();
                    if (configVar != null && configVar.getName() != null) {
                        String paramName = getParameterName(configVar.getName());
                        ScalarParameterHandle parameter = findParameter(paramName);
                        if (parameter != null) {
                            String typeVarName = configVar.getName() + "String_Node_Str" + PROP_TYPE;
                            ConfigVariable typeVar = handle.findConfigVariable(typeVarName);
                            String dataType = null;
                            if (typeVar != null)
                                dataType = typeVar.getValue();
                            if (dataType == null || !dataType.equalsIgnoreCase(parameter.getDataType())) {
                                continue;
                            }
                        }
                        if (paramName != null && paramName.length() > 0) {
                            configVars.put(paramName, configVar.getValue());
                        }
                    }
                }
                handle.close();
            }
        }
    } catch (DesignFileException e) {
        e.printStackTrace();
        try {
            if (handle != null) {
                handle.close();
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
    return configVars;
}

Output:
                                 dataType = typeVar.getValue();
-                            if (dataType == null || !dataType.equalsIgnoreCase(parameter.getDataType())) {
+                            if (dataType == null || !dataType.equalsIgnoreCase(parameter.getDataType()))
+                                continue;
+                            String exprVarName = configVar.getName() + "String_Node_Str" + PROP_EXPR;
+                            ConfigVariable exprVar = handle.findConfigVariable(exprVarName);
+                            String expr = parameter.getValueExpr();
+                            String cachedExpr = null;
+                            if (exprVar != null)
+                                cachedExpr = exprVar.getValue();
+                            if (cachedExpr == null)
+                                cachedExpr = "String_Node_Str";
+                            if (expr == null)
+                                expr = "String_Node_Str";
+                            if (!cachedExpr.equals(expr))
                                 continue;


Input:
public void handleSelectionUpdate(SelectionDelta selectionDelta) {
    IDType recordIDType = dataDomain.getRecordIDType();
    if (selectionDelta.getIDType().getIDCategory().equals(recordIDType.getIDCategory())) {
        if (selectionDelta.getIDType() != recordIDType) {
            selectionDelta = DeltaConverter.convertDelta(dataDomain.getRecordIDMappingManager(), recordIDType, selectionDelta);
        }
        recordSelectionManager.setDelta(selectionDelta);
        updateTree(true, recordSelectionManager, contentTree);
    }
    if (selectionDelta.getIDType() == recordSelectionManager.getIDType()) {
    } else if (selectionDelta.getIDType() == dimensionSelectionManager.getIDType()) {
        dimensionSelectionManager.setDelta(selectionDelta);
        updateTree(false, dimensionSelectionManager, dimensionTree);
    }
}

Output:
         updateTree(true, recordSelectionManager, contentTree);
-    }
-    if (selectionDelta.getIDType() == recordSelectionManager.getIDType()) {
-    } else if (selectionDelta.getIDType() == dimensionSelectionManager.getIDType()) {
+    } else if (selectionDelta.getIDType().getIDCategory().equals(dimensionSelectionManager.getIDType().getIDCategory())) {
         dimensionSelectionManager.setDelta(selectionDelta);


Input:
protected void okPressed() {
    try {
        inputParameter.setName(nameEditor.getText());
        inputParameter.setPromptText(UIUtil.convertToModelString(promptTextEditor.getText(), true));
        String newControlType = getSelectedControlType();
        if (PARAM_CONTROL_COMBO.equals(newControlType)) {
            newControlType = DesignChoiceConstants.PARAM_CONTROL_LIST_BOX;
            inputParameter.setMustMatch(false);
        } else if (PARAM_CONTROL_LIST.equals(newControlType)) {
            newControlType = DesignChoiceConstants.PARAM_CONTROL_LIST_BOX;
            inputParameter.setMustMatch(true);
        } else {
            inputParameter.setProperty(ScalarParameterHandle.MUCH_MATCH_PROP, null);
        }
        inputParameter.setControlType(newControlType);
        if (DesignChoiceConstants.PARAM_TYPE_DATETIME.equals(getSelectedDataType())) {
            defaultValue = DEUtil.convertToXMLString(DataTypeUtil.toDate(defaultValue, ULocale.US));
        }
        inputParameter.setDefaultValue(defaultValue);
        inputParameter.setDataType(DATA_TYPE_CHOICE_SET.findChoiceByDisplayName(dataTypeChooser.getText()).getName());
        PropertyHandle selectionChioceList = inputParameter.getPropertyHandle(ScalarParameterHandle.SELECTION_LIST_PROP);
        selectionChioceList.setValue(null);
        if (isStatic()) {
            inputParameter.setValueType(DesignChoiceConstants.PARAM_VALUE_TYPE_STATIC);
            if (!DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(newControlType) && !DesignChoiceConstants.PARAM_CONTROL_CHECK_BOX.equals(newControlType)) {
                for (Iterator iter = choiceList.iterator(); iter.hasNext(); ) {
                    SelectionChoice choice = (SelectionChoice) iter.next();
                    if (isValidValue(choice.getValue()) == null) {
                        selectionChioceList.addItem(choice);
                    }
                }
            }
            inputParameter.setDataSetName(null);
            inputParameter.setValueExpr(null);
            inputParameter.setLabelExpr(null);
        } else {
            inputParameter.setValueType(DesignChoiceConstants.PARAM_VALUE_TYPE_DYNAMIC);
            inputParameter.setDataSetName(dataSetChooser.getText());
            inputParameter.setValueExpr(getExpression(columnChooser.getText()));
            if (displayTextChooser.getText().equals(LABEL_NULL)) {
                inputParameter.setLabelExpr("String_Node_Str");
            } else {
                inputParameter.setLabelExpr(getExpression(displayTextChooser.getText()));
            }
        }
        inputParameter.setHelpText(UIUtil.convertToModelString(helpTextEditor.getText(), false));
        inputParameter.setCategory(formatCategroy);
        inputParameter.setPattern(formatPattern);
        if (isStatic() && (PARAM_CONTROL_COMBO.equals(getSelectedControlType()) || DesignChoiceConstants.PARAM_CONTROL_RADIO_BUTTON.equals(getSelectedControlType())) && !containValue(null, defaultValue, COLUMN_VALUE)) {
            defaultValue = null;
        }
        if (dirtyProperties.containsKey(CHECKBOX_HIDDEN)) {
            inputParameter.setHidden(getProperty(CHECKBOX_HIDDEN));
        }
        if (dirtyProperties.containsKey(CHECKBOX_ISREQUIRED)) {
            inputParameter.setIsRequired(getProperty(CHECKBOX_ISREQUIRED));
        }
        if (doNotEcho.isEnabled()) {
            if (dirtyProperties.containsKey(CHECKBOX_DO_NOT_ECHO)) {
                inputParameter.setConcealValue(getProperty(CHECKBOX_DO_NOT_ECHO));
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.CONCEAL_VALUE_PROP, null);
        }
        if (sorttingArea != null && sorttingArea.isVisible()) {
            if (!sortKeyChooser.getText().equals(CHOICE_NONE)) {
                inputParameter.setFixedOrder(false);
                inputParameter.setDistinct(!distinct.getSelection());
                if (sortKeyChooser.getText().equals(CHOICE_DISPLAY_TEXT)) {
                    inputParameter.setSortBy(DesignChoiceConstants.PARAM_SORT_VALUES_LABEL);
                } else if (sortKeyChooser.getText().equals(CHOICE_VALUE_COLUMN)) {
                    inputParameter.setSortBy(DesignChoiceConstants.PARAM_SORT_VALUES_VALUE);
                }
                if (sortDirectionChooser.getText().equals(CHOICE_ASCENDING)) {
                    inputParameter.setSortDirection(DesignChoiceConstants.SORT_DIRECTION_ASC);
                } else if (sortDirectionChooser.getText().equals(CHOICE_DESCENDING)) {
                    inputParameter.setSortDirection(DesignChoiceConstants.SORT_DIRECTION_DESC);
                }
            } else {
                inputParameter.setFixedOrder(true);
                inputParameter.setSortBy(null);
                inputParameter.setSortDirection(null);
                inputParameter.setDistinct(false);
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.FIXED_ORDER_PROP, null);
        }
        if (!isStatic() && !StringUtil.isBlank(listLimit.getText())) {
            try {
                inputParameter.setListlimit(Integer.parseInt(listLimit.getText()));
            } catch (NumberFormatException ex) {
                ExceptionHandler.openErrorMessageBox(ERROR_TITLE_INVALID_LIST_LIMIT, MessageFormat.format(ERROR_MSG_INVALID_LIST_LIMIT, new Object[] { Integer.toString(Integer.MAX_VALUE) }));
            }
        } else {
            inputParameter.setProperty(ScalarParameterHandle.LIST_LIMIT_PROP, null);
        }
    } catch (Exception e) {
        ExceptionHandler.handle(e);
        return;
    }
    setResult(inputParameter);
    super.okPressed();
}

Output:
         }
-        if (sorttingArea != null && sorttingArea.isVisible()) {
+        if (sorttingArea != null && !sorttingArea.isDisposed() && sorttingArea.isVisible()) {
             if (!sortKeyChooser.getText().equals(CHOICE_NONE)) {


Input:
private void removeNativePlugins() {
    Iterator pluginIterator = nativePluginsTable.entrySet().iterator();
    Object constraints;
    while (pluginIterator.hasNext()) {
        Map.Entry<PluginComponent, Component> entry = (Map.Entry<PluginComponent, Component>) pluginIterator.next();
        PluginComponent pluginComponent = (PluginComponent) entry.getKey();
        Component c = (Component) entry.getValue();
        constraints = UIServiceImpl.getBorderLayoutConstraintsFromContainer(pluginComponent.getConstraints());
        if (constraints == null)
            constraints = BorderLayout.SOUTH;
        this.removePluginComponent(c, pluginComponent.getContainer(), constraints);
        this.getContentPane().repaint();
    }
}

Output:
     Object constraints;
-    while (pluginIterator.hasNext()) {
-        Map.Entry<PluginComponent, Component> entry = (Map.Entry<PluginComponent, Component>) pluginIterator.next();
-        PluginComponent pluginComponent = (PluginComponent) entry.getKey();
-        Component c = (Component) entry.getValue();
+    for (Map.Entry<PluginComponent, Component> entry : nativePluginsTable.entrySet()) {
+        PluginComponent pluginComponent = entry.getKey();
+        Component c = entry.getValue();
         constraints = UIServiceImpl.getBorderLayoutConstraintsFromContainer(pluginComponent.getConstraints());


Input:
public boolean sellShares(SellShares action) {
    Portfolio portfolio = operatingCompany.getPortfolio();
    String errMsg = null;
    String companyName = action.getCompanyName();
    PublicCompanyI company = companyManager.getPublicCompany(companyName);
    PublicCertificateI cert = null;
    List<PublicCertificateI> certsToSell = new ArrayList<PublicCertificateI>();
    int numberToSell = action.getNumberSold();
    int shareUnits = action.getShareUnits();
    while (true) {
        if (numberToSell <= 0) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        if (company == null) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        if (company != operatingCompany) {
            errMsg = LocalText.getText("String_Node_Str", companyName, operatingCompany.getName());
            break;
        }
        if (!company.hasFloated()) {
            errMsg = LocalText.getText("String_Node_Str", companyName);
            break;
        }
        if (company.mustHaveOperatedToTradeShares() && !company.hasOperated()) {
            errMsg = LocalText.getText("String_Node_Str", companyName);
            break;
        }
        if (hasSold.booleanValue()) {
            errMsg = LocalText.getText("String_Node_Str", companyName);
            break;
        }
        if (portfolio.getShare(company) < numberToSell) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        if (pool.getShare(company) + numberToSell * company.getShareUnit() > getGameParameterAsInt(GameDef.Parm.POOL_SHARE_LIMIT)) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        Iterator<PublicCertificateI> it = portfolio.getCertificatesPerCompany(companyName).iterator();
        while (numberToSell > 0 && it.hasNext()) {
            cert = it.next();
            if (shareUnits != cert.getShares()) {
                continue;
            }
            certsToSell.add(cert);
            numberToSell--;
        }
        if (numberToSell > 0) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        break;
    }
    int numberSold = action.getNumberSold();
    if (errMsg != null) {
        DisplayBuffer.add(LocalText.getText("String_Node_Str", companyName, numberSold, companyName, errMsg));
        return false;
    }
    StockSpaceI sellPrice;
    int price;
    if (sellPrices.containsKey(companyName)) {
        price = (sellPrices.get(companyName)).getPrice();
    } else {
        sellPrice = company.getCurrentSpace();
        price = sellPrice.getPrice();
        sellPrices.put(companyName, sellPrice);
    }
    moveStack.start(true);
    ReportBuffer.add(LocalText.getText("String_Node_Str", companyName, numberSold, company.getShareUnit(), (numberSold * company.getShareUnit()), companyName, Bank.format(numberSold * price)));
    for (PublicCertificateI cert2 : certsToSell) {
        if (cert2 != null) {
            executeTradeCertificate(cert2, pool, cert2.getShares() * price);
        }
    }
    stockMarket.sell(company, numberSold);
    hasSold.set(true);
    return true;
}

Output:
         }
-        if (hasSold.booleanValue()) {
+        if (hasBought.booleanValue()) {
             errMsg = LocalText.getText("String_Node_Str", companyName);


Input:
private int caculateBufferSize(IDatasetIterator iterator, String[][] keyColumnNames, String[] measureColumnNames) throws BirtException {
    int[][] levelKeyColumnDataType = new int[keyColumnNames.length][];
    int[] measureColumnType = new int[measureColumnNames.length];
    for (int i = 0; i < keyColumnNames.length; i++) {
        levelKeyColumnDataType[i] = new int[keyColumnNames[i].length];
        for (int j = 0; j < keyColumnNames[i].length; j++) {
            levelKeyColumnDataType[i][j] = iterator.getFieldType(keyColumnNames[i][j]);
        }
    }
    for (int i = 0; i < measureColumnType.length; i++) {
        measureColumnType[i] = iterator.getFieldType(measureColumnNames[i]);
    }
    int levelSize = 0;
    for (int i = 0; i < levelKeyColumnDataType.length; i++) {
        levelSize += getObjectSize(levelKeyColumnDataType[i]);
    }
    int measureSize = getObjectSize(measureColumnType);
    int rowSize = 16 + (4 + (levelSize + measureSize) - 1) / 8 * 8;
    return (int) (memoryCacheSize / rowSize);
}

Output:
     int rowSize = 16 + (4 + (levelSize + measureSize) - 1) / 8 * 8;
-    return (int) (memoryCacheSize / rowSize);
+    return (int) ((memoryCacheSize * 0.75) / rowSize);
 }


Input:
private ServiceMethodDefinition buildServiceMethodDefinition(ServiceMethodBean serviceMethodBean, ServiceMethod serviceMethod) {
    ServiceMethodDefinition definition = new ServiceMethodDefinition();
    definition.setMethodGroup(serviceMethodBean.group());
    definition.setMethodGroupTitle(serviceMethodBean.groupTitle());
    definition.setTags(serviceMethodBean.tags());
    definition.setTimeout(serviceMethodBean.timeout());
    definition.setIgnoreSign(IgnoreSignType.isIgnoreSign(serviceMethodBean.ignoreSign()));
    definition.setVersion(serviceMethodBean.version());
    definition.setNeedInSession(NeedInSessionType.isNeedInSession(serviceMethodBean.needInSession()));
    definition.setHttpAction(serviceMethodBean.httpAction());
    definition.setObsoleted(ObsoletedType.isObsoleted(serviceMethodBean.obsoleted()));
    definition.setMethod(serviceMethod.method());
    definition.setMethodTitle(serviceMethod.title());
    if (!ServiceMethodDefinition.DEFAULT_GROUP.equals(serviceMethod.group())) {
        definition.setMethodGroup(serviceMethod.group());
    }
    if (!ServiceMethodDefinition.DEFAULT_GROUP_TITLE.equals(serviceMethod.groupTitle())) {
        definition.setMethodGroupTitle(serviceMethod.groupTitle());
    }
    if (serviceMethod.tags() != null && serviceMethod.tags().length > 0) {
        definition.setTags(serviceMethod.tags());
    }
    if (serviceMethod.timeout() != definition.getTimeout()) {
        definition.setTimeout(serviceMethod.timeout());
    }
    if (serviceMethod.ignoreSign() != IgnoreSignType.DEFAULT) {
        definition.setIgnoreSign(IgnoreSignType.isIgnoreSign(serviceMethod.ignoreSign()));
    }
    if (StringUtils.hasText(serviceMethod.version())) {
        definition.setVersion(serviceMethod.version());
    }
    if (serviceMethod.needInSession() != NeedInSessionType.DEFAULT) {
        definition.setNeedInSession(NeedInSessionType.isNeedInSession(serviceMethod.needInSession()));
    }
    if (serviceMethod.obsoleted() != ObsoletedType.DEFAULT) {
        definition.setObsoleted(ObsoletedType.isObsoleted(serviceMethod.obsoleted()));
    }
    if (serviceMethod.httpAction().length > 0) {
        definition.setHttpAction(serviceMethod.httpAction());
    }
    return definition;
}

Output:
     }
-    if (serviceMethod.timeout() != definition.getTimeout()) {
+    if (serviceMethod.timeout() > 0) {
         definition.setTimeout(serviceMethod.timeout());


Input:
public boolean isValid(final PropagationTask object, final ConstraintValidatorContext context) {
    boolean isValid;
    if (object == null) {
        isValid = true;
    } else {
        isValid = object.getPropagationMode() != null && object.getResourceOperationType() != null && !object.getAttributes().isEmpty() && object.getResource() != null;
        if (isValid) {
            List<TaskExec> executions = object.getExecs();
            for (TaskExec execution : executions) {
                try {
                    PropagationTaskExecStatus.valueOf(execution.getStatus());
                } catch (IllegalArgumentException e) {
                    LOG.error("String_Node_Str" + execution.getStatus() + "String_Node_Str", e);
                    isValid = false;
                }
            }
        }
        if (!isValid) {
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(EntityViolationType.InvalidPropagationTask.toString()).addConstraintViolation();
        }
    }
    return isValid;
}

Output:
     } else {
-        isValid = object.getPropagationMode() != null && object.getResourceOperationType() != null && !object.getAttributes().isEmpty() && object.getResource() != null;
+        isValid = object.getPropagationMode() != null && object.getResourceOperationType() != null && !object.getAttributes().isEmpty() && object.getResource() != null && (PropagationOperation.DELETE == object.getResourceOperationType() || object.getSyncopeUser() != null);
         if (isValid) {


Input:
private void setSubRangeOfRange(boolean select, int changeIndex0, int changeIndex1, int invertIndex0, int invertIndex1) {
    if (changeIndex0 >= flagList.size() || changeIndex1 >= flagList.size() || ((changeIndex0 == -1 || changeIndex1 == -1) && changeIndex0 != changeIndex1)) {
        throw new ArrayIndexOutOfBoundsException("String_Node_Str" + changeIndex0 + "String_Node_Str" + changeIndex1 + "String_Node_Str" + flagList.size());
    }
    if (invertIndex0 >= flagList.size() || invertIndex1 >= flagList.size() || ((invertIndex0 == -1 || invertIndex1 == -1) && invertIndex0 != invertIndex1)) {
        throw new ArrayIndexOutOfBoundsException("String_Node_Str" + invertIndex0 + "String_Node_Str" + invertIndex1 + "String_Node_Str" + flagList.size());
    }
    if (changeIndex0 == -1 && changeIndex1 == -1) {
        if (invertIndex0 == -1 && invertIndex1 == -1)
            return;
        changeIndex0 = invertIndex0;
        changeIndex1 = invertIndex1;
        select = !select;
    }
    if (invertIndex0 == -1 && invertIndex1 == -1) {
        invertIndex0 = changeIndex0;
        invertIndex1 = changeIndex1;
    }
    int minChangeIndex = Math.min(changeIndex0, changeIndex1);
    int maxChangeIndex = Math.max(changeIndex0, changeIndex1);
    int minInvertIndex = Math.min(invertIndex0, invertIndex1);
    int maxInvertIndex = Math.max(invertIndex0, invertIndex1);
    int minUnionIndex = Math.min(minChangeIndex, minInvertIndex);
    int maxUnionIndex = Math.max(maxChangeIndex, maxInvertIndex);
    int minChangedIndex = maxUnionIndex + 1;
    int maxChangedIndex = minUnionIndex - 1;
    updates.beginEvent();
    for (int i = minUnionIndex; i <= maxUnionIndex; i++) {
        boolean selectedBefore = (flagList.get(i) != null);
        boolean inChangeRange = (i >= minChangeIndex && i <= maxChangeIndex);
        boolean selectedAfter = (inChangeRange == select);
        if (selectedBefore != selectedAfter) {
            if (i < minChangedIndex)
                minChangedIndex = i;
            if (i > maxChangedIndex)
                maxChangedIndex = i;
            if (selectedBefore) {
                int selectionIndex = flagList.getCompressedIndex(i);
                flagList.set(i, null);
                updates.addDelete(selectionIndex);
            } else {
                flagList.set(i, Boolean.TRUE);
                int selectionIndex = flagList.getCompressedIndex(i);
                updates.addInsert(selectionIndex);
            }
        }
    }
    updates.commitEvent();
    if (minChangedIndex <= maxChangedIndex)
        fireSelectionChanged(minChangedIndex, maxChangedIndex);
}

Output:
     if (changeIndex0 >= flagList.size() || changeIndex1 >= flagList.size() || ((changeIndex0 == -1 || changeIndex1 == -1) && changeIndex0 != changeIndex1)) {
-        throw new ArrayIndexOutOfBoundsException("String_Node_Str" + changeIndex0 + "String_Node_Str" + changeIndex1 + "String_Node_Str" + flagList.size());
+        throw new IndexOutOfBoundsException("String_Node_Str" + changeIndex0 + "String_Node_Str" + changeIndex1 + "String_Node_Str" + flagList.size());
     }


Input:
protected TypeReference[][] makeParameterTypes(IMethod method) throws IllegalArgumentException {
    if (method == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    TypeReference[][] result = new TypeReference[method.getNumberOfParameters()][];
    for (int i = 0; i < result.length; i++) {
        TypeReference t = method.getParameterType(i);
        if (!t.isPrimitiveType()) {
            IClass klass = cha.lookupClass(t);
            if (klass == null) {
                t = null;
            } else if (klass.isAbstract()) {
                t = chooseAConcreteSubClass(klass);
            } else if (klass.isInterface()) {
                t = chooseAnImplementor(klass);
            } else if (klass.isArrayClass()) {
                ArrayClass arrayKlass = (ArrayClass) klass;
                IClass innermost = arrayKlass.getInnermostElementClass();
                if (innermost != null && innermost.isInterface()) {
                    TypeReference impl = chooseAnImplementor(innermost);
                    if (impl == null) {
                        t = null;
                    } else {
                        t = TypeReference.findOrCreateArrayOf(impl);
                        for (int dim = 1; dim < arrayKlass.getDimensionality(); dim++) {
                            t = TypeReference.findOrCreateArrayOf(t);
                        }
                    }
                }
            }
        }
        result[i] = (t == null) ? new TypeReference[0] : new TypeReference[] { t };
    }
    return result;
}

Output:
                 t = null;
-            } else if (klass.isAbstract()) {
+            } else if (!klass.isInterface() && klass.isAbstract()) {
                 t = chooseAConcreteSubClass(klass);


Input:
public void onClickPositive(String local_username, String password) {
    if (username.isEmpty()) {
        Toast.makeText(this, "String_Node_Str", Toast.LENGTH_LONG).show();
        return;
    }
    UserStructure userStructure = new UserStructure();
    userStructure.setUsername(local_username);
    userStructure.setPassword(password);
    if (add_update) {
        saveCredential(userStructure);
    } else {
        updateCredentials(userStructure);
    }
    dialogAlert.dismiss();
}

Output:
 public void onClickPositive(String local_username, String password) {
-    if (username.isEmpty()) {
+    if (local_username.isEmpty()) {
+        Toast.makeText(this, "String_Node_Str", Toast.LENGTH_LONG).show();
+        return;
+    }
+    if (password.isEmpty()) {
         Toast.makeText(this, "String_Node_Str", Toast.LENGTH_LONG).show();


Input:
public Pool createPool(Pool pool) {
    Pool created = poolCurator.create(pool);
    log.debug("String_Node_Str", pool);
    if (created != null) {
        sink.emitPoolCreated(created);
    }
    return created;
}

Output:
 public Pool createPool(Pool pool) {
-    Pool created = poolCurator.create(pool);
-    log.debug("String_Node_Str", pool);
-    if (created != null) {
-        sink.emitPoolCreated(created);
+    if (pool != null) {
+        if (pool.getId() == null) {
+            pool = this.poolCurator.create(pool);
+            log.debug("String_Node_Str", pool);
+            if (pool != null) {
+                sink.emitPoolCreated(pool);
+            }
+        } else {
+            pool = this.poolCurator.merge(pool);
+            log.debug("String_Node_Str", pool);
+        }
     }