Input:
public void shouldScheduleFourDayRecallJobs_StartDateIsToday() {
    DayOfWeek dayOfWeek = DayOfWeek.Friday;
    int numDaysToRetry = 2;
    patient.getPatientPreferences().setDayOfWeeklyCall(dayOfWeek);
    when(properties.getProperty(TAMAConstants.FOUR_DAY_RECALL_DAYS_TO_RETRY)).thenReturn(String.valueOf(numDaysToRetry));
    schedulerService.scheduleJobsForFourDayRecall(patient, treatmentAdvice);
    ArgumentCaptor<CronSchedulableJob> cronSchedulableJobArgumentCaptor = ArgumentCaptor.forClass(CronSchedulableJob.class);
    verify(motechSchedulerService, times(numDaysToRetry + 1)).scheduleJob(cronSchedulableJobArgumentCaptor.capture());
    List<CronSchedulableJob> cronSchedulableJobList = cronSchedulableJobArgumentCaptor.getAllValues();
    assertCronSchedulableJob(cronSchedulableJobList.get(0), "String_Node_Str", TREATMENT_ADVICE_START_DATE.plusDays(4).toDate(), TREATMENT_ADVICE_END_DATE.toDate());
    assertCronSchedulableJob(cronSchedulableJobList.get(1), "String_Node_Str", TREATMENT_ADVICE_START_DATE.plusDays(5).toDate(), TREATMENT_ADVICE_END_DATE.toDate());
    assertCronSchedulableJob(cronSchedulableJobList.get(2), "String_Node_Str", TREATMENT_ADVICE_START_DATE.plusDays(6).toDate(), TREATMENT_ADVICE_END_DATE.toDate());
}

Output:
     ArgumentCaptor<CronSchedulableJob> cronSchedulableJobArgumentCaptor = ArgumentCaptor.forClass(CronSchedulableJob.class);
-    verify(motechSchedulerService, times(numDaysToRetry + 1)).scheduleJob(cronSchedulableJobArgumentCaptor.capture());
+    verify(motechSchedulerService, times(numDaysToRetry + 1 + 1)).scheduleJob(cronSchedulableJobArgumentCaptor.capture());
     List<CronSchedulableJob> cronSchedulableJobList = cronSchedulableJobArgumentCaptor.getAllValues();


Input:
protected void createScreenTexture() {
    int[] pix = new int[width * height];
    for (int i = 0; i < width * height; i++) pix[i] = 0xFF000000;
    gl.glGenTextures(1, screenTexID, 0);
    gl.glBindTexture(GL10.GL_TEXTURE_2D, screenTexID[0]);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
    gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, GL10.GL_RGBA, width, height, 0, GL10.GL_RGBA, GL10.GL_UNSIGNED_BYTE, IntBuffer.wrap(pix));
    gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);
    int fw = toFixed32(width);
    int fh = toFixed32(height);
    int one = toFixed32(1.0f);
    int[] quadCoords = { 0, fh, 0, 0, 0, 0, fw, 0, 0, 0, fh, 0, fw, 0, 0, fw, fh, 0 };
    int[] quadTexCoords = { 0, one, 0, 0, one, 0, 0, one, one, 0, one, one };
    screenVertBuffer.position(0);
    screenTexCoordBuffer.position(0);
    screenVertBuffer.put(quadCoords);
    screenTexCoordBuffer.put(quadTexCoords);
    screenTex = parent.createImage(width, height, ARGB);
    screenTex.getTexture().set(pix);
}

Output:
     int[] pix = new int[width * height];
-    for (int i = 0; i < width * height; i++) pix[i] = 0xFF000000;
-    gl.glGenTextures(1, screenTexID, 0);
-    gl.glBindTexture(GL10.GL_TEXTURE_2D, screenTexID[0]);
-    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
-    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
-    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
-    gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
-    gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, GL10.GL_RGBA, width, height, 0, GL10.GL_RGBA, GL10.GL_UNSIGNED_BYTE, IntBuffer.wrap(pix));
-    gl.glBindTexture(GL10.GL_TEXTURE_2D, 0);
-    int fw = toFixed32(width);
-    int fh = toFixed32(height);
-    int one = toFixed32(1.0f);
-    int[] quadCoords = { 0, fh, 0, 0, 0, 0, fw, 0, 0, 0, fh, 0, fw, 0, 0, fw, fh, 0 };
-    int[] quadTexCoords = { 0, one, 0, 0, one, 0, 0, one, one, 0, one, one };
-    screenVertBuffer.position(0);
-    screenTexCoordBuffer.position(0);
-    screenVertBuffer.put(quadCoords);
-    screenTexCoordBuffer.put(quadTexCoords);
-    screenTex = parent.createImage(width, height, ARGB);
+    for (int i = 0; i < width * height; i++) pix[i] = 0xFF0000;
+    screenTex = parent.createImage(width, height, ARGB, GLConstants.NEAREST);
     screenTex.getTexture().set(pix);


Input:
public MethodWrapper addMethod(MethodNode mn) {
    MethodWrapper node = new MethodWrapper(this, mn);
    getMethods().add(node);
    return node;
}

Output:
     MethodWrapper node = new MethodWrapper(this, mn);
-    getMethods().add(node);
+    getMethodMap().put(mn.name + mn.desc, node);
     return node;


Input:
public Object[] getFieldValues() {
    ArrayList fields = new ArrayList();
    fields.add(new Integer(startIndex));
    fields.add(new Integer(endIndex));
    if (sortKeys != null) {
        fields.add(new Integer(sortKeys.length));
        for (int i = 0; i < sortKeys.length; i++) fields.add(sortKeys[i]);
    } else {
        fields.add(null);
    }
    if (sortDirections != null) {
        fields.add(new Integer(sortDirections.length));
        for (int i = 0; i < sortDirections.length; i++) fields.add(new Boolean(sortDirections[i]));
    } else {
        fields.add(null);
    }
    if (this.comparator != null) {
        fields.add(new Integer(comparator.length));
        for (int i = 0; i < comparator.length; i++) fields.add(new Integer(comparator[i].getStrength()));
    } else {
        fields.add(null);
    }
    fields.add(new Boolean(accept));
    return fields.toArray();
}

Output:
         fields.add(new Integer(comparator.length));
-        for (int i = 0; i < comparator.length; i++) fields.add(new Integer(comparator[i].getStrength()));
+        for (int i = 0; i < comparator.length; i++) fields.add(comparator[i] == null ? ISortDefinition.ASCII_SORT_STRENGTH : new Integer(comparator[i].getStrength()));
     } else {


Input:
public void onBootPhase(int phase) {
    if (phase == PHASE_SYSTEM_SERVICES_READY) {
        synchronized (this) {
            mPm = getLocalService(PowerManagerInternal.class);
            mNumProfiles = mPm.getFeature(POWER_FEATURE_SUPPORTED_PROFILES);
            Slog.d(TAG, "String_Node_Str" + mNumProfiles);
            if (mNumProfiles > 0) {
                int profile = CMSettings.Secure.getInt(mContext.getContentResolver(), CMSettings.Secure.PERFORMANCE_PROFILE, PerformanceManager.PROFILE_BALANCED);
                if (profile == PerformanceManager.PROFILE_HIGH_PERFORMANCE) {
                    profile = PerformanceManager.PROFILE_BALANCED;
                }
                setPowerProfileInternal(profile, true);
                mPm.registerLowPowerModeObserver(mLowPowerModeListener);
            }
        }
    }
}

Output:
             if (mNumProfiles > 0) {
-                int profile = CMSettings.Secure.getInt(mContext.getContentResolver(), CMSettings.Secure.PERFORMANCE_PROFILE, PerformanceManager.PROFILE_BALANCED);
+                int profile = getUserProfile();
                 if (profile == PerformanceManager.PROFILE_HIGH_PERFORMANCE) {


Input:
private static void offerAssociation() {
    boolean offered = Configuration.offeredAssociation.get();
    if (!offered) {
        if (Platform.isWindows()) {
            if ((!ContextMenuTools.isAddedToContextMenu()) && View.showConfirmDialog(null, "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION) {
                ContextMenuTools.addToContextMenu(true);
            }
        }
    }
    Configuration.offeredAssociation.set(true);
}

Output:
             if ((!ContextMenuTools.isAddedToContextMenu()) && View.showConfirmDialog(null, "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION) {
-                ContextMenuTools.addToContextMenu(true);
+                ContextMenuTools.addToContextMenu(true, false);
             }


Input:
public Snip post(Snip weblog, String content, Date date) {
    String name = Snip.toName(date);
    Snip snip = null;
    if (exists(name)) {
        snip = load(name);
        snip.setContent(snip.getContent() + "String_Node_Str" + content);
    } else {
        snip = create(name, content);
    }
    snip.setParent(weblog);
    snip.addPermission(Permissions.EDIT, Roles.OWNER);
    store(snip);
    WeblogsPing.ping(snip);
    return snip;
}

Output:
     store(snip);
-    WeblogsPing.ping(snip);
+    WeblogsPing.ping(weblog);
     return snip;


Input:
public void clearLock() {
    if (lock != null) {
        lock.clear();
    }
}

Output:
 public void clearLock() {
-    if (lock != null) {
-        lock.clear();
-    }
+    lock = null;
 }


Input:
private URI getConfigURI(final String location) {
    try {
        String configLocation = location;
        if (configLocation == null) {
            final String[] paths = SetUtils.prefixSet(servletContext.getResourcePaths("String_Node_Str"), "String_Node_Str");
            if (paths.length == 1) {
                configLocation = paths[0];
            } else if (paths.length > 1) {
                final String prefix = "String_Node_Str" + this.name + "String_Node_Str";
                final boolean found = false;
                for (final String str : paths) {
                    if (str.startsWith(prefix)) {
                        configLocation = str;
                        break;
                    }
                }
                if (!found) {
                    configLocation = paths[0];
                }
            }
        }
        if (configLocation != null) {
            final URL url = servletContext.getResource(configLocation);
            if (url != null) {
                return url.toURI();
            }
        }
    } catch (final Exception ex) {
    }
    if (location != null) {
        try {
            return FileUtils.getCorrectedFilePathUri(location);
        } catch (final Exception e) {
            this.servletContext.log("String_Node_Str" + location + "String_Node_Str", e);
        }
    }
    return null;
}

Output:
                 final String prefix = "String_Node_Str" + this.name + "String_Node_Str";
-                final boolean found = false;
+                boolean found = false;
                 for (final String str : paths) {


Input:
public void onResidenceRemoved(ResidenceRemovedEvent event) {
    try {
        Block signBlock = nation.getResidenceManager(event.getResidence()).getSign();
        Sign sign = (Sign) signBlock.getState();
        for (int index = 0; index < 4; ++index) {
            sign.setLine(index, "String_Node_Str");
        }
    } catch (NullPointerException e) {
        plugin.severe("String_Node_Str", event.getResidence().getName());
    }
}

Output:
         }
-    } catch (NullPointerException e) {
+    } catch (ResidenceSignMissingException e) {
         plugin.severe("String_Node_Str", event.getResidence().getName());


Input:
private void parseRoot(Tree tree) throws SAXException {
    if (namespaces != null) {
        Map<String, String> namespacePairs = namespaces.getPrefixesToNamespaces();
        Iterator<String> keys = namespacePairs.keySet().iterator();
        while (keys.hasNext()) {
            String nextKey = keys.next();
            contentHandler.startPrefixMapping(nextKey, namespacePairs.get(nextKey));
        }
    }
    if (tree.getType() == JSONLexer.OBJECT) {
        contentHandler.startDocument();
        int children = tree.getChildCount();
        if (includeRoot) {
            parse((CommonTree) tree.getChild(0));
        } else {
            contentHandler.startElement(XMLConstants.EMPTY_STRING, XMLConstants.EMPTY_STRING, null, attributes.setTree(tree, attributePrefix, namespaces, namespaceSeparator, namespaceAware));
            for (int x = 0, size = tree.getChildCount(); x < size; x++) {
                parse((CommonTree) tree.getChild(x));
            }
            contentHandler.endElement(XMLConstants.EMPTY_STRING, XMLConstants.EMPTY_STRING, null);
        }
        contentHandler.endDocument();
    } else if (tree.getType() == JSONLexer.ARRAY) {
        int size = tree.getChildCount();
        List list = new ArrayList(size);
        for (int x = 0; x < size; x++) {
            parseRoot(tree.getChild(x));
            if (getContentHandler() instanceof SAXUnmarshallerHandler) {
                SAXUnmarshallerHandler saxUnmarshallerHandler = (SAXUnmarshallerHandler) contentHandler;
                list.add(saxUnmarshallerHandler.getObject());
                saxUnmarshallerHandler.setObject(null);
            } else if (getContentHandler() instanceof UnmarshalRecord) {
                UnmarshalRecord unmarshalRecord = (UnmarshalRecord) contentHandler;
                list.add(unmarshalRecord.getCurrentObject());
                unmarshalRecord.setCurrentObject(null);
            }
        }
        if (getContentHandler() instanceof SAXUnmarshallerHandler) {
            ((SAXUnmarshallerHandler) getContentHandler()).setObject(list);
        } else if (getContentHandler() instanceof UnmarshalRecord) {
            ((UnmarshalRecord) getContentHandler()).setCurrentObject(list);
        }
    }
}

Output:
                 UnmarshalRecord unmarshalRecord = (UnmarshalRecord) contentHandler;
-                list.add(unmarshalRecord.getCurrentObject());
+                Object unmarshalledObject = unmarshalRecord.getCurrentObject();
+                if (includeRoot && unmarshalClass != null) {
+                    XMLRoot xmlRoot = new XMLRoot();
+                    xmlRoot.setNamespaceURI(unmarshalRecord.getRootElementNamespaceUri());
+                    xmlRoot.setLocalName(unmarshalRecord.getLocalName());
+                    xmlRoot.setObject(unmarshalledObject);
+                    unmarshalledObject = xmlRoot;
+                }
+                list.add(unmarshalledObject);
                 unmarshalRecord.setCurrentObject(null);


Input:
public boolean hasNext() {
    if (currentBase == null) {
        if (neighborhood_one.hasNext()) {
            return true;
        } else
            return false;
    } else {
        if (neighborhood_Two.hasNext()) {
            return true;
        } else {
            if (neighborhood_one.hasNext()) {
                return true;
            } else
                return false;
        }
    }
}

Output:
 public boolean hasNext() {
-    if (currentBase == null) {
-        if (neighborhood_one.hasNext()) {
-            return true;
-        } else
-            return false;
-    } else {
-        if (neighborhood_Two.hasNext()) {
-            return true;
-        } else {
-            if (neighborhood_one.hasNext()) {
-                return true;
-            } else
-                return false;
+    if (currentNeighborhood != null) {
+        while (!currentNeighborhood.hasNext() && !newNeighborhood) {
+            nIndex--;
+            newNeighborhood = false;
+            if (nIndex < 0)
+                break;
+            currentNeighborhood = neighborhoods.get(nIndex);
         }


Input:
public static DatabaseConnection fillDbConnectionInformation(DatabaseConnection dbConn) {
    if (DatabaseConstant.XML_EXIST_DRIVER_NAME.equals(dbConn.getDriverClass())) {
        IXMLDBConnection xmlDBConnection = new EXistXMLDBConnection(dbConn.getDriverClass(), dbConn.getURL());
        ConnectionHelper.addXMLDocuments(xmlDBConnection.createConnection(), dbConn);
    } else {
        try {
            boolean noStructureExists = ConnectionHelper.getAllCatalogs(dbConn).isEmpty() && ConnectionHelper.getAllSchemas(dbConn).isEmpty();
            if (noStructureExists) {
                dbConn = (DatabaseConnection) TalendCwmFactory.createDataProvider(createDBConnect(dbConn, false));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (TalendException e) {
            e.printStackTrace();
        }
    }
    return dbConn;
}

Output:
         IXMLDBConnection xmlDBConnection = new EXistXMLDBConnection(dbConn.getDriverClass(), dbConn.getURL());
-        ConnectionHelper.addXMLDocuments(xmlDBConnection.createConnection(), dbConn);
+        ConnectionHelper.addXMLDocuments(xmlDBConnection.createConnection(dbConn));
     } else {


Input:
public void execute(Tuple tuple) {
    if (CtrlAction.boltHandlerEntrance(this, tuple))
        return;
    logger.trace("String_Node_Str", flowCache);
    ComponentType componentId = ComponentType.valueOf(tuple.getSourceComponent());
    String correlationId = Utils.DEFAULT_CORRELATION_ID;
    StreamType streamId = null;
    String flowId = null;
    if (!componentId.equals(ComponentType.LCM_FLOW_SYNC_BOLT)) {
        streamId = StreamType.valueOf(tuple.getSourceStreamId());
        flowId = tuple.getStringByField(Utils.FLOW_ID);
    }
    try {
        logger.debug("String_Node_Str", tuple);
        switch(componentId) {
            case SPLITTER_BOLT:
                Message msg = (Message) tuple.getValueByField(AbstractTopology.MESSAGE_FIELD);
                correlationId = msg.getCorrelationId();
                CommandMessage cmsg = (msg instanceof CommandMessage) ? (CommandMessage) msg : null;
                InfoMessage imsg = (msg instanceof InfoMessage) ? (InfoMessage) msg : null;
                logger.info("String_Node_Str", Utils.CORRELATION_ID, correlationId, Utils.FLOW_ID, flowId, componentId, streamId);
                switch(streamId) {
                    case CREATE:
                        handleCreateRequest(cmsg, tuple);
                        break;
                    case UPDATE:
                        handleUpdateRequest(cmsg, tuple);
                        break;
                    case DELETE:
                        handleDeleteRequest(flowId, cmsg, tuple);
                        break;
                    case PUSH:
                        handlePushRequest(flowId, imsg, tuple);
                        break;
                    case UNPUSH:
                        handleUnpushRequest(flowId, imsg, tuple);
                        break;
                    case PATH:
                        handlePathRequest(flowId, cmsg, tuple);
                        break;
                    case RESTORE:
                        handleRestoreRequest(cmsg, tuple);
                        break;
                    case REROUTE:
                        handleRerouteRequest(cmsg, tuple);
                        break;
                    case STATUS:
                        handleStatusRequest(flowId, cmsg, tuple);
                        break;
                    case CACHE_SYNC:
                        handleCacheSyncRequest(cmsg, tuple);
                        break;
                    case READ:
                        if (flowId != null) {
                            handleReadRequest(flowId, cmsg, tuple);
                        } else {
                            handleDumpRequest(cmsg, tuple);
                        }
                        break;
                    default:
                        logger.debug("String_Node_Str", componentId, streamId);
                        break;
                }
                break;
            case SPEAKER_BOLT:
            case TRANSACTION_BOLT:
                FlowState newStatus = (FlowState) tuple.getValueByField(FlowTopology.STATUS_FIELD);
                logger.info("String_Node_Str", flowId, newStatus, componentId, streamId);
                switch(streamId) {
                    case STATUS:
                        handleStateRequest(flowId, newStatus, tuple);
                        break;
                    default:
                        logger.debug("String_Node_Str", componentId, streamId);
                        break;
                }
                break;
            case TOPOLOGY_ENGINE_BOLT:
                ErrorMessage errorMessage = (ErrorMessage) tuple.getValueByField(AbstractTopology.MESSAGE_FIELD);
                logger.info("String_Node_Str", flowId, componentId, streamId);
                switch(streamId) {
                    case STATUS:
                        handleErrorRequest(flowId, errorMessage, tuple);
                        break;
                    default:
                        logger.debug("String_Node_Str", componentId, streamId);
                        break;
                }
                break;
            case LCM_FLOW_SYNC_BOLT:
                logger.debug("String_Node_Str");
                NetworkInfoData networkDump = (NetworkInfoData) tuple.getValueByField(LcmFlowCacheSyncBolt.FIELD_ID_NETWORK_DUMP);
                handleFlowSync(networkDump);
                break;
            default:
                logger.debug("String_Node_Str", componentId);
                break;
        }
    } catch (CacheException exception) {
        String logMessage = format("String_Node_Str", exception.getErrorMessage(), exception.getErrorDescription());
        logger.error("String_Node_Str", logMessage, Utils.CORRELATION_ID, correlationId, Utils.FLOW_ID, flowId, componentId, streamId, exception);
        ErrorMessage errorMessage = buildErrorMessage(correlationId, exception.getErrorType(), logMessage, componentId.toString().toLowerCase());
        Values error = new Values(errorMessage, exception.getErrorType());
        outputCollector.emit(StreamType.ERROR.toString(), tuple, error);
    } catch (IOException exception) {
        logger.error("String_Node_Str", tuple, exception);
    } catch (Exception e) {
        logger.error(String.format("String_Node_Str", getClass().getName()), e);
    } finally {
        logger.debug("String_Node_Str", tuple.getSourceComponent(), tuple.getSourceStreamId(), tuple);
        outputCollector.ack(tuple);
    }
    logger.trace("String_Node_Str", flowCache);
}

Output:
         logger.debug("String_Node_Str", tuple.getSourceComponent(), tuple.getSourceStreamId(), tuple);
-        outputCollector.ack(tuple);
+        if (isRecoverable) {
+            outputCollector.fail(tuple);
+        } else {
+            outputCollector.ack(tuple);
+        }
     }


Input:
public <T> T forwardTo(T controller) {
    return (T) forwardTo(CDIProxies.extractRawTypeIfPossible(controller.getClass()));
}

Output:
 public <T> T forwardTo(T controller) {
-    return (T) forwardTo(CDIProxies.extractRawTypeIfPossible(controller.getClass()));
+    return (T) forwardTo((Class<T>) extractRawTypeIfPossible(controller.getClass()));
 }


Input:
public void processCategories(Map<String, String> categories) throws InterruptedException, ExecutionException {
    logger.info("String_Node_Str");
    final ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    List<Future<Map<String, List<Long>>>> contentsFutures = new ArrayList<>();
    Transaction tx = graphDb.beginTx();
    for (Entry<String, String> category : categories.entrySet()) {
        ReadableIndex<Node> nodeIndex = graphDb.index().getNodeAutoIndexer().getAutoIndex();
        Node root = nodeIndex.get(CommonProperties.IRI, category.getKey()).getSingle();
        final Future<Map<String, List<Long>>> contentFuture = pool.submit(new CategoryProcessor(graphDb, root, category.getValue()));
        contentsFutures.add(contentFuture);
    }
    Map<String, List<Long>> toTag = new HashMap<String, List<Long>>();
    for (Future<Map<String, List<Long>>> contentFuture : contentsFutures) {
        final Map<String, List<Long>> resolved = contentFuture.get();
        toTag.putAll(resolved);
    }
    pool.shutdown();
    pool.awaitTermination(10, TimeUnit.DAYS);
    tx.success();
    tx.close();
    tx = graphDb.beginTx();
    for (Entry<String, List<Long>> t : toTag.entrySet()) {
        String category = t.getKey();
        logger.info("String_Node_Str" + t.getValue().size() + "String_Node_Str" + category);
        final ExecutorService taggingPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        List<Future<Boolean>> taggedFutures = new ArrayList<>();
        int partitionSize = 1000;
        List<List<Long>> partitions = new LinkedList<List<Long>>();
        for (int i = 0; i < t.getValue().size(); i += partitionSize) {
            partitions.add(t.getValue().subList(i, Math.min(i + partitionSize, t.getValue().size())));
        }
        for (List<Long> ids : partitions) {
            final Future<Boolean> contentFuture = taggingPool.submit(new CategoryLabeler(graphDb, ids, category));
            taggedFutures.add(contentFuture);
        }
        for (Future<Boolean> taggedFuture : taggedFutures) {
            taggedFuture.get();
        }
        taggingPool.shutdown();
        taggingPool.awaitTermination(10, TimeUnit.DAYS);
    }
    tx.success();
    tx.close();
}

Output:
         final Map<String, List<Long>> resolved = contentFuture.get();
-        toTag.putAll(resolved);
+        String key = resolved.keySet().iterator().next();
+        if (toTag.containsKey(key)) {
+            List<Long> acc = toTag.get(key);
+            acc.addAll(resolved.get(key));
+            toTag.put(key, acc);
+        } else {
+            toTag.putAll(resolved);
+        }
     }


Input:
public RootJid getRootJid(Mailbox mailbox, Actor parent) throws Exception {
    if (rootJid != null)
        return rootJid;
    rb = null;
    if (rootJidBytes == null)
        return null;
    RootJid rootJid = new RootJid(mailbox);
    rootJid.setParent(parent);
    rootJid.load(new ReadableBytes(rootJidBytes, 0));
    return rootJid;
}

Output:
         return null;
-    RootJid rootJid = new RootJid(mailbox);
+    rootJid = new RootJid(mailbox);
     rootJid.setParent(parent);


Input:
protected void onPreExecute() {
    super.onPreExecute();
    showLastMatch = showNextMatch = showRanks = showStats = false;
    activity.showMenuProgressBar();
    View view = mFragment.getView();
    eventName = (TextView) view.findViewById(R.id.event_name);
    eventDate = (TextView) view.findViewById(R.id.event_date);
    eventLoc = (TextView) view.findViewById(R.id.event_location);
    eventVenue = (TextView) view.findViewById(R.id.event_venue);
    nextLayout = (LinearLayout) view.findViewById(R.id.event_next_match_container);
    lastLayout = (LinearLayout) view.findViewById(R.id.event_last_match_container);
    topTeams = (LinearLayout) view.findViewById(R.id.event_top_teams_container);
    topOpr = (LinearLayout) view.findViewById(R.id.event_top_opr_container);
}

Output:
     lastLayout = (LinearLayout) view.findViewById(R.id.event_last_match_container);
-    topTeams = (LinearLayout) view.findViewById(R.id.event_top_teams_container);
-    topOpr = (LinearLayout) view.findViewById(R.id.event_top_opr_container);
+    topTeamsContainer = view.findViewById(R.id.event_top_teams_container);
+    topOprsContainer = view.findViewById(R.id.event_top_oprs_container);
+    topTeams = (TextView) view.findViewById(R.id.event_top_teams);
+    topOprs = (TextView) view.findViewById(R.id.event_top_oprs);
 }


Input:
public boolean isAnonymous(HashGroupifyEntry entry) {
    int[] buckets = entry.distribution.getBuckets();
    int totalElements = 0;
    for (int i = 0; i < buckets.length; i += 2) {
        if (buckets[i] != -1) {
            totalElements += buckets[i + 1];
        }
    }
    double val = 0d;
    for (int i = 0; i < buckets.length; i += 2) {
        if (buckets[i] != -1) {
            val += Math.abs((distribution[buckets[i]] - ((double) buckets[i + 1] / (double) totalElements)));
        }
    }
    val /= 2;
    return val <= t;
}

Output:
     }
-    double val = 0d;
+    double val = total;
     for (int i = 0; i < buckets.length; i += 2) {


Input:
public void initView() {
    refSWTContainer.setLayout(new FillLayout(SWT.VERTICAL));
    Label viewComboLabel = new Label(refSWTContainer, SWT.LEFT);
    viewComboLabel.setText("String_Node_Str");
    viewComboLabel.setSize(150, 30);
    final Combo viewCombo = new Combo(refSWTContainer, SWT.READ_ONLY);
    Label dataComboLabel = new Label(refSWTContainer, SWT.LEFT);
    dataComboLabel.setText("String_Node_Str");
    dataComboLabel.setSize(150, 30);
    final Combo dataCombo = new Combo(refSWTContainer, SWT.READ_ONLY);
    viewCombo.setSize(150, 30);
    viewCombo.setEnabled(true);
    dataCombo.setSize(150, 30);
    dataCombo.setEnabled(false);
    viewCombo.addFocusListener(new FocusAdapter() {
        public void focusGained(FocusEvent e) {
            if (bIsDataInitialized == true)
                return;
            fillCombos();
            viewCombo.removeAll();
            viewCombo.setItems(viewComboItems);
            dataCombo.setEnabled(true);
            bIsDataInitialized = true;
        }
    });
    viewCombo.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            fillDataSets(viewCombo, dataCombo);
            viewCombo.select(viewCombo.getSelectionIndex());
        }
    });
    dataCombo.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            int iSelectedViewDataSetId = StringConversionTool.convertStringToInt(arSetIDs.get(dataCombo.getSelectionIndex()), 0);
            hashComboText2View.get(arFilteredViews.get(viewCombo.getSelectionIndex())).setDataSetId(iSelectedViewDataSetId);
            bIsDataInitialized = false;
        }
    });
}

Output:
 public void initView() {
-    refSWTContainer.setLayout(new FillLayout(SWT.VERTICAL));
+    refSWTContainer.setLayout(new RowLayout(SWT.VERTICAL));
     Label viewComboLabel = new Label(refSWTContainer, SWT.LEFT);


Input:
private boolean doProcess(ClusterInstanceActivatedEvent event, Topology topology) {
    String applicationId = event.getAppId();
    String serviceName = event.getServiceName();
    String clusterId = event.getClusterId();
    if (TopologyApplicationFilter.apply(applicationId)) {
        return false;
    }
    if (TopologyServiceFilter.apply(serviceName)) {
        return false;
    }
    if (TopologyClusterFilter.apply(clusterId)) {
        return false;
    }
    Service service = topology.getService(event.getServiceName());
    if (service == null) {
        if (log.isWarnEnabled()) {
            log.warn(String.format("String_Node_Str", event.getServiceName()));
        }
        return false;
    }
    Cluster cluster = service.getCluster(event.getClusterId());
    if (cluster == null) {
        if (log.isDebugEnabled()) {
            log.debug(String.format("String_Node_Str", event.getServiceName(), event.getClusterId()));
            return false;
        }
    } else {
        cluster.addAccessUrlList(event.getInstanceId(), event.getAccessUrls());
        cluster.addLoadBalancerIps(event.getLoadBalancerIps());
        ClusterInstance context = cluster.getInstanceContexts(event.getInstanceId());
        if (context == null) {
            log.warn("String_Node_Str" + event.getClusterId() + "String_Node_Str" + event.getInstanceId());
            return false;
        }
        ClusterStatus status = ClusterStatus.Active;
        if (!context.isStateTransitionValid(status)) {
            log.error("String_Node_Str" + context.getStatus() + "String_Node_Str" + status);
        }
        context.setStatus(status);
    }
    notifyEventListeners(event);
    return true;
}

Output:
     } else {
-        cluster.addAccessUrlList(event.getInstanceId(), event.getAccessUrls());
-        cluster.addLoadBalancerIps(event.getLoadBalancerIps());
-        ClusterInstance context = cluster.getInstanceContexts(event.getInstanceId());
-        if (context == null) {
-            log.warn("String_Node_Str" + event.getClusterId() + "String_Node_Str" + event.getInstanceId());
+        ClusterInstance clusterInstance = cluster.getInstanceContexts(event.getInstanceId());
+        if (clusterInstance == null) {
+            log.warn(String.format("String_Node_Str", event.getAppId(), event.getClusterId(), event.getInstanceId()));
             return false;


Input:
protected ExactRelation rewriteWithPartition() {
    ExactRelation newSource = partitionedSource();
    List<SelectElem> scaledElems = new ArrayList<SelectElem>();
    List<TableUniqueName> stratifiedSampleTables = source.accumulateStratifiedSamples();
    List<ColNameExpr> groupby = new ArrayList<ColNameExpr>();
    if (source instanceof ApproxGroupedRelation) {
        groupby.addAll(((ApproxGroupedRelation) source).getGroupby());
    }
    for (SelectElem e : elems) {
        Expr scaled = transformForSingleFunctionWithPartitionSize(e.getExpr(), stratifiedSampleTables, groupby, newSource.partitionColumn());
        scaledElems.add(new SelectElem(scaled, e.getAlias()));
    }
    scaledElems.add(new SelectElem(FuncExpr.count(), partitionSizeAlias));
    ExactRelation r = new AggregatedRelation(vc, newSource, scaledElems);
    return r;
}

Output:
     List<SelectElem> scaledElems = new ArrayList<SelectElem>();
-    List<TableUniqueName> stratifiedSampleTables = source.accumulateStratifiedSamples();
+    List<ColNameExpr> samplingProbCols = newSource.accumulateSamplingProbColumns();
     List<ColNameExpr> groupby = new ArrayList<ColNameExpr>();


Input:
public void onServiceConnected(ComponentName cname, IBinder binder) {
    mInstallService = ((DownloadInstallService.LocalServiceBinder) binder).getService();
    mInstallButtonGuard = new InstallButtonGuard(mInstallButton, null, mInstallService);
}

Output:
     mInstallService = ((DownloadInstallService.LocalServiceBinder) binder).getService();
-    mInstallButtonGuard = new InstallButtonGuard(mInstallButton, null, mInstallService);
+    int pos = mListView.getSelectedItemPosition();
+    if (ListView.INVALID_POSITION != pos) {
+        String code = (String) mListView.getItemAtPosition(pos);
+        if (null != code) {
+            mInstallButtonGuard = new InstallButtonGuard(mInstallButton, mAppMap.get(code), mInstallService);
+        }
+    }
 }


Input:
public void mouseOver(Pick pick) {
    if (!node.isPickable())
        return;
    if (pathwayPathRenderer.isFirstNode((ALinearizableNode) node) || pathwayPathRenderer.isLastNode((ALinearizableNode) node)) {
        super.mouseOver(pick);
        showRemoveButton = true;
        pathwayPathRenderer.setDisplayListDirty();
    }
}

Output:
         showRemoveButton = true;
-        pathwayPathRenderer.setDisplayListDirty();
+        pathwayPathRenderer.setDisplayListDirty(true);
     }


Input:
public IntrospectionResponse introspect(String accessToken, String oxdId) {
    if (StringUtils.isBlank(accessToken)) {
        throw new ErrorResponseException(ErrorResponseCode.BLANK_PROTECTION_ACCESS_TOKEN);
    }
    final RpService rpService = ServerLauncher.getInjector().getInstance(RpService.class);
    final Rp rp = rpService.getRp(oxdId);
    if (StringUtils.isNotBlank(rp.getSetupOxdId())) {
        oxdId = rp.getSetupOxdId();
    }
    LOG.trace("String_Node_Str" + rpService.getRp(oxdId));
    final DiscoveryService discoveryService = ServerLauncher.getInjector().getInstance(DiscoveryService.class);
    final String introspectionEndpoint = discoveryService.getConnectDiscoveryResponseByOxdId(oxdId).getIntrospectionEndpoint();
    final UmaTokenService umaTokenService = ServerLauncher.getInjector().getInstance(UmaTokenService.class);
    final HttpService httpService = ServerLauncher.getInjector().getInstance(HttpService.class);
    final IntrospectionService introspectionService = ProxyFactory.create(IntrospectionService.class, introspectionEndpoint, httpService.getClientExecutor());
    IntrospectionResponse response = null;
    try {
        response = introspectionService.introspectToken("String_Node_Str" + umaTokenService.getPat(oxdId).getToken(), accessToken);
    } catch (ClientResponseFailure e) {
        int status = e.getResponse().getStatus();
        LOG.debug("String_Node_Str" + e.getResponse().getEntity(String.class) + "String_Node_Str" + status, e);
        if (status == 400 || status == 401) {
            LOG.debug("String_Node_Str");
            umaTokenService.obtainPat(oxdId);
            response = introspectionService.introspectToken("String_Node_Str" + umaTokenService.getPat(oxdId).getToken(), accessToken);
        } else {
            throw e;
        }
    }
    if (!response.isActive()) {
        LOG.debug("String_Node_Str");
        throw new ErrorResponseException(ErrorResponseCode.INACTIVE_PROTECTION_ACCESS_TOKEN);
    }
    return response;
}

Output:
     LOG.trace("String_Node_Str" + rpService.getRp(oxdId));
-    final DiscoveryService discoveryService = ServerLauncher.getInjector().getInstance(DiscoveryService.class);
-    final String introspectionEndpoint = discoveryService.getConnectDiscoveryResponseByOxdId(oxdId).getIntrospectionEndpoint();
-    final UmaTokenService umaTokenService = ServerLauncher.getInjector().getInstance(UmaTokenService.class);
-    final HttpService httpService = ServerLauncher.getInjector().getInstance(HttpService.class);
-    final IntrospectionService introspectionService = ProxyFactory.create(IntrospectionService.class, introspectionEndpoint, httpService.getClientExecutor());
-    IntrospectionResponse response = null;
-    try {
-        response = introspectionService.introspectToken("String_Node_Str" + umaTokenService.getPat(oxdId).getToken(), accessToken);
-    } catch (ClientResponseFailure e) {
-        int status = e.getResponse().getStatus();
-        LOG.debug("String_Node_Str" + e.getResponse().getEntity(String.class) + "String_Node_Str" + status, e);
-        if (status == 400 || status == 401) {
-            LOG.debug("String_Node_Str");
-            umaTokenService.obtainPat(oxdId);
-            response = introspectionService.introspectToken("String_Node_Str" + umaTokenService.getPat(oxdId).getToken(), accessToken);
-        } else {
-            throw e;
-        }
-    }
+    final IntrospectionService introspectionService = ServerLauncher.getInjector().getInstance(IntrospectionService.class);
+    final IntrospectionResponse response = introspectionService.introspectToken(oxdId, accessToken);
     if (!response.isActive()) {


Input:
public void testInternalDifferentiation() throws IntegratorException, DerivativeException {
    FirstOrderIntegrator integ = new DormandPrince54Integrator(1.0e-8, 100.0, 1.0e-4, 1.0e-4);
    double hP = 1.0e-12;
    SummaryStatistics residuals0 = new SummaryStatistics();
    SummaryStatistics residuals1 = new SummaryStatistics();
    for (double b = 2.88; b < 3.08; b += 0.001) {
        Brusselator brusselator = new Brusselator(b);
        brusselator.setParameter(0, b);
        double[] z = { 1.3, b };
        double[][] dZdZ0 = new double[2][2];
        double[][] dZdP = new double[2][1];
        double hY = 1.0e-12;
        FirstOrderIntegratorWithJacobians extInt = new FirstOrderIntegratorWithJacobians(integ, brusselator, new double[] { b }, new double[] { hY, hY }, new double[] { hP });
        extInt.integrate(0, z, new double[][] { { 0.0 }, { 1.0 } }, 20.0, z, dZdZ0, dZdP);
        residuals0.addValue(dZdP[0][0] - brusselator.dYdP0());
        residuals1.addValue(dZdP[1][0] - brusselator.dYdP1());
    }
    Assert.assertTrue((residuals0.getMax() - residuals0.getMin()) < 0.006);
    Assert.assertTrue(residuals0.getStandardDeviation() < 0.0009);
    Assert.assertTrue((residuals1.getMax() - residuals1.getMin()) < 0.006);
    Assert.assertTrue(residuals1.getStandardDeviation() < 0.0012);
}

Output:
     double hP = 1.0e-12;
-    SummaryStatistics residuals0 = new SummaryStatistics();
-    SummaryStatistics residuals1 = new SummaryStatistics();
+    SummaryStatistics residualsP0 = new SummaryStatistics();
+    SummaryStatistics residualsP1 = new SummaryStatistics();
     for (double b = 2.88; b < 3.08; b += 0.001) {


Input:
public void run() {
    if (stop)
        return;
    if (npc == null || player == null || eplayer.activeContainer == eplayer.defaultContainer) {
        kill();
        return;
    }
    if (mode == Mode.STOCK)
        return;
    if (player.getHandle().inventory.j() == null)
        return;
    stop = true;
    int count = 0;
    boolean found = false;
    for (ItemStack i : npc.getInventory().getContents()) {
        if (!previousNPCInv.getItem(count).equals(i) && previousNPCInv.getItem(count).getTypeId() == eplayer.inventory.j().id) {
            found = true;
            handleItemClicked((Player) npc.getPlayer(), count, false);
            break;
        }
        count += 1;
    }
    count = 0;
    if (!found) {
        for (ItemStack i : player.getInventory().getContents()) {
            if (!previousPlayerInv.getItem(count).equals(i) && previousPlayerInv.getItem(count).getTypeId() == eplayer.inventory.j().id) {
                handleItemClicked(player, count, true);
                break;
            }
            count += 1;
        }
    }
    clonePlayerInventory(npc.getInventory(), this.previousNPCInv);
    clonePlayerInventory(player.getInventory(), this.previousPlayerInv);
    eplayer.inventory.b((net.minecraft.server.ItemStack) null);
    Packet103SetSlot packet = new Packet103SetSlot(-1, -1, null);
    eplayer.netServerHandler.sendPacket(packet);
    stop = false;
}

Output:
             found = true;
-            handleItemClicked((Player) npc.getPlayer(), count, false);
+            handleNPCItemClicked(count, npc.getInventory());
             break;


Input:
public org.hl7.fhir.dstu2.model.Encounter.EncounterLocationComponent convertEncounterLocationComponent(org.hl7.fhir.dstu3.model.Encounter.EncounterLocationComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.Encounter.EncounterLocationComponent tgt = new org.hl7.fhir.dstu2.model.Encounter.EncounterLocationComponent();
    copyElement(src, tgt);
    tgt.setLocation(convertReference(src.getLocation()));
    tgt.setStatus(convertEncounterLocationStatus(src.getStatus()));
    tgt.setPeriod(convertPeriod(src.getPeriod()));
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.Encounter.EncounterLocationComponent convertEncounterLocationComponent(org.hl7.fhir.dstu3.model.Encounter.EncounterLocationComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public boolean isVisible() {
    IElementDefn elementDefn = getElementHandle().getDefn();
    return elementDefn.isPropertyVisible(propDefn.getName());
}

Output:
     IElementDefn elementDefn = getElementHandle().getDefn();
-    return elementDefn.isPropertyVisible(propDefn.getName());
+    if (elementDefn.isPropertyVisible(propDefn.getName()))
+        return true;
+    if (propDefn.isUserProperty())
+        return true;
+    return false;
 }


Input:
public ActionableResult rollback() throws Exception {
    Optional<Object> optionalOriginal = data.get(DataQueries.OriginalBlock);
    if (!optionalOriginal.isPresent()) {
        return ActionableResult.skipped(SkipReason.INVALID);
    }
    DataView finalBlock = ((DataView) optionalOriginal.get()).copy();
    Optional<Object> optionalLocation = data.get(DataQueries.Location);
    if (!optionalLocation.isPresent()) {
        return ActionableResult.skipped(SkipReason.INVALID_LOCATION);
    }
    finalBlock = formatBlockData(finalBlock, optionalLocation);
    Optional<BlockSnapshot> optionalSnapshot = Prism.getGame().getRegistry().createBuilder(Builder.class).build(finalBlock);
    if (!optionalSnapshot.isPresent()) {
        return ActionableResult.skipped(SkipReason.INVALID);
    }
    BlockSnapshot snapshot = optionalSnapshot.get();
    if (BlockUtil.rejectIllegalApplierBlock(snapshot.getState().getType())) {
        return ActionableResult.skipped(SkipReason.ILLEGAL_BLOCK);
    }
    BlockSnapshot original = snapshot.getLocation().get().getBlock().snapshotFor(snapshot.getLocation().get());
    if (!optionalSnapshot.get().restore(true, BlockChangeFlag.NONE)) {
        return ActionableResult.skipped(SkipReason.UNKNOWN);
    }
    BlockSnapshot resultingBlock = snapshot.getLocation().get().getBlock().snapshotFor(snapshot.getLocation().get());
    return ActionableResult.success(new Transaction<>(original, resultingBlock));
}

Output:
     }
-    BlockSnapshot original = snapshot.getLocation().get().getBlock().snapshotFor(snapshot.getLocation().get());
+    BlockSnapshot original = location.getBlock().snapshotFor(location);
     if (!optionalSnapshot.get().restore(true, BlockChangeFlag.NONE)) {


Input:
protected Control addWidget(Composite parent, Object value, PropertyDescriptor<?> desc, Rule rule) {
    final Spinner spinner = new Spinner(parent, SWT.SINGLE | SWT.BORDER);
    final NumericPropertyDescriptor<?> ip = numericPropertyFrom(desc);
    spinner.setMinimum(ip.lowerLimit().intValue());
    spinner.setMaximum(ip.upperLimit().intValue());
    setValue(spinner, value);
    return spinner;
}

Output:
 protected Control addWidget(Composite parent, Object value, PropertyDescriptor<?> desc, Rule rule) {
-    final Spinner spinner = new Spinner(parent, SWT.SINGLE | SWT.BORDER);
-    final NumericPropertyDescriptor<?> ip = numericPropertyFrom(desc);
-    spinner.setMinimum(ip.lowerLimit().intValue());
-    spinner.setMaximum(ip.upperLimit().intValue());
-    setValue(spinner, value);
-    return spinner;
+    NumericPropertyDescriptor<?> ip = numericPropertyFrom(desc);
+    return IntegerEditorFactory.newSpinner(parent, ip, value);
 }


Input:
public List<Project> getInactiveProjects() {
    ArrayList<Project> inactiveProjects = new ArrayList<Project>();
    for (Project p : projectList) {
        if (!p.isInactive()) {
            inactiveProjects.add(p);
        }
    }
    return inactiveProjects;
}

Output:
     for (Project p : projectList) {
-        if (!p.isInactive()) {
+        if (p.isInactive()) {
             inactiveProjects.add(p);


Input:
private AggregationBuilder buildAggregationBuilder(Collection<Selector> groupingSelectors, Integer limit, Integer internalLimit, ProjectParsed queryData) {
    OrderBy orderBy = queryData.getOrderBy();
    Select select = queryData.getSelect();
    Map<String, OrderByClause> orderByMap = getOrderByClauseMap(orderBy);
    AggregationBuilder aggregationBuilder = null;
    AggregationBuilder lastAggregationBuilder = null;
    for (Selector term : groupingSelectors) {
        String fieldName = SelectorUtils.getSelectorFieldName(term);
        if (aggregationBuilder == null) {
            lastAggregationBuilder = aggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
            if (limit != null) {
                ((TermsBuilder) lastAggregationBuilder).size(limit);
            }
            sortSubAggregation(fieldName, orderByMap, (TermsBuilder) lastAggregationBuilder);
        } else {
            lastAggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
            ((TermsBuilder) lastAggregationBuilder).size(internalLimit);
            sortSubAggregation(fieldName, orderByMap, (TermsBuilder) lastAggregationBuilder);
            aggregationBuilder.subAggregation(lastAggregationBuilder);
        }
    }
    if (aggregationBuilder != null) {
        addFunctionAggregation(select, orderByMap, lastAggregationBuilder);
    }
    return aggregationBuilder;
}

Output:
         } else {
-            lastAggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
+            AggregationBuilder newAggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
             ((TermsBuilder) lastAggregationBuilder).size(internalLimit);


Input:
public int hashCode() {
    int hashCode = 11;
    hashCode = hashCode * 37 + getGuid().hashCode();
    hashCode = hashCode * 37 + getBranchGuid().hashCode();
    return hashCode;
}

Output:
 public int hashCode() {
-    int hashCode = 11;
-    hashCode = hashCode * 37 + getGuid().hashCode();
-    hashCode = hashCode * 37 + getBranchGuid().hashCode();
-    return hashCode;
+    return super.hashCode();
 }


Input:
public void testGetFreeToPlayChampions() throws Exception {
    Thread.sleep(1500);
    assertNotNull(handler.getFreeToPlayChampions());
    assertEquals(handler.getFreeToPlayChampions().size(), 10);
}

Output:
 public void testGetFreeToPlayChampions() throws Exception {
-    Thread.sleep(1500);
-    assertNotNull(handler.getFreeToPlayChampions());
-    assertEquals(handler.getFreeToPlayChampions().size(), 10);
+    try {
+        Thread.sleep(1500);
+        assertNotNull(handler.getFreeToPlayChampions());
+        assertEquals(handler.getFreeToPlayChampions().size(), 10);
+    } catch (RequestException ex) {
+        System.out.println("String_Node_Str");
+        ex.printStackTrace();
+    }
 }


Input:
private DatabaseCall buildCallFromSelectStatementForLocator(SQLSelectStatement selectStatement, WriteObjectQuery writeQuery, DatabaseCall dbCall, AbstractSession session) {
    DatabaseCall call = selectStatement.buildCall(session);
    call.setIsNativeConnectionRequired(true);
    call.setContexts(dbCall.getContexts());
    call.returnOneRow();
    call.setQuery(writeQuery);
    call.prepare(session);
    call.translate(writeQuery.getTranslationRow(), writeQuery.getModifyRow(), session);
    return call;
}

Output:
     DatabaseCall call = selectStatement.buildCall(session);
-    call.setIsNativeConnectionRequired(true);
+    call.setIsNativeConnectionRequired(this.isNativeConnectionRequired);
     call.setContexts(dbCall.getContexts());


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

Output:
         }
-        return ((nameIsText && xPathFragment.nameIsText()) || (localName == xPathFragment.getLocalName()) || ((localName != null) && localName.equals(xPathFragment.getLocalName()))) && ((namespaceURI == xPathFragment.getNamespaceURI()) || ((namespaceURI != null) && namespaceURI.equals(xPathFragment.getNamespaceURI()))) && (this.indexValue == xPathFragment.getIndexValue()) && (nameIsText == xPathFragment.nameIsText());
+        if (isNamespaceAware && xPathFragment.isNamespaceAware) {
+            if (namespaceURI == null) {
+                if (xPathFragment.getNamespaceURI() != null) {
+                    return false;
+                }
+            } else {
+                if (xPathFragment.getNamespaceURI() == null) {
+                    return false;
+                } else if (namespaceURI != xPathFragment.getNamespaceURI() && !(namespaceURI.equals(xPathFragment.getNamespaceURI()))) {
+                    return false;
+                }
+            }
+        }
+        return ((nameIsText && xPathFragment.nameIsText()) || (getLocalName() == xPathFragment.getLocalName()) || ((getLocalName() != null) && getLocalName().equals(xPathFragment.getLocalName()))) && (this.indexValue == xPathFragment.getIndexValue()) && (nameIsText == xPathFragment.nameIsText());
     } catch (ClassCastException e) {


Input:
private void addDataNode(INode dataNode) {
    if (dataNode != null) {
        String addedUniqueName = dataNode.getUniqueName();
        boolean found = false;
        for (INode node : getNodeList()) {
            String uniqueName = node.getUniqueName();
            if (addedUniqueName.equals(uniqueName)) {
                found = true;
            }
        }
        if (!found) {
            getNodeList().add(dataNode);
        }
    }
}

Output:
             if (addedUniqueName.equals(uniqueName)) {
-                found = true;
+                return node;
             }


Input:
private static ServletContext extractServletContext(final CustomFilterAdapterListener listener) {
    final FilterConfig listenerFilterConfig = listener.getFilterConfig();
    final ServletContext listenerServletContext = (listenerFilterConfig != null ? listenerFilterConfig.getServletContext() : null);
    return listenerServletContext;
}

Output:
     final FilterConfig listenerFilterConfig = listener.getFilterConfig();
-    final ServletContext listenerServletContext = (listenerFilterConfig != null ? listenerFilterConfig.getServletContext() : null);
+    final ServletContext listenerServletContext = listenerFilterConfig != null ? listenerFilterConfig.getServletContext() : null;
     return listenerServletContext;


Input:
public static ArrayList<Integer> findEqual(int[] input) {
    ArrayList<Integer> ret = new ArrayList<Integer>();
    int l = 0;
    int r = input.length - 1;
    while (l < r - 1) {
        int mid = l + (r - l) / 2;
        if (input[mid] >= mid) {
            r = mid;
        } else {
            l = mid;
        }
    }
    int leftBound = l == input[l] ? l : r;
    l = 0;
    r = input.length - 1;
    while (l < r - 1) {
        int mid = l + (r - l) / 2;
        if (input[mid] <= mid) {
            l = mid;
        } else {
            r = mid;
        }
    }
    int rightBound = r == input[l] ? r : l;
    for (int i = leftBound; i <= rightBound; i++) {
        ret.add(i);
    }
    return ret;
}

Output:
     }
-    int rightBound = r == input[l] ? r : l;
+    int rightBound = r == input[r] ? r : l;
     for (int i = leftBound; i <= rightBound; i++) {


Input:
public void onPrepared(DtPlayer mp) {
    Log.i(Constant.LOGTAG, "String_Node_Str");
    mState = PLAYER_PREPARED;
    dtPlayer.start();
    mState = PLAYER_RUNNING;
    int duration = mp.getDuration();
    if (duration > 0) {
        mTextViewDuration.setText(TimesUtil.getTime(duration));
        mSeekBarProgress.setMax(duration);
    }
    startTimerTask();
}

Output:
 public void onPrepared(DtPlayer mp) {
-    Log.i(Constant.LOGTAG, "String_Node_Str");
+    Log.i(TAG, "String_Node_Str");
     mState = PLAYER_PREPARED;


Input:
private DiscoverVariantPositionData makeListWithScoresStranded(SampleCountInfo[] sampleCounts, IntArrayList qualityScores) {
    IntIterator nextQualityIterator = qualityScores.iterator();
    DiscoverVariantPositionData list = new DiscoverVariantPositionData();
    for (SampleCountInfo sampleInfo : sampleCounts) {
        for (int baseIndex = 0; baseIndex < SampleCountInfo.BASE_MAX_INDEX; baseIndex++) {
            for (int i = 0; i < sampleInfo.getGenotypeCount(baseIndex, true); i++) {
                PositionBaseInfo info = new PositionBaseInfo();
                nextQualityIterator = makeBase(true, qualityScores, nextQualityIterator, list, sampleInfo, baseIndex, info);
            }
            for (int i = 0; i < sampleInfo.getGenotypeCount(baseIndex, false); i++) {
                PositionBaseInfo info = new PositionBaseInfo();
                nextQualityIterator = makeBase(false, qualityScores, nextQualityIterator, list, sampleInfo, baseIndex, info);
            }
        }
    }
    return list;
}

Output:
             for (int i = 0; i < sampleInfo.getGenotypeCount(baseIndex, true); i++) {
-                PositionBaseInfo info = new PositionBaseInfo();
-                nextQualityIterator = makeBase(true, qualityScores, nextQualityIterator, list, sampleInfo, baseIndex, info);
+                nextQualityIterator = makeBase(true, qualityScores, nextQualityIterator, list, sampleInfo, baseIndex);
             }


Input:
public <T extends Event> void dispatchEvent(T event, Object... objects) {
    Class<? extends Event> type = event.getClass();
    PriorityQueue<Entry<IEventListener>> listenerEntryQueue = new PriorityQueue<Entry<IEventListener>>(16, new Comparator<Entry<IEventListener>>() {
        public int compare(Entry<IEventListener> o1, Entry<IEventListener> o2) {
            return o2.priority - o1.priority;
        }
    });
    for (Object object : objects) {
        Class<?> clz = object.getClass();
        Map<Object, List<Entry<IEventListener>>> objectListenerContainers = objectListenerContainersMap.get(type);
        if (objectListenerContainers == null)
            return;
        List<Entry<IEventListener>> classListeners = objectListenerContainers.get(clz);
        List<Entry<IEventListener>> listeners = objectListenerContainers.get(object);
        if (listeners != null)
            for (int i = 0; i < listeners.size(); i++) {
                Entry<IEventListener> entry = listeners.get(i);
                if (entry.getValue() == null) {
                    listeners.remove(i);
                    i--;
                } else
                    listenerEntryQueue.add(entry);
            }
        if (classListeners != null)
            for (int i = 0; i < classListeners.size(); i++) {
                Entry<IEventListener> entry = classListeners.get(i);
                if (entry.getValue() == null) {
                    listeners.remove(i);
                    i--;
                } else
                    listenerEntryQueue.add(entry);
            }
    }
    while (event.interrupted) {
        Entry<IEventListener> entry = listenerEntryQueue.poll();
        IEventListener listener = entry.getValue();
        if (listener == null)
            continue;
        listener.handleEvent(event);
    }
}

Output:
     }
-    while (event.interrupted) {
+    while (listenerEntryQueue.isEmpty() == false && event.isInterrupted() == false) {
         Entry<IEventListener> entry = listenerEntryQueue.poll();


Input:
public void onRemoveMerge(Record record) {
    LOGGER.info("String_Node_Str" + record.getId());
}

Output:
 public void onRemoveMerge(Record record) {
-    LOGGER.info("String_Node_Str" + record.getId());
+    if (LOGGER.isInfoEnabled()) {
+        LOGGER.info("String_Node_Str" + record.getId());
+    }
 }


Input:
private void unBindFromRouterService() {
    try {
        getContext().unbindService(routerConnection);
    } catch (IllegalArgumentException e) {
    }
}

Output:
     try {
-        getContext().unbindService(routerConnection);
+        if (getContext() != null) {
+            getContext().unbindService(routerConnection);
+        } else {
+            Log.w(TAG, "String_Node_Str");
+        }
     } catch (IllegalArgumentException e) {


Input:
public void update(long now) {
    if (!activeWindow.isLoaded()) {
        return;
    } else if (needReload) {
        fastReload();
    }
    if (Configuration.getInstance().isLanguageChanged()) {
        guiEvents.add(GUIEvent.LANGUAGE_CHANGED);
        Configuration.getInstance().setLanguageChanged(false);
    }
    if (Configuration.getInstance().isThemeChanged()) {
        guiEvents.add(GUIEvent.THEME_CHANGED);
        Configuration.getInstance().setThemeChanged(false);
    }
    superEvent = GUIEvent.NONE;
    List<View> components = new CopyOnWriteArrayList<View>(activeWindow.getViews());
    Context application = activeWindow.getApplication();
    components.add(application);
    updateEffects(now);
    updateApplication(application, now);
    updateActiveWindow(now);
    updateGui(components);
    updateMouse(components);
    keyboard.update(now);
    JoystickLoader.getInstance().update(now);
    if (enableFullScreen) {
        enableFullScreen = false;
        superEvent = GUIEvent.ENABLE_FULL_SCREEN;
    }
    if (disableFullScreen) {
        disableFullScreen = false;
        superEvent = GUIEvent.DISABLE_FULL_SCREEN;
    }
}

Output:
     updateActiveWindow(now);
-    updateGui(components);
+    updateGui(components, guiEvents);
     updateMouse(components);


Input:
public boolean readBytes(ReadBytesMarshallable marshallable) throws IOException {
    if (this.store == null) {
        long lastCycle = this.toStart ? queue.firstCycle() : queue.lastCycle();
        if (lastCycle == -1) {
            return false;
        }
        cycle(lastCycle);
    }
    long position = store.read(wire, marshallable);
    if (position > 0) {
        this.index++;
        return true;
    } else if (position < 0) {
        cycle(Math.abs(position));
        return readBytes(marshallable);
    }
    return false;
}

Output:
     if (this.store == null) {
-        long lastCycle = this.toStart ? queue.firstCycle() : queue.lastCycle();
-        if (lastCycle == -1) {
-            return false;
-        }
-        cycle(lastCycle);
+        throw new IllegalStateException("String_Node_Str");
     }


Input:
public void afterUnmarshal(Object target, Object parent) {
    SDODataObject targetDataObject;
    try {
        targetDataObject = (SDODataObject) target;
    } catch (ClassCastException ccex) {
        ((SDOChangeSummary) target).setRootDataObject((DataObject) parent);
        changeSummaries.add(target);
        return;
    }
    if (targetDataObject.getType().isSequenced()) {
        ((SDOSequence) (targetDataObject.getSequence())).afterUnmarshal();
    }
    if (parent == null) {
        SDOChangeSummary nextCS = null;
        XMLUnmarshaller unmarshaller = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getXmlContext().createUnmarshaller();
        for (int i = 0; i < changeSummaries.size(); i++) {
            nextCS = (SDOChangeSummary) changeSummaries.get(i);
            nextCS.setLogging(nextCS.isLoggingMapping());
            List xpaths = nextCS.getCreatedXPaths();
            String nextXPath = null;
            SDODataObject nextCreatedDO = null;
            for (int j = 0; j < xpaths.size(); j++) {
                nextXPath = (String) xpaths.get(j);
                String sdoPath = convertXPathToSDOPath(nextXPath);
                nextCreatedDO = (SDODataObject) targetDataObject.getDataObject(sdoPath);
                if (nextCreatedDO == null) {
                    int nextSlash = sdoPath.indexOf('/');
                    if (nextSlash != -1) {
                        sdoPath = sdoPath.substring(nextSlash + 1);
                    } else {
                        sdoPath = "String_Node_Str";
                    }
                    nextCreatedDO = (SDODataObject) targetDataObject.getDataObject(sdoPath);
                }
                if (nextCreatedDO != null) {
                    nextCreatedDO._setCreated(true);
                    nextCS.getOldContainers().remove(nextCreatedDO);
                } else {
                    throw SDOException.errorProcessingXPath(nextXPath);
                }
            }
            nextCS.setCreatedXPaths(null);
            List modifiedDoms = nextCS.getModifiedDoms();
            Element nextNode = null;
            String refValue = null;
            SDODataObject nextModifiedDO = null;
            for (int j = 0; j < modifiedDoms.size(); j++) {
                nextNode = (Element) modifiedDoms.get(j);
                refValue = nextNode.getAttributeNS(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY_REF);
                if ((refValue == null) || (refValue.length() == 0)) {
                    throw SDOException.missingRefAttribute();
                }
                String sdoPath = convertXPathToSDOPath(refValue);
                nextModifiedDO = (SDODataObject) targetDataObject.getDataObject(sdoPath);
                if (nextModifiedDO == null) {
                    int nextSlash = sdoPath.indexOf('/');
                    if (nextSlash != -1) {
                        sdoPath = sdoPath.substring(nextSlash + 1);
                    } else {
                        sdoPath = "String_Node_Str";
                    }
                    nextModifiedDO = (SDODataObject) targetDataObject.getDataObject(sdoPath);
                }
                String unsetValue = nextNode.getAttributeNS(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY_UNSET);
                List unsetValueList = new ArrayList();
                if ((unsetValue != null) && (unsetValue.length() > 0)) {
                    XMLConversionManager xmlConversionManager = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getXmlConversionManager();
                    unsetValueList = (List) xmlConversionManager.convertObject(unsetValue, List.class);
                }
                if (nextModifiedDO != null) {
                    nextModifiedDO._setModified(true);
                    SDOCSUnmarshalListener listener = new SDOCSUnmarshalListener(((SDOType) nextModifiedDO.getType()).getHelperContext(), true);
                    unmarshaller.setUnmarshalListener(listener);
                    unmarshaller.getProperties().put("String_Node_Str", aHelperContext);
                    unmarshaller.setUnmappedContentHandlerClass(SDOUnmappedContentHandler.class);
                    Object unmarshalledNode = unmarshaller.unmarshal(nextNode, ((SDOType) nextModifiedDO.getType()).getXmlDescriptor().getJavaClass());
                    DataObject unmarshalledDO = null;
                    if (unmarshalledNode instanceof XMLRoot) {
                        unmarshalledDO = (DataObject) ((XMLRoot) unmarshalledNode).getObject();
                    } else if (unmarshalledNode instanceof DataObject) {
                        unmarshalledDO = (DataObject) unmarshalledNode;
                    }
                    List modifiedProps = new ArrayList();
                    Node n = nextNode.getFirstChild();
                    while (n != null) {
                        if (n.getNodeType() == Node.ELEMENT_NODE) {
                            String propName = n.getLocalName();
                            Property nextProp = unmarshalledDO.getInstanceProperty(propName);
                            if (nextProp == null) {
                                nextProp = aHelperContext.getTypeHelper().getOpenContentProperty(n.getNamespaceURI(), propName);
                            }
                            if (!modifiedProps.contains(nextProp)) {
                                modifiedProps.add(nextProp);
                            }
                        }
                        n = n.getNextSibling();
                    }
                    for (int k = 0; k < modifiedProps.size(); k++) {
                        SDOProperty nextProp = (SDOProperty) modifiedProps.get(k);
                        if (!nextProp.getType().isDataType()) {
                            if (nextProp.isMany()) {
                                List originalValue = unmarshalledDO.getList(nextProp);
                                List newList = new ArrayList();
                                List toDelete = new ArrayList();
                                List indexsToDelete = new ArrayList();
                                for (int l = 0; l < originalValue.size(); l++) {
                                    SDODataObject nextInList = (SDODataObject) originalValue.get(l);
                                    String sdoRef = nextInList._getSdoRef();
                                    if (sdoRef != null) {
                                        String sdoRefPath = convertXPathToSDOPath(sdoRef);
                                        int nextSlash = sdoRefPath.indexOf('/');
                                        if (nextSlash != -1) {
                                            sdoRefPath = sdoRefPath.substring(nextSlash + 1);
                                        } else {
                                            sdoRefPath = "String_Node_Str";
                                        }
                                        newList.add(targetDataObject.getDataObject(sdoRefPath));
                                    } else {
                                        toDelete.add(nextInList);
                                        indexsToDelete.add(new Integer(l));
                                        newList.add(nextInList);
                                    }
                                }
                                ListWrapper lw = ((ListWrapper) nextModifiedDO.getList(nextProp));
                                if (indexsToDelete.size() > 0) {
                                    nextCS.pauseLogging();
                                    for (int m = 0; m < indexsToDelete.size(); m++) {
                                        int toDeleteIndex = ((Integer) indexsToDelete.get(m)).intValue();
                                        SDODataObject nextToDelete = (SDODataObject) toDelete.get(m);
                                        lw.add(toDeleteIndex, nextToDelete);
                                    }
                                    nextCS.setPropertyInternal(nextModifiedDO, nextProp, lw);
                                    SDOSequence nextSeq = ((SDOSequence) nextCS.getOriginalSequences().get(nextModifiedDO));
                                    nextCS.resumeLogging();
                                    nextModifiedDO._setModified(true);
                                    for (int m = indexsToDelete.size() - 1; m >= 0; m--) {
                                        int toDeleteIndex = ((Integer) indexsToDelete.get(m)).intValue();
                                        SDODataObject nextToDelete = (SDODataObject) toDelete.get(m);
                                        if (nextSeq != null) {
                                            nextSeq.addSettingWithoutModifyingDataObject(-1, nextProp, nextToDelete);
                                        }
                                        nextToDelete.resetChanges();
                                        lw.remove(toDeleteIndex);
                                    }
                                }
                                nextCS.getOriginalElements().put(lw, newList);
                            } else {
                                SDODataObject value = (SDODataObject) unmarshalledDO.getDataObject(nextProp);
                                if (value != null) {
                                    String sdoRef = value._getSdoRef();
                                    if (sdoRef != null) {
                                        nextModifiedDO._setModified(true);
                                    } else {
                                        value._setChangeSummary(nextCS);
                                        nextModifiedDO._setModified(true);
                                        nextCS.pauseLogging();
                                        boolean wasSet = nextModifiedDO.isSet(nextProp);
                                        Object existingValue = nextModifiedDO.get(nextProp);
                                        Sequence nextModifiedDOSequence = nextModifiedDO.getSequence();
                                        int settingIdx = -1;
                                        if (nextModifiedDOSequence != null) {
                                            settingIdx = ((SDOSequence) nextModifiedDOSequence).getIndexForProperty(nextProp);
                                        }
                                        value._setContainmentPropertyName(null);
                                        value._setContainer(null);
                                        nextModifiedDO.set(nextProp, value);
                                        nextCS.setPropertyInternal(nextModifiedDO, nextProp, value);
                                        SDOSequence nextSeq = ((SDOSequence) nextCS.getOriginalSequences().get(nextModifiedDO));
                                        if (nextSeq != null) {
                                            nextSeq.addSettingWithoutModifyingDataObject(-1, nextProp, value);
                                        }
                                        nextCS.resumeLogging();
                                        nextModifiedDO._setModified(true);
                                        value.resetChanges();
                                        value.delete();
                                        if (wasSet) {
                                            nextModifiedDO.set(nextProp, existingValue, false);
                                            if (settingIdx != -1) {
                                                ((SDOSequence) nextModifiedDO.getSequence()).addSettingWithoutModifyingDataObject(settingIdx, nextProp, existingValue);
                                            }
                                        } else {
                                            nextModifiedDO.unset(nextProp);
                                        }
                                    }
                                } else {
                                    nextModifiedDO._setModified(true);
                                    nextCS.setPropertyInternal(nextModifiedDO, nextProp, null);
                                }
                            }
                        } else {
                            nextModifiedDO._setModified(true);
                            Object value = unmarshalledDO.get(nextProp);
                            if (nextProp.isMany()) {
                                Property theProp = nextModifiedDO.getInstanceProperty(nextProp.getName());
                                if (theProp == null) {
                                    Property newProp = nextModifiedDO.defineOpenContentProperty(nextProp.getName(), new ArrayList(), nextProp.getType());
                                    nextModifiedDO.set(newProp, new ArrayList());
                                    theProp = newProp;
                                }
                                List lw = nextModifiedDO.getList(theProp.getName());
                                nextCS.setPropertyInternal(nextModifiedDO, theProp, lw);
                                nextCS.getOriginalElements().put(lw, ((ListWrapper) value).getCurrentElements());
                            } else {
                                nextCS.setPropertyInternal(nextModifiedDO, nextProp, value);
                            }
                        }
                    }
                    for (int k = 0; k < unsetValueList.size(); k++) {
                        Property nextProp = unmarshalledDO.getInstanceProperty((String) unsetValueList.get(k));
                        if (nextProp != null) {
                            Object oldValue = null;
                            if (nextProp.getType().isDataType() || nextProp.isMany()) {
                                oldValue = unmarshalledDO.get(nextProp);
                            }
                            nextModifiedDO._setModified(true);
                            nextCS.setPropertyInternal(nextModifiedDO, nextProp, oldValue);
                            nextCS.unsetPropertyInternal(nextModifiedDO, nextProp);
                        } else {
                            nextProp = nextModifiedDO.getInstanceProperty((String) unsetValueList.get(k));
                            nextModifiedDO._setModified(true);
                            nextCS.setPropertyInternal(nextModifiedDO, nextProp, null);
                            nextCS.unsetPropertyInternal(nextModifiedDO, nextProp);
                        }
                    }
                } else {
                    throw SDOException.errorProcessingXPath(refValue);
                }
            }
            nextCS.setModifiedDoms(null);
            nextCS.setDeletedXPaths(null);
            Iterator created = nextCS.getCreated().iterator();
            while (created.hasNext()) {
                SDODataObject next = (SDODataObject) created.next();
                Property containmentProperty = next.getContainmentProperty();
                if (containmentProperty != null && containmentProperty.isMany()) {
                    SDODataObject container = (SDODataObject) next.getContainer();
                    ListWrapper list = (ListWrapper) container.get(containmentProperty);
                    if (!(nextCS.getOriginalElements().containsKey(list))) {
                        nextCS.getOriginalElements().put(list, new ArrayList());
                    }
                }
            }
        }
        initialize();
    }
}

Output:
             nextCS = (SDOChangeSummary) changeSummaries.get(i);
-            nextCS.setLogging(nextCS.isLoggingMapping());
+            boolean loggingValue = nextCS.isLoggingMapping();
+            nextCS.setLogging(true);
             List xpaths = nextCS.getCreatedXPaths();


Input:
public void clearSelection() {
    getListView().clearChoices();
    getListView().requestLayout();
}

Output:
 public void clearSelection() {
-    getListView().clearChoices();
-    getListView().requestLayout();
+    if (getListView() != null) {
+        getListView().clearChoices();
+        getListView().requestLayout();
+    }
 }


Input:
public Record createRecord(String name, Data dataKey, Object value, long ttl) {
    Record record = null;
    MapContainer mapContainer = getMapContainer(name);
    final MapConfig.RecordType recordType = mapContainer.getMapConfig().getRecordType();
    if (recordType == MapConfig.RecordType.DATA) {
        record = new DataRecord(dataKey, toData(value));
    } else if (recordType == MapConfig.RecordType.OBJECT) {
        record = new ObjectRecord(dataKey, toObject(value));
    } else if (recordType == MapConfig.RecordType.CACHED) {
        record = new CachedDataRecord(dataKey, toData(value));
    } else {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (ttl <= 0 && mapContainer.getMapConfig().getTimeToLiveSeconds() > 0) {
        record.getState().updateTtlExpireTime(mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
        scheduleTtlEviction(name, dataKey, mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
    }
    if (ttl > 0) {
        record.getState().updateTtlExpireTime(ttl);
        scheduleTtlEviction(name, record.getKey(), ttl);
    }
    if (mapContainer.getMapConfig().getMaxIdleSeconds() > 0) {
        record.getState().updateIdleExpireTime(mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
        scheduleIdleEviction(name, dataKey, mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
    }
    return record;
}

Output:
     }
-    if (ttl <= 0 && mapContainer.getMapConfig().getTimeToLiveSeconds() > 0) {
-        record.getState().updateTtlExpireTime(mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
-        scheduleTtlEviction(name, dataKey, mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
-    }
-    if (ttl > 0) {
-        record.getState().updateTtlExpireTime(ttl);
-        scheduleTtlEviction(name, record.getKey(), ttl);
-    }
-    if (mapContainer.getMapConfig().getMaxIdleSeconds() > 0) {
-        record.getState().updateIdleExpireTime(mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
-        scheduleIdleEviction(name, dataKey, mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
+    if (!backup) {
+        if (ttl <= 0 && mapContainer.getMapConfig().getTimeToLiveSeconds() > 0) {
+            record.getState().updateTtlExpireTime(mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
+            scheduleTtlEviction(name, dataKey, mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
+        }
+        if (ttl > 0) {
+            record.getState().updateTtlExpireTime(ttl);
+            scheduleTtlEviction(name, record.getKey(), ttl);
+        }
+        if (mapContainer.getMapConfig().getMaxIdleSeconds() > 0) {
+            record.getState().updateIdleExpireTime(mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
+            scheduleIdleEviction(name, dataKey, mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
+        }
     }


Input:
private int getServerPort(String mech) {
    IiopListener[] iiopListenerBeans = (IiopListener[]) IIOPUtils.getInstance().getIiopService().getIiopListener().toArray(new IiopListener[0]);
    for (IiopListener ilisten : iiopListenerBeans) {
        if (mech.equalsIgnoreCase("String_Node_Str")) {
            if (ilisten.getSecurityEnabled().equalsIgnoreCase("String_Node_Str") && ilisten.getSsl() != null && !ilisten.getSsl().getClientAuthEnabled().equalsIgnoreCase("String_Node_Str")) {
                return Integer.parseInt(ilisten.getPort());
            }
        } else if (mech.equalsIgnoreCase("String_Node_Str")) {
            if (ilisten.getSecurityEnabled().equalsIgnoreCase("String_Node_Str") && ilisten.getSsl() != null && ilisten.getSsl().getClientAuthEnabled().equalsIgnoreCase("String_Node_Str")) {
                return Integer.parseInt(ilisten.getPort());
            }
        } else if (!ilisten.getSecurityEnabled().equalsIgnoreCase("String_Node_Str")) {
            return Integer.parseInt(ilisten.getPort());
        }
    }
    return -1;
}

Output:
 private int getServerPort(String mech) {
-    IiopListener[] iiopListenerBeans = (IiopListener[]) IIOPUtils.getInstance().getIiopService().getIiopListener().toArray(new IiopListener[0]);
+    List<IiopListener> listenersList = IIOPUtils.getInstance().getIiopService().getIiopListener();
+    IiopListener[] iiopListenerBeans = listenersList.toArray(new IiopListener[listenersList.size()]);
     for (IiopListener ilisten : iiopListenerBeans) {


Input:
public RecordPerspective convertForeignRecordPerspective(RecordPerspective foreignPerspective) {
    if (foreignPerspective.getIdType().getIDCategory() != recordIDCategory) {
        throw new IllegalArgumentException("String_Node_Str" + foreignPerspective.getIdType() + "String_Node_Str" + recordIDType);
    }
    if (foreignPerspective.getIdType() == recordIDType)
        return foreignPerspective;
    RecordVirtualArray foreignRecordVA = foreignPerspective.getVirtualArray();
    RecordGroupList recordGroupList = foreignRecordVA.getGroupList();
    PerspectiveInitializationData data = new PerspectiveInitializationData();
    ArrayList<Integer> indices = new ArrayList<Integer>(foreignRecordVA.size());
    ArrayList<Integer> groupSizes = new ArrayList<Integer>(recordGroupList.size());
    ArrayList<Integer> sampleElements = new ArrayList<Integer>(recordGroupList.size());
    ArrayList<String> groupNames = new ArrayList<String>(recordGroupList.size());
    for (Group foreignGroup : recordGroupList) {
        groupSizes.add(0);
        sampleElements.add(0);
        groupNames.add(foreignGroup.getClusterNode().getLabel());
    }
    for (Integer foreignVAID : foreignRecordVA) {
        Integer localVAID = recordIDMappingManager.getID(foreignRecordVA.getIdType(), recordIDType, foreignVAID);
        if (localVAID == null)
            continue;
        indices.add(localVAID);
        int groupIndex = recordGroupList.getGroupOfVAIndex(foreignRecordVA.indexOf(foreignVAID)).getGroupID();
        groupSizes.set(groupIndex, sampleElements.get(groupIndex) + 1);
        sampleElements.set(groupIndex, localVAID);
    }
    data.setData(indices, groupSizes, sampleElements, groupNames);
    RecordPerspective localRecordPerspective = new RecordPerspective(this);
    localRecordPerspective.setIDType(recordIDType);
    localRecordPerspective.init(data);
    return localRecordPerspective;
}

Output:
         int groupIndex = recordGroupList.getGroupOfVAIndex(foreignRecordVA.indexOf(foreignVAID)).getGroupID();
-        groupSizes.set(groupIndex, sampleElements.get(groupIndex) + 1);
-        sampleElements.set(groupIndex, localVAID);
+        groupSizes.set(groupIndex, groupSizes.get(groupIndex) + 1);
+        sampleElements.set(groupIndex, count);
+        count++;
     }


Input:
private static boolean deployEJBTimerService(File root, File appScratchFile, String resourceName, boolean is_upgrade) {
    boolean deployed = false;
    logger.log(Level.INFO, "String_Node_Str");
    File app = null;
    try {
        app = FileUtils.getManagedFile(TIMER_SERVICE_APP_NAME + "String_Node_Str", new File(root, "String_Node_Str"));
    } catch (Exception e) {
        logger.log(Level.WARNING, "String_Node_Str", e);
    }
    if (app == null || !app.exists()) {
        logger.log(Level.WARNING, "String_Node_Str" + "String_Node_Str" + TIMER_SERVICE_APP_NAME + "String_Node_Str");
    } else {
        DeployCommandParameters params = new DeployCommandParameters(app);
        params.name = TIMER_SERVICE_APP_NAME;
        try {
            EjbContainerUtil _ejbContainerUtil = EjbContainerUtilImpl.getInstance();
            if (_ejbContainerUtil.isDas()) {
                boolean scratchFileCreated = appScratchFile.createNewFile();
                if (!is_upgrade && scratchFileCreated) {
                    params.origin = OpsParams.Origin.deploy;
                }
            } else {
                params.origin = OpsParams.Origin.load;
            }
            params.target = _ejbContainerUtil.getServerEnvironment().getInstanceName();
            ActionReport report = _ejbContainerUtil.getServices().getService(ActionReport.class, "String_Node_Str");
            Deployment deployment = _ejbContainerUtil.getDeployment();
            ExtendedDeploymentContext dc = deployment.getBuilder(logger, params, report).source(app).build();
            dc.addTransientAppMetaData(DatabaseConstants.JTA_DATASOURCE_JNDI_NAME_OVERRIDE, resourceName);
            Properties appProps = dc.getAppProps();
            appProps.setProperty(ServerTags.OBJECT_TYPE, DeploymentProperties.SYSTEM_ALL);
            deployment.deploy(dc);
            if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS) {
                logger.log(Level.WARNING, "String_Node_Str", report.getFailureCause());
            } else {
                deployed = true;
            }
        } catch (Exception e) {
            logger.log(Level.WARNING, "String_Node_Str", e);
        } finally {
            if (!deployed && params.origin.isDeploy() && appScratchFile.exists()) {
                if (!appScratchFile.delete()) {
                    logger.log(Level.WARNING, "String_Node_Str" + appScratchFile);
                }
            }
        }
    }
    return deployed;
}

Output:
             EjbContainerUtil _ejbContainerUtil = EjbContainerUtilImpl.getInstance();
-            if (_ejbContainerUtil.isDas()) {
-                boolean scratchFileCreated = appScratchFile.createNewFile();
-                if (!is_upgrade && scratchFileCreated) {
-                    params.origin = OpsParams.Origin.deploy;
-                }
+            if (_ejbContainerUtil.isDas() && appScratchFile.createNewFile() && !is_upgrade) {
+                params.origin = OpsParams.Origin.deploy;
             } else {


Input:
public void deletePath(RenderedServicePath rsp) {
    Eid spEid = LispAddressUtil.asServicePathEid(0, rsp.getPathId().longValue(), LispAddressUtil.STARTING_SERVICE_INDEX);
    removeMapping(spEid);
}

Output:
 public void deletePath(RenderedServicePath rsp) {
-    Eid spEid = LispAddressUtil.asServicePathEid(0, rsp.getPathId().longValue(), LispAddressUtil.STARTING_SERVICE_INDEX);
+    Eid spEid = LispAddressUtil.asServicePathEid(0, rsp.getPathId(), LispAddressUtil.STARTING_SERVICE_INDEX);
     removeMapping(spEid);


Input:
public synchronized CtfTmfEvent getNext(final ITmfContext context) {
    CtfTmfEvent event = null;
    if (context instanceof CtfTmfLightweightContext) {
        if (CtfLocation.INVALID_LOCATION.equals(context.getLocation())) {
            return null;
        }
        CtfTmfLightweightContext ctfContext = (CtfTmfLightweightContext) context;
        if (ctfContext.getLocation().equals(CtfLocation.INVALID_LOCATION)) {
            return null;
        }
        event = ctfContext.getCurrentEvent();
        if (event != null) {
            updateAttributes(context, event.getTimestamp());
            ctfContext.advance();
            ctfContext.increaseRank();
        }
    }
    return event;
}

Output:
     if (context instanceof CtfTmfLightweightContext) {
-        if (CtfLocation.INVALID_LOCATION.equals(context.getLocation())) {
+        if (CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocation())) {
             return null;


Input:
public File getModuleLocationFile() {
    if (moduleLocationFile == null && moduleLocation != null) {
        moduleLocationFile = new File(moduleLocation);
    }
    return moduleLocationFile;
}

Output:
     if (moduleLocationFile == null && moduleLocation != null) {
-        moduleLocationFile = new File(moduleLocation);
+        if (!isSystemModule()) {
+            moduleLocationFile = new File(moduleLocation);
+        } else {
+            return null;
+        }
     }


Input:
private void parseChildren(String path, org.w3c.dom.Element node, Element context) throws FHIRFormatError, FHIRException, IOException, DefinitionException {
    reapComments(node, context);
    List<Property> properties = context.getProperty().getChildProperties(context.getName(), XMLUtil.getXsiType(node));
    String text = XMLUtil.getDirectText(node).trim();
    if (!Utilities.noString(text)) {
        Property property = getTextProp(properties);
        if (property != null) {
            context.getChildren().add(new Element(property.getName(), property, property.getType(), text).markLocation(line(node), col(node)));
        } else {
            logError(line(node), col(node), path, IssueType.STRUCTURE, "String_Node_Str", IssueSeverity.ERROR);
        }
    }
    for (int i = 0; i < node.getAttributes().getLength(); i++) {
        Node attr = node.getAttributes().item(i);
        if (!(attr.getNodeName().equals("String_Node_Str") || attr.getNodeName().startsWith("String_Node_Str"))) {
            Property property = getAttrProp(properties, attr.getNodeName());
            if (property != null) {
                String av = attr.getNodeValue();
                if (ToolingExtensions.hasExtension(property.getDefinition(), "String_Node_Str"))
                    av = convertForDateFormat(ToolingExtensions.readStringExtension(property.getDefinition(), "String_Node_Str"), av);
                if (property.getName().equals("String_Node_Str") && context.isPrimitive())
                    context.setValue(av);
                else
                    context.getChildren().add(new Element(property.getName(), property, property.getType(), av).markLocation(line(node), col(node)));
            } else if (!allowXsiLocation || !attr.getNodeName().endsWith("String_Node_Str")) {
                logError(line(node), col(node), path, IssueType.STRUCTURE, "String_Node_Str" + attr.getNodeName() + "String_Node_Str" + node.getNodeName(), IssueSeverity.ERROR);
            }
        }
    }
    Node child = node.getFirstChild();
    while (child != null) {
        if (child.getNodeType() == Node.ELEMENT_NODE) {
            Property property = getElementProp(properties, child.getLocalName());
            if (property != null) {
                if (!property.isChoice() && "String_Node_Str".equals(property.getType())) {
                    XhtmlNode xhtml = new XhtmlParser().setValidatorMode(true).parseHtmlNode((org.w3c.dom.Element) child);
                    context.getChildren().add(new Element("String_Node_Str", property, "String_Node_Str", new XhtmlComposer().setXmlOnly(true).compose(xhtml)).setXhtml(xhtml).markLocation(line(child), col(child)));
                } else {
                    String npath = path + "String_Node_Str" + pathPrefix(child.getNamespaceURI()) + child.getLocalName();
                    Element n = new Element(child.getLocalName(), property).markLocation(line(child), col(child));
                    checkElement((org.w3c.dom.Element) child, npath, n.getProperty());
                    boolean ok = true;
                    if (property.isChoice()) {
                        if (property.getDefinition().hasRepresentation(PropertyRepresentation.TYPEATTR)) {
                            String xsiType = ((org.w3c.dom.Element) child).getAttributeNS(FormatUtilities.NS_XSI, "String_Node_Str");
                            if (xsiType == null) {
                                logError(line(child), col(child), path, IssueType.STRUCTURE, "String_Node_Str" + child.getLocalName() + '"', IssueSeverity.ERROR);
                                ok = false;
                            } else {
                                if (xsiType.contains("String_Node_Str"))
                                    xsiType = xsiType.substring(xsiType.indexOf("String_Node_Str") + 1);
                                n.setType(xsiType);
                            }
                        } else
                            n.setType(n.getType());
                    }
                    context.getChildren().add(n);
                    if (ok) {
                        if (property.isResource())
                            parseResource(npath, (org.w3c.dom.Element) child, n, property);
                        else
                            parseChildren(npath, (org.w3c.dom.Element) child, n);
                    }
                }
            } else
                logError(line(child), col(child), path, IssueType.STRUCTURE, "String_Node_Str" + child.getLocalName() + "String_Node_Str", IssueSeverity.ERROR);
        } else if (child.getNodeType() == Node.CDATA_SECTION_NODE) {
            logError(line(child), col(child), path, IssueType.STRUCTURE, "String_Node_Str", IssueSeverity.ERROR);
        } else if (!Utilities.existsInList(child.getNodeType(), 3, 8)) {
            logError(line(child), col(child), path, IssueType.STRUCTURE, "String_Node_Str" + Integer.toString(child.getNodeType()) + "String_Node_Str", IssueSeverity.ERROR);
        }
        child = child.getNextSibling();
    }
}

Output:
                     XhtmlNode xhtml = new XhtmlParser().setValidatorMode(true).parseHtmlNode((org.w3c.dom.Element) child);
-                    context.getChildren().add(new Element("String_Node_Str", property, "String_Node_Str", new XhtmlComposer().setXmlOnly(true).compose(xhtml)).setXhtml(xhtml).markLocation(line(child), col(child)));
+                    context.getChildren().add(new Element("String_Node_Str", property, "String_Node_Str", new XhtmlComposer(XhtmlComposer.XML).compose(xhtml)).setXhtml(xhtml).markLocation(line(child), col(child)));
                 } else {


Input:
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        if (!m_order.orderItems.isEmpty()) {
            new Alerts(this).showAlert();
        } else {
            finish();
        }
    }
    return true;
}

Output:
         if (!m_order.orderItems.isEmpty()) {
-            new Alerts(this).showAlert();
+            new Alerts(this, R.string.alters_confirm_delete).showAlert();
         } else {


Input:
protected Dimension getIntrinsicDimension(IImageContent content, Image image) {
    if (image != null) {
        int resolutionX = image.getDpiX();
        int resolutionY = image.getDpiY();
        if (0 == resolutionX || 0 == resolutionY) {
            ReportDesignHandle designHandle = content.getReportContent().getDesign().getReportDesign();
            resolutionX = designHandle.getImageDPI();
            resolutionY = designHandle.getImageDPI();
        }
        if (0 == resolutionX || 0 == resolutionY) {
            resolutionX = context.getDpi();
            resolutionY = context.getDpi();
        }
        if (0 == resolutionX || 0 == resolutionY) {
            resolutionX = 96;
            resolutionY = 96;
        }
        return new Dimension((int) (image.plainWidth() * 1000 / resolutionX * 72), (int) (image.plainHeight() * 1000 / resolutionY * 72));
    }
    return null;
}

Output:
     if (image != null) {
-        int resolutionX = image.getDpiX();
-        int resolutionY = image.getDpiY();
+        resolutionX = image.getDpiX();
+        resolutionY = image.getDpiY();
         if (0 == resolutionX || 0 == resolutionY) {


Input:
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    canvas.drawColor(mBgcolor);
    canvas.drawRect(mBorder, mBorder, mWidth - mBorder, mHeight - mBorder, mCheckPaint);
    canvas.drawRect(mBorder, mBorder, mWidth - mBorder, mHeight - mBorder, mBarPaint1);
    canvas.drawLine(mDotX, mDotY, mWidth - mBorder, mDotY, mLinePaint1);
    canvas.drawLine(mBorder, mDotY, mDotX, mDotY, mLinePaint2);
    if (mDotX != Float.NaN) {
        canvas.drawCircle(mDotX, mDotY, mDotRadus, mDotPaint);
    }
}

Output:
     if (mDotX != Float.NaN) {
-        canvas.drawCircle(mDotX, mDotY, mDotRadus, mDotPaint);
+        canvas.drawCircle(mDotX, mDotY, mDotRadius, mDotPaint);
     }


Input:
public static boolean removeSpouts(Location loc0, double radius, Player sourceplayer) {
    boolean removed = false;
    for (Integer id : getInstances(StockAbility.AirSpout).keySet()) {
        Player player = getInstances(StockAbility.AirSpout).get(id).getPlayer();
        if (!player.equals(sourceplayer)) {
            Location loc1 = player.getLocation().getBlock().getLocation();
            loc0 = loc0.getBlock().getLocation();
            double dx = loc1.getX() - loc0.getX();
            double dy = loc1.getY() - loc0.getY();
            double dz = loc1.getZ() - loc0.getZ();
            double distance = Math.sqrt(dx * dx + dz * dz);
            if (distance <= radius && dy > 0 && dy < HEIGHT) {
                getInstances(StockAbility.AirSpout).get(id).remove();
                removed = true;
            }
        }
    }
    return removed;
}

Output:
     for (Integer id : getInstances(StockAbility.AirSpout).keySet()) {
-        Player player = getInstances(StockAbility.AirSpout).get(id).getPlayer();
+        Player player = getAbility(id).getPlayer();
         if (!player.equals(sourceplayer)) {


Input:
private void addEdit(TextEdit edit) {
    if (edit instanceof DeleteEdit && edit.getLength() == 0) {
        return;
    }
    if (edit instanceof ReplaceEdit && edit.getLength() == 0 && ((ReplaceEdit) edit).getText().isEmpty()) {
        return;
    }
    if (edit instanceof InsertEdit && ((InsertEdit) edit).getText().isEmpty()) {
        return;
    }
    if (edit != null && edit.getOffset() >= formatter.formatOffset && edit.getOffset() + edit.getLength() <= formatter.formatOffset + formatter.formatLength) {
        if (edit instanceof DeleteEdit) {
            debug("String_Node_Str" + edit.getOffset() + "String_Node_Str" + edit.getLength());
            debug("String_Node_Str");
            IDocument doc = formatter.getProgressDocument();
            try {
                debug(doc.get(0, edit.getOffset()) + "String_Node_Str" + doc.get(edit.getOffset(), edit.getLength()) + "String_Node_Str" + doc.get(edit.getOffset() + edit.getLength(), doc.getLength() - (edit.getOffset() + edit.getLength())));
            } catch (BadLocationException e) {
                e.printStackTrace();
            }
            debug("String_Node_Str");
        }
        try {
            indentationEdits.addChild(edit);
        } catch (MalformedTreeException e) {
            debug("String_Node_Str" + edit);
            GroovyCore.logException("String_Node_Str", e);
        }
    }
}

Output:
     }
-    if (edit instanceof ReplaceEdit && edit.getLength() == 0 && ((ReplaceEdit) edit).getText().isEmpty()) {
+    if (edit instanceof ReplaceEdit && edit.getLength() == 0 && ((ReplaceEdit) edit).getText().length() < 1) {
         return;