Input:
public String saveImage(JComponent comp, float scaleX, float scaleY, File folder, OTObject otObject) {
    try {
        String seperator = System.getProperty("String_Node_Str");
        String id = otObject.getGlobalId().toString();
        id = id.replaceAll("String_Node_Str", "String_Node_Str");
        id = id.replaceAll("String_Node_Str", "String_Node_Str") + "String_Node_Str";
        if (!folder.isDirectory())
            return null;
        File newFile = new File(folder.getAbsoluteFile().toString() + seperator + id);
        BufferedImage bim = ComponentScreenshot.makeComponentImageAlpha(comp, scaleX, scaleY);
        ComponentScreenshot.saveImageAsFile(bim, newFile, "String_Node_Str");
        String relativePath = folder + "String_Node_Str" + newFile.getName();
        return relativePath;
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return null;
}

Output:
     try {
-        String seperator = System.getProperty("String_Node_Str");
-        String id = otObject.getGlobalId().toString();
-        id = id.replaceAll("String_Node_Str", "String_Node_Str");
-        id = id.replaceAll("String_Node_Str", "String_Node_Str") + "String_Node_Str";
-        if (!folder.isDirectory())
-            return null;
-        File newFile = new File(folder.getAbsoluteFile().toString() + seperator + id);
-        BufferedImage bim = ComponentScreenshot.makeComponentImageAlpha(comp, scaleX, scaleY);
-        ComponentScreenshot.saveImageAsFile(bim, newFile, "String_Node_Str");
-        String relativePath = folder + "String_Node_Str" + newFile.getName();
-        return relativePath;
-    } catch (Throwable t) {
-        t.printStackTrace();
+        SwingUtilities.invokeAndWait(saver);
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    } catch (InvocationTargetException e) {
+        e.printStackTrace();
     }


Input:
private boolean doSorting(Path sortedTmpDir) throws ClassNotFoundException, InterruptedException {
    final Configuration conf = getConf();
    final Job[] jobs = new Job[levels.length];
    boolean errors = false;
    for (int i = 0; i < levels.length; ++i) {
        final String l = levels[i];
        try {
            jobs[i] = sortMerged(l, new Path(sortedTmpDir, getSummaryName(l)));
        } catch (IOException e) {
            System.err.printf("String_Node_Str", l, e);
            if (i == 0)
                return false;
            else
                errors = true;
        }
    }
    System.out.println("String_Node_Str");
    t.start();
    for (int i = levels.length; i-- > 0; ) {
        boolean success;
        try {
            success = jobs[i].waitForCompletion(verbose);
        } catch (IOException e) {
            success = false;
        }
        final String l = levels[i];
        if (!success) {
            System.err.printf("String_Node_Str", l);
            errors = true;
            continue;
        }
        System.out.printf("String_Node_Str", l);
        final Path mergedTmp = FileInputFormat.getInputPaths(jobs[i])[0];
        try {
            mergedTmp.getFileSystem(conf).delete(mergedTmp, false);
        } catch (IOException e) {
            System.err.printf("String_Node_Str", mergedTmp);
        }
    }
    if (errors)
        return false;
    System.out.printf("String_Node_Str", t.stopS(), t.fms());
    return true;
}

Output:
     for (int i = 0; i < levels.length; ++i) {
-        final String l = levels[i];
+        final String lvl = levels[i];
         try {


Input:
public void topicChanged(Topic t) throws TopicMapException {
    for (Locator l : t.getSubjectIdentifiers()) {
        removeTopicFromIndex(l);
    }
    if (topicMapListeners.size() > 0) {
        LayeredTopic lt = null;
        if (t instanceof LayeredTopic && t.getTopicMap() == this)
            lt = (LayeredTopic) t;
        else
            lt = makeLayeredTopic(t);
        for (TopicMapListener listener : topicMapListeners) {
            listener.topicChanged(lt);
        }
    }
}

Output:
     }
-    if (topicMapListeners.size() > 0) {
+    if (!topicMapListeners.isEmpty()) {
         LayeredTopic lt = null;


Input:
public void createDisk(String vmdkDatastorePath, VirtualDiskType diskType, VirtualDiskMode diskMode, String rdmDeviceName, int sizeInMb, ManagedObjectReference morDs, int controllerKey) throws Exception {
    if (s_logger.isTraceEnabled())
        s_logger.trace("String_Node_Str" + _mor.getValue() + "String_Node_Str" + vmdkDatastorePath + "String_Node_Str" + sizeInMb + "String_Node_Str" + diskType + "String_Node_Str" + diskMode + "String_Node_Str" + rdmDeviceName + "String_Node_Str" + morDs.getValue() + "String_Node_Str" + controllerKey);
    assert (vmdkDatastorePath != null);
    assert (morDs != null);
    if (controllerKey < 0) {
        controllerKey = getIDEDeviceControllerKey();
    }
    VirtualDisk newDisk = new VirtualDisk();
    if (diskType == VirtualDiskType.THIN || diskType == VirtualDiskType.PREALLOCATED || diskType == VirtualDiskType.EAGER_ZEROED_THICK) {
        VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
        backingInfo.setDiskMode(diskMode.PERSISTENT.toString());
        if (diskType == VirtualDiskType.THIN) {
            backingInfo.setThinProvisioned(true);
        } else {
            backingInfo.setThinProvisioned(false);
        }
        if (diskType == VirtualDiskType.EAGER_ZEROED_THICK) {
            backingInfo.setEagerlyScrub(true);
        } else {
            backingInfo.setEagerlyScrub(false);
        }
        backingInfo.setDatastore(morDs);
        backingInfo.setFileName(vmdkDatastorePath);
        newDisk.setBacking(backingInfo);
    } else if (diskType == VirtualDiskType.RDM || diskType == VirtualDiskType.RDMP) {
        VirtualDiskRawDiskMappingVer1BackingInfo backingInfo = new VirtualDiskRawDiskMappingVer1BackingInfo();
        if (diskType == VirtualDiskType.RDM) {
            backingInfo.setCompatibilityMode("String_Node_Str");
        } else {
            backingInfo.setCompatibilityMode("String_Node_Str");
        }
        backingInfo.setDeviceName(rdmDeviceName);
        if (diskType == VirtualDiskType.RDM) {
            backingInfo.setDiskMode(diskMode.PERSISTENT.toString());
        }
        backingInfo.setDatastore(morDs);
        backingInfo.setFileName(vmdkDatastorePath);
        newDisk.setBacking(backingInfo);
    }
    int deviceNumber = getNextDeviceNumber(controllerKey);
    newDisk.setControllerKey(controllerKey);
    newDisk.setKey(-deviceNumber);
    newDisk.setUnitNumber(deviceNumber);
    newDisk.setCapacityInKB(sizeInMb * 1024);
    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();
    VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
    deviceConfigSpec.setDevice(newDisk);
    deviceConfigSpec.setFileOperation(VirtualDeviceConfigSpecFileOperation.CREATE);
    deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.ADD);
    reConfigSpec.getDeviceChange().add(deviceConfigSpec);
    ManagedObjectReference morTask = _context.getService().reconfigVMTask(_mor, reConfigSpec);
    boolean result = _context.getVimClient().waitForTask(morTask);
    if (!result) {
        if (s_logger.isTraceEnabled())
            s_logger.trace("String_Node_Str");
        throw new Exception("String_Node_Str" + vmdkDatastorePath + "String_Node_Str" + TaskMO.getTaskFailureInfo(_context, morTask));
    }
    _context.waitForTaskProgressDone(morTask);
    if (s_logger.isTraceEnabled())
        s_logger.trace("String_Node_Str");
}

Output:
         VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
-        backingInfo.setDiskMode(diskMode.PERSISTENT.toString());
+        backingInfo.setDiskMode(diskMode.PERSISTENT.value());
         if (diskType == VirtualDiskType.THIN) {


Input:
public void onClick(View view) {
    if (!checkSurveyData()) {
        return;
    }
    final ArrayList<String> selectedFacIds = new ArrayList<String>();
    if (!selectedFaculties.isEmpty()) {
        for (int j = 0; j < selectedFaculties.size(); j++) {
            for (int x = 0; x < fetchedFaculties.size(); x++) {
                if (selectedFaculties.get(j).equals(fetchedFaculties.get(x))) {
                    Cursor cursor = surveyManager.getFacultyID(selectedFaculties.get(j));
                    if (cursor.moveToFirst()) {
                        selectedFacIds.add(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
                    }
                }
            }
        }
    } else {
        Cursor c = surveyManager.getAllFaculties();
        if (c.moveToFirst()) {
            do {
                selectedFacIds.add(c.getString(c.getColumnIndex("String_Node_Str")));
            } while (c.moveToNext());
        }
    }
    if (NetUtils.isConnected(getApplication())) {
        for (int i = 0; i < aSpinner1.getSelectedItemPosition() + 1; i++) {
            Question ques = new Question(questions.get(i), selectedFacIds);
            try {
                TUMCabeClient.getInstance(getApplicationContext()).createQuestion(ques, new Callback<Question>() {
                    public void success(Question question, Response response) {
                        Utils.log("String_Node_Str" + response.getBody().toString());
                        numberOfQuestion++;
                        Toast.makeText(getApplicationContext(), getResources().getString(R.string.survey_submitted), Toast.LENGTH_SHORT).show();
                    }
                    public void failure(RetrofitError error) {
                        Utils.log("String_Node_Str" + error.toString());
                    }
                });
            } catch (Exception e) {
                Utils.log(e.toString());
            }
        }
        clearData();
        new AsyncTask<Void, Void, Void>() {
            protected Void doInBackground(Void... voids) {
                surveyManager.downLoadOwnQuestions();
                return null;
            }
            protected void onPostExecute(Void v) {
                restartActivity();
            }
        }.execute();
    } else
        Toast.makeText(getApplicationContext(), "String_Node_Str", Toast.LENGTH_LONG).show();
}

Output:
     } else
-        Toast.makeText(getApplicationContext(), "String_Node_Str", Toast.LENGTH_LONG).show();
+        restartActivity();
 }


Input:
final void handleConfigurationChanged(Configuration config) {
    synchronized (mRelaunchingActivities) {
        if (mPendingConfiguration != null) {
            config = mPendingConfiguration;
            mPendingConfiguration = null;
        }
    }
    ArrayList<ComponentCallbacks> callbacks = new ArrayList<ComponentCallbacks>();
    synchronized (mPackages) {
        if (mConfiguration == null) {
            mConfiguration = new Configuration();
        }
        mConfiguration.updateFrom(config);
        DisplayMetrics dm = getDisplayMetricsLocked(true);
        if (config.locale != null) {
            Locale.setDefault(config.locale);
        }
        Resources.updateSystemConfiguration(config, null);
        ApplicationContext.ApplicationPackageManager.configurationChanged();
        {
            Iterator<WeakReference<Resources>> it = mActiveResources.values().iterator();
            while (it.hasNext()) {
                WeakReference<Resources> v = it.next();
                Resources r = v.get();
                if (r != null) {
                    r.updateConfiguration(config, dm);
                } else {
                    it.remove();
                }
            }
        }
        callbacks = collectComponentCallbacksLocked(false, config);
    }
    final int N = callbacks.size();
    for (int i = 0; i < N; i++) {
        performConfigurationChanged(callbacks.get(i), config);
    }
}

Output:
         }
-        Resources.updateSystemConfiguration(config, null);
+        Resources.updateSystemConfiguration(config, dm);
         ApplicationContext.ApplicationPackageManager.configurationChanged();


Input:
private void updateSuppression(NotificationGroup group) {
    if (group == null || mUpdatingSuppressionBlocked) {
        return;
    }
    boolean prevSuppressed = group.suppressed;
    group.suppressed = group.summary != null && !group.expanded && (group.children.size() == 1 || (group.children.size() == 0 && group.summary.notification.getNotification().isGroupSummary() && hasIsolatedChildren(group)));
    if (prevSuppressed != group.suppressed) {
        if (group.suppressed) {
            handleSuppressedSummaryHeadsUpped(group.summary);
        }
        mListener.onGroupsChanged();
    }
}

Output:
 private void updateSuppression(NotificationGroup group) {
-    if (group == null || mUpdatingSuppressionBlocked) {
+    if (group == null) {
         return;


Input:
public <T> Key<T> merge(T entity, WriteConcern wc) {
    LinkedHashMap<Object, DBObject> involvedObjects = new LinkedHashMap<Object, DBObject>();
    DBObject dbObj = mapr.toDBObject(entity, involvedObjects);
    Key<T> key = getKey(entity);
    entity = ProxyHelper.unwrap(entity);
    Object id = getId(entity);
    if (id == null)
        throw new MappingException("String_Node_Str" + entity.getClass().getName());
    Query<T> query = (Query<T>) createQuery(entity.getClass()).filter(Mapper.ID_KEY, id);
    dbObj.removeField(Mapper.ID_KEY);
    UpdateResults<T> res = update(query, new BasicDBObject("String_Node_Str", dbObj), false, false, wc);
    CommandResult gle = res.getWriteResult().getCachedLastError();
    if (gle != null && res.getUpdatedCount() == 0)
        throw new UpdateException("String_Node_Str" + gle);
    postSaveOperations(entity, dbObj, involvedObjects);
    return key;
}

Output:
     dbObj.removeField(Mapper.ID_KEY);
-    UpdateResults<T> res = update(query, new BasicDBObject("String_Node_Str", dbObj), false, false, wc);
-    CommandResult gle = res.getWriteResult().getCachedLastError();
+    WriteResult wr = null;
+    MappedClass mc = mapr.getMappedClass(entity);
+    DBCollection dbColl = getCollection(entity);
+    wr = tryVersionedUpdate(dbColl, entity, dbObj, wc, db, mc);
+    if (wr == null) {
+        Query<T> query = (Query<T>) createQuery(entity.getClass()).filter(Mapper.ID_KEY, id);
+        wr = update(query, new BasicDBObject("String_Node_Str", dbObj), false, false, wc).getWriteResult();
+    }
+    UpdateResults<T> res = new UpdateResults<T>(wr);
+    throwOnError(wc, wr);
+    CommandResult gle = wr.getCachedLastError();
     if (gle != null && res.getUpdatedCount() == 0)


Input:
protected void populateCommonFields(final PropertiableFile propertiable) {
    heading.setText(propertiableHeadings.getHeading(propertiable));
    filename.setText(propertiable.getFileName());
    subheading.setText(propertiableHeadings.getSubHeading(propertiable));
    fileSize.setText(str(propertiable.getProperty(FilePropertyKey.FILE_SIZE)));
    genre.setModel(new DefaultComboBoxModel(new Object[] { propertiable.getProperty(FilePropertyKey.GENRE) }));
    rating.setModel(new DefaultComboBoxModel(new Object[] { propertiable.getProperty(FilePropertyKey.RATING) }));
    platform.setModel(new DefaultComboBoxModel(new Object[] { propertiable.getProperty(FilePropertyKey.PLATFORM) }));
    populateMetadata(propertiable);
    title.setText(str(propertiable.getProperty(FilePropertyKey.TITLE)));
    artist.setText(str(propertiable.getProperty(FilePropertyKey.AUTHOR)));
    author.setText(str(propertiable.getProperty(FilePropertyKey.AUTHOR)));
    company.setText(str(propertiable.getProperty(FilePropertyKey.COMPANY)));
    album.setText(str(propertiable.getProperty(FilePropertyKey.ALBUM)));
    year.setText(str(propertiable.getProperty(FilePropertyKey.YEAR)));
    track.setText(str(propertiable.getProperty(FilePropertyKey.TRACK_NUMBER)));
    description.setText(str(propertiable.getProperty(FilePropertyKey.COMMENTS)));
}

Output:
     subheading.setText(propertiableHeadings.getSubHeading(propertiable));
-    fileSize.setText(str(propertiable.getProperty(FilePropertyKey.FILE_SIZE)));
+    fileSize.setText(propertiableHeadings.getFileSize(propertiable));
     genre.setModel(new DefaultComboBoxModel(new Object[] { propertiable.getProperty(FilePropertyKey.GENRE) }));


Input:
private boolean wakeUpRouterService(Context context, boolean ping, boolean altTransportWake) {
    if (!isRouterServiceRunning(context, ping)) {
        Intent serviceIntent = new Intent(context, localRouterClass);
        if (altTransportWake) {
            serviceIntent.setAction(TransportConstants.BIND_REQUEST_TYPE_ALT_TRANSPORT);
        }
        context.startService(serviceIntent);
        return true;
    } else {
        if (altTransportWake && runningBluetoothServicePackage != null && runningBluetoothServicePackage.size() > 0) {
            Intent serviceIntent = new Intent();
            serviceIntent.setAction(TransportConstants.BIND_REQUEST_TYPE_ALT_TRANSPORT);
            for (ComponentName compName : runningBluetoothServicePackage) {
                serviceIntent.setComponent(compName);
                context.startService(serviceIntent);
            }
            return true;
        }
        return false;
    }
}

Output:
         }
-        context.startService(serviceIntent);
+        try {
+            context.startService(serviceIntent);
+        } catch (SecurityException e) {
+            Log.e(TAG, "String_Node_Str");
+            return false;
+        }
         return true;


Input:
public void propertyChange(PropertyChangeEvent evt) {
    switch(evt.getPropertyName()) {
        case RankTableModel.PROP_DATA:
            Collection<IRow> news = (Collection<IRow>) evt.getNewValue();
            maskInvalid.set(getTable().getDataSize() - news.size(), getTable().getDataSize());
            break;
    }
}

Output:
         case RankTableModel.PROP_DATA:
-            Collection<IRow> news = (Collection<IRow>) evt.getNewValue();
-            maskInvalid.set(getTable().getDataSize() - news.size(), getTable().getDataSize());
+            RankTableModel table = getTable();
+            if (table != null) {
+                Collection<IRow> news = (Collection<IRow>) evt.getNewValue();
+                maskInvalid.set(table.getDataSize() - news.size(), table.getDataSize());
+            }
             break;


Input:
private Optional<String> unableToFindTargetBuildTools(Path sdkPath) {
    return Optional.of("String_Node_Str" + targetBuildToolsVersion.get() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Escaper.escapeAsShellString(sdkPath.resolve("String_Node_Str").toString()) + "String_Node_Str" + "String_Node_Str" + targetBuildToolsVersion.get() + "String_Node_Str");
}

Output:
 private Optional<String> unableToFindTargetBuildTools(Path sdkPath) {
-    return Optional.of("String_Node_Str" + targetBuildToolsVersion.get() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Escaper.escapeAsShellString(sdkPath.resolve("String_Node_Str").toString()) + "String_Node_Str" + "String_Node_Str" + targetBuildToolsVersion.get() + "String_Node_Str");
+    return Optional.of("String_Node_Str" + targetBuildToolsVersion.get() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Escaper.escapeAsShellString(sdkPath.resolve("String_Node_Str").toString()) + "String_Node_Str" + targetBuildToolsVersion.get() + "String_Node_Str");
 }


Input:
public Result getResults(final CharSequence originalText, final double threshold) {
    final String[] gatheredSuggestions;
    final boolean looksLikeTypo;
    if (0 == mLength) {
        if (null == mBestSuggestion) {
            gatheredSuggestions = null;
            looksLikeTypo = false;
        } else {
            gatheredSuggestions = EMPTY_STRING_ARRAY;
            final double normalizedScore = Utils.calcNormalizedScore(originalText, mBestSuggestion, mBestScore);
            looksLikeTypo = (normalizedScore > threshold);
        }
    } else {
        if (DBG) {
            if (mLength != mSuggestions.size()) {
                Log.e(TAG, "String_Node_Str");
            }
        }
        Collections.reverse(mSuggestions);
        Utils.removeDupes(mSuggestions);
        gatheredSuggestions = mSuggestions.toArray(EMPTY_STRING_ARRAY);
        final int bestScore = mScores[0];
        final CharSequence bestSuggestion = mSuggestions.get(0);
        final double normalizedScore = Utils.calcNormalizedScore(originalText, bestSuggestion, bestScore);
        looksLikeTypo = (normalizedScore > threshold);
    }
    return new Result(gatheredSuggestions, looksLikeTypo);
}

Output:
         gatheredSuggestions = mSuggestions.toArray(EMPTY_STRING_ARRAY);
-        final int bestScore = mScores[0];
+        final int bestScore = mScores[mLength - 1];
         final CharSequence bestSuggestion = mSuggestions.get(0);


Input:
private void updateDocMap(DataReader reader) {
    String[] keys = reader.getKeys();
    if (keys == null || keys.length == 1) {
        return;
    }
    keys = Arrays.copyOfRange(keys, 1, keys.length);
    for (String key : keys) {
        log.debug("String_Node_Str", key);
        String lastKey = key;
        for (int count = 0; count < reader.getTotalLines(key); count++) {
            String[] row = reader.read(key, count);
            if (row == null) {
                continue;
            }
            if (count == 0) {
                if (row.length > CommonService.HELP) {
                    docMap.put(lastKey, Arrays.copyOfRange(row, CommonService.HELP, row.length));
                }
                continue;
            }
            String name = getFieldName(row);
            String type = row[CommonService.TYPE];
            if (type == null) {
                continue;
            }
            String model = row[CommonService.MODEL];
            if (model != null) {
                model = common.inflector.camelize(model);
            }
            String view = row[CommonService.VIEW];
            if (model != null && view == null) {
                view = ViewLoaderService.getDefaultViewName(model, "String_Node_Str");
            }
            if (updateComment(lastKey, type, row)) {
                continue;
            }
            lastKey = model + "String_Node_Str" + view + "String_Node_Str" + getFieldType(type) + "String_Node_Str" + name;
            if (row.length > CommonService.HELP) {
                docMap.put(lastKey, Arrays.copyOfRange(row, CommonService.HELP, row.length));
            }
        }
    }
}

Output:
         String lastKey = key;
-        for (int count = 0; count < reader.getTotalLines(key); count++) {
+        for (int count = 1; count < reader.getTotalLines(key); count++) {
             String[] row = reader.read(key, count);


Input:
public void writeExample(IndentedAppendable writer) throws IOException {
    Optional<Example> e = source.getAnnotation(Example.class);
    if (!e.isPresent()) {
        return;
    }
    writer.appendLine(name + "String_Node_Str" + e.get().value());
}

Output:
 public void writeExample(IndentedAppendable writer) throws IOException {
-    Optional<Example> e = source.getAnnotation(Example.class);
-    if (!e.isPresent()) {
-        return;
+    if (!ramlType.isRamlType()) {
+        writer.appendLine(name + "String_Node_Str");
+        writer.indent();
+        ramlType.writeExample(writer);
+        writer.outdent();
+    } else {
+        Optional<Example> e = source.getAnnotation(Example.class);
+        if (!e.isPresent()) {
+            return;
+        }
+        writer.appendLine(name + "String_Node_Str" + e.get().value());
     }


Input:
public boolean existGroup(String nameOrKey) {
    SearchBusinessGroupParams params = new SearchBusinessGroupParams();
    if (StringHelper.isLong(nameOrKey)) {
        params.setKeys(Collections.singletonList(new Long(nameOrKey)));
    } else {
        params.setExactName(nameOrKey);
    }
    return businessGroupService.countBusinessGroups(params, courseResource) > 0;
}

Output:
     if (StringHelper.isLong(nameOrKey)) {
-        params.setKeys(Collections.singletonList(new Long(nameOrKey)));
+        params.setGroupKeys(Collections.singletonList(new Long(nameOrKey)));
     } else {


Input:
private void transferData(InputStream in, OutputStream out) {
    final byte[] data = new byte[BUFFER_SIZE];
    mCurrentBytes = 0;
    mRequest.setDownloadState(DownloadManager.STATUS_RUNNING);
    Log.v(TAG, "String_Node_Str" + mContentLength + "String_Node_Str" + mRequest.getDownloadId());
    for (; ; ) {
        if (mRequest.isCanceled()) {
            Log.v(TAG, "String_Node_Str" + mRequest.getDownloadId());
            mRequest.finish();
            updateDownloadFailed(DownloadManager.ERROR_DOWNLOAD_CANCELLED, "String_Node_Str");
            return;
        }
        int bytesRead = readFromResponse(data, in);
        if (mContentLength != -1) {
            int progress = (int) ((mCurrentBytes * 100) / mContentLength);
            updateDownloadProgress(progress);
        }
        if (bytesRead == -1) {
            updateDownloadComplete();
            return;
        } else if (bytesRead == Integer.MIN_VALUE) {
            return;
        }
        writeDataToDestination(data, bytesRead, out);
        mCurrentBytes += bytesRead;
    }
}

Output:
             int progress = (int) ((mCurrentBytes * 100) / mContentLength);
-            updateDownloadProgress(progress);
+            updateDownloadProgress(progress, mCurrentBytes);
         }


Input:
protected RestXqErrorCode getInvalidDefaultValueErr() {
    return RestXqErrorCodes.RQST0023;
}

Output:
 protected RestXqErrorCode getInvalidDefaultValueErr() {
-    return RestXqErrorCodes.RQST0023;
+    return RestXqErrorCodes.RQST0024;
 }


Input:
public void configure(List<String> options, final HeatMapModel heatMapModel, final AttributeType selType) {
    this.heatMapModel = heatMapModel;
    this.heatMapModel.addChangeListener(this);
    this.selectionType = selType;
    DefaultComboBoxModel<String> readoutModel = new DefaultComboBoxModel<String>(options.toArray(new String[options.size()]));
    setModel(readoutModel);
    switch(selType) {
        case READOUT:
            if (heatMapModel.getSelectedReadOut() != null) {
                setSelectedItem(heatMapModel.getSelectedReadOut());
            } else {
                heatMapModel.setCurrentReadout((String) getSelectedItem());
            }
            break;
        case OVERLAY_ANNOTATION:
            if (heatMapModel.getCurrentOverlay() != null) {
                setSelectedItem(heatMapModel.getCurrentOverlay());
            } else {
                heatMapModel.setCurrentOverlay((String) getSelectedItem());
            }
            break;
    }
    addItemListener(new ItemListener() {
        public void itemStateChanged(ItemEvent event) {
            if (event.getStateChange() == ItemEvent.SELECTED) {
                HeatMapModel mapModel = WellAttributeComboBox.this.heatMapModel;
                switch(selType) {
                    case READOUT:
                        mapModel.setCurrentReadout((String) getModel().getSelectedItem());
                        break;
                    case OVERLAY_ANNOTATION:
                        mapModel.setCurrentOverlay((String) getModel().getSelectedItem());
                        break;
                }
                heatMapModel.fireModelChanged();
            }
        }
    });
    setRenderer(new MyComboBoxRenderer());
}

Output:
     this.selectionType = selType;
-    DefaultComboBoxModel<String> readoutModel = new DefaultComboBoxModel<String>(options.toArray(new String[options.size()]));
+    String[] items = options.toArray(new String[options.size()]);
+    if (selectionType == AttributeType.OVERLAY_ANNOTATION) {
+        items = addOverlayOptions(items);
+    }
+    DefaultComboBoxModel<String> readoutModel = new DefaultComboBoxModel<String>(items);
     setModel(readoutModel);


Input:
public IIcon getIcon(int Side, int Meta) {
    try {
        return (Types.values()[Meta].OpenIcon);
    } catch (Throwable Throwable) {
        Throwable.printStackTrace();
        return (Blocks.Spectre.getIcon(0, 0));
    }
}

Output:
     try {
-        return (Types.values()[Meta].OpenIcon);
+        CarriageEntity Carriage = (CarriageEntity) World.getTileEntity(X, Y, Z);
+        if ((Carriage.decorationId != null) && (Carriage.SideClosed[Side])) {
+            return (Carriage.decorationId.getIcon(Side, Carriage.DecorationMeta));
+        }
+        Types Type = Types.values()[World.getBlockMetadata(X, Y, Z)];
+        return (Carriage.SideClosed[Side] ? Type.ClosedIcon : Type.OpenIcon);
     } catch (Throwable Throwable) {


Input:
protected ARXConfiguration getSubsetInstance(RowSet rowset, double gsFactor) {
    ARXConfiguration result = this.clone();
    result.aCriteria = null;
    HashSet<PrivacyCriterion> criteria = new HashSet<PrivacyCriterion>();
    for (PrivacyCriterion criterion : result.criteria) {
        PrivacyCriterion clone = null;
        if (criterion instanceof Inclusion) {
            clone = new Inclusion(((Inclusion) criterion).getSubset().getSubsetInstance(rowset));
        } else if (criterion instanceof DPresence) {
            clone = new DPresence(((DPresence) criterion).getDMin(), ((DPresence) criterion).getDMax(), ((DPresence) criterion).getSubset().getSubsetInstance(rowset));
        } else if (criterion instanceof KMap && ((KMap) criterion).isAccurate()) {
            clone = new KMap(((KMap) criterion).getK(), ((KMap) criterion).getSubset().getSubsetInstance(rowset));
        } else {
            clone = criterion.clone();
        }
        criteria.add(clone);
    }
    result.criteria = criteria;
    MetricConfiguration utilityConfig = result.getMetric().getConfiguration();
    utilityConfig.setGsFactor(gsFactor);
    result.metric = result.getMetric().getDescription().createInstance(utilityConfig);
    return result;
}

Output:
             clone = new DPresence(((DPresence) criterion).getDMin(), ((DPresence) criterion).getDMax(), ((DPresence) criterion).getSubset().getSubsetInstance(rowset));
-        } else if (criterion instanceof KMap && ((KMap) criterion).isAccurate()) {
-            clone = new KMap(((KMap) criterion).getK(), ((KMap) criterion).getSubset().getSubsetInstance(rowset));
+        } else if (criterion instanceof KMap) {
+            if (((KMap) criterion).isAccurate()) {
+                clone = new KMap(((KMap) criterion).getK(), ((KMap) criterion).getSubset().getSubsetInstance(rowset));
+            } else {
+                clone = new KAnonymity(((KMap) criterion).getDerivedK());
+            }
         } else {


Input:
public void onReceive(Context context, Intent intent) {
    if (action != null && action.equals(intent.getAction())) {
        String key = intent.getAction();
        String json = intent.getStringExtra(key);
        handleJSONUpdateInBackground(json);
    }
}

Output:
         String json = intent.getStringExtra(key);
-        handleJSONUpdateInBackground(json);
+        handleJSONUpdateInBackground(json, action);
     }


Input:
public CQLStatement next() {
    List values = Lists.newArrayList(CQLTemplate.getValues());
    values.add(0, this.keyIterator.next());
    CQLStatement ret = CQLStatement.make(CQLTemplate.getQuery(), values.toArray());
    ret.setCacheable(CQLTemplate.isCacheable());
    return ret;
}

Output:
     values.add(0, this.keyIterator.next());
-    CQLStatement ret = CQLStatement.make(CQLTemplate.getQuery(), values.toArray());
+    CQLStatement ret = CQLStatement.make(String.format(CQLTemplate.getQuery(), numberRemaining), values.toArray());
     ret.setCacheable(CQLTemplate.isCacheable());


Input:
private void checkPermissions() {
    if (isVoiceOnlyCall) {
        onMicrophoneClick();
    } else if (getActivity() != null) {
        requestPermissions(PERMISSIONS_CALL, 100);
    }
}

Output:
     } else if (getActivity() != null) {
-        requestPermissions(PERMISSIONS_CALL, 100);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            requestPermissions(PERMISSIONS_CALL, 100);
+        } else {
+            onRequestPermissionsResult(100, PERMISSIONS_CALL, new int[] { 1 });
+        }
     }


Input:
public void setLastExec(Date lastExec) {
    this.lastExec = lastExec;
}

Output:
 public void setLastExec(Date lastExec) {
-    this.lastExec = lastExec;
+    this.lastExec = new Date(lastExec.getTime());
 }


Input:
public void encodeHeader(FacesContext context, String h, UIComponent navlink) throws IOException {
    ResponseWriter rw = context.getResponseWriter();
    String htmlTag = "String_Node_Str";
    UIComponent parent = navlink.getParent();
    if (parent != null) {
        if (parent instanceof DropButton || parent instanceof NavBar || parent instanceof TabLinks || parent instanceof PillLinks || parent instanceof ListLinks) {
            htmlTag = "String_Node_Str";
        } else {
            System.out.println(parent.getClass().getName());
        }
    }
    rw.startElement(htmlTag, navlink);
    writeAttribute(rw, "String_Node_Str", navlink.getClientId(context), "String_Node_Str");
    String styleClass = ((AbstractNavLink) navlink).getStyleClass();
    if (null == styleClass)
        writeAttribute(rw, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    else
        writeAttribute(rw, "String_Node_Str", "String_Node_Str" + styleClass, "String_Node_Str");
    writeAttribute(rw, "String_Node_Str", ((AbstractNavLink) navlink).getStyle(), "String_Node_Str");
    writeAttribute(rw, "String_Node_Str", "String_Node_Str", null);
    rw.writeText(h, null);
    rw.endElement(htmlTag);
}

Output:
     if (parent != null) {
-        if (parent instanceof DropButton || parent instanceof NavBar || parent instanceof TabLinks || parent instanceof PillLinks || parent instanceof ListLinks) {
+        if (parent instanceof DropButton || parent instanceof NavBar || parent instanceof TabLinks || parent instanceof PillLinks || parent instanceof ListLinks || parent instanceof NavBarLinks || parent instanceof DropMenu) {
             htmlTag = "String_Node_Str";


Input:
public void create(Table table) {
    drawDebug = true;
    shapeRenderer = new ShapeRenderer();
    separationDecayCoefficient = 500;
    characters = new Array<SteeringActor>();
    blendedSteerings = new Array<BlendedSteering<Vector2>>();
    proximities = new Array<FieldOfViewProximity<Vector2>>();
    for (int i = 0; i < 60; i++) {
        SteeringActor character = new SteeringActor(container.greenFish, false);
        character.setCenterPosition(MathUtils.random(container.stageWidth), MathUtils.random(container.stageHeight));
        character.setMaxLinearSpeed(70);
        character.setMaxLinearAcceleration(400);
        character.setMaxAngularAcceleration(0);
        character.setMaxAngularSpeed(5);
        FieldOfViewProximity<Vector2> proximity = new FieldOfViewProximity<Vector2>(character, characters, 140, 270 * MathUtils.degreesToRadians);
        proximities.add(proximity);
        if (i == 0)
            char0Proximity = proximity;
        Alignment<Vector2> groupAlignmentSB = new Alignment<Vector2>(character, proximity);
        Cohesion<Vector2> groupCohesionSB = new Cohesion<Vector2>(character, proximity);
        Separation<Vector2> groupSeparationSB = new Separation<Vector2>(character, proximity) {
            public float getDecayCoefficient() {
                return separationDecayCoefficient;
            }
            public Separation<Vector2> setDecayCoefficient(float decayCoefficient) {
                separationDecayCoefficient = decayCoefficient;
                return this;
            }
        };
        BlendedSteering<Vector2> blendedSteering = new BlendedSteering<Vector2>(character).add(groupAlignmentSB, .2f).add(groupCohesionSB, .06f).add(groupSeparationSB, 1.7f);
        blendedSteerings.add(blendedSteering);
        Wander<Vector2> wanderSB = new Wander<Vector2>(character).setFaceEnabled(false).setWanderOffset(60).setWanderOrientation(10).setWanderRadius(40).setWanderRate(MathUtils.PI / 5);
        PrioritySteering<Vector2> prioritySteeringSB = new PrioritySteering<Vector2>(character, 0.0001f).add(blendedSteering).add(wanderSB);
        character.setSteeringBehavior(prioritySteeringSB);
        table.addActor(character);
        characters.add(character);
    }
    inputProcessor = null;
    Table detailTable = new Table(container.skin);
    detailTable.row();
    final Label alignmentWeightLabel = new Label("String_Node_Str" + blendedSteerings.get(0).get(0).getWeight() + "String_Node_Str", container.skin);
    detailTable.add(alignmentWeightLabel);
    detailTable.row();
    Slider alignmentWeight = new Slider(0, 2, .01f, false, container.skin);
    alignmentWeight.setValue(blendedSteerings.get(0).get(0).getWeight());
    alignmentWeight.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < blendedSteerings.size; i++) blendedSteerings.get(i).get(0).setWeight(slider.getValue());
            alignmentWeightLabel.setText("String_Node_Str" + blendedSteerings.get(0).get(0).getWeight() + "String_Node_Str");
        }
    });
    detailTable.add(alignmentWeight);
    detailTable.row();
    final Label cohesionWeightLabel = new Label("String_Node_Str" + blendedSteerings.get(0).get(1).getWeight() + "String_Node_Str", container.skin);
    detailTable.add(cohesionWeightLabel);
    detailTable.row();
    Slider cohesionWeight = new Slider(0, 2, .01f, false, container.skin);
    cohesionWeight.setValue(blendedSteerings.get(0).get(1).getWeight());
    cohesionWeight.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < blendedSteerings.size; i++) blendedSteerings.get(i).get(1).setWeight(slider.getValue());
            cohesionWeightLabel.setText("String_Node_Str" + blendedSteerings.get(0).get(1).getWeight() + "String_Node_Str");
        }
    });
    detailTable.add(cohesionWeight);
    detailTable.row();
    final Label separationWeightLabel = new Label("String_Node_Str" + blendedSteerings.get(0).get(2).getWeight() + "String_Node_Str", container.skin);
    detailTable.add(separationWeightLabel);
    detailTable.row();
    Slider separationWeight = new Slider(0, 2, .01f, false, container.skin);
    separationWeight.setValue(blendedSteerings.get(0).get(2).getWeight());
    separationWeight.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < blendedSteerings.size; i++) blendedSteerings.get(i).get(2).setWeight(slider.getValue());
            separationWeightLabel.setText("String_Node_Str" + blendedSteerings.get(0).get(2).getWeight() + "String_Node_Str");
        }
    });
    detailTable.add(separationWeight);
    detailTable.row();
    final Label separationDecayCoeffLabel = new Label("String_Node_Str" + separationDecayCoefficient + "String_Node_Str", container.skin);
    detailTable.add(separationDecayCoeffLabel);
    detailTable.row();
    Slider separationDecayCoeff = new Slider(1, 5000, 1, false, container.skin);
    separationDecayCoeff.setValue(separationDecayCoefficient);
    separationDecayCoeff.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            separationDecayCoefficient = slider.getValue();
            separationDecayCoeffLabel.setText("String_Node_Str" + separationDecayCoefficient + "String_Node_Str");
        }
    });
    detailTable.add(separationDecayCoeff);
    detailTable.row();
    addSeparator(detailTable);
    detailTable.row();
    final Label labelProximityRadius = new Label("String_Node_Str" + proximities.get(0).getRadius() + "String_Node_Str", container.skin);
    detailTable.add(labelProximityRadius);
    detailTable.row();
    Slider proximityRadius = new Slider(0, 500, 1, false, container.skin);
    proximityRadius.setValue(proximities.get(0).getRadius());
    proximityRadius.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < proximities.size; i++) proximities.get(i).setRadius(slider.getValue());
            labelProximityRadius.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(proximityRadius);
    detailTable.row();
    final Label labelProximityAngle = new Label("String_Node_Str" + proximities.get(0).getAngle() * MathUtils.radiansToDegrees + "String_Node_Str", container.skin);
    detailTable.add(labelProximityAngle);
    detailTable.row();
    Slider proximityAngle = new Slider(0, 360, 1, false, container.skin);
    proximityAngle.setValue(proximities.get(0).getAngle() * MathUtils.radiansToDegrees);
    proximityAngle.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < proximities.size; i++) proximities.get(i).setAngle(slider.getValue() * MathUtils.degreesToRadians);
            labelProximityAngle.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(proximityAngle);
    detailTable.row();
    final Label labelMaxLinAcc = new Label("String_Node_Str" + characters.get(0).getMaxLinearAcceleration() + "String_Node_Str", container.skin);
    detailTable.add(labelMaxLinAcc);
    detailTable.row();
    Slider maxLinAcc = new Slider(0, 500, 1, false, container.skin);
    maxLinAcc.setValue(characters.get(0).getMaxLinearAcceleration());
    maxLinAcc.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < characters.size; i++) characters.get(i).setMaxLinearAcceleration(slider.getValue());
            labelMaxLinAcc.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(maxLinAcc);
    detailTable.row();
    final Label labelMaxLinSpeed = new Label("String_Node_Str" + characters.get(0).getMaxLinearSpeed() + "String_Node_Str", container.skin);
    detailTable.add(labelMaxLinSpeed);
    detailTable.row();
    Slider maxLinSpeed = new Slider(0, 500, 1, false, container.skin);
    maxLinSpeed.setValue(characters.get(0).getMaxLinearSpeed());
    maxLinSpeed.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            for (int i = 0; i < characters.size; i++) characters.get(i).setMaxLinearSpeed(slider.getValue());
            labelMaxLinSpeed.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(maxLinSpeed);
    detailTable.row();
    addSeparator(detailTable);
    detailTable.row();
    CheckBox debug = new CheckBox("String_Node_Str", container.skin);
    debug.setChecked(drawDebug);
    debug.addListener(new ClickListener() {
        public void clicked(InputEvent event, float x, float y) {
            CheckBox checkBox = (CheckBox) event.getListenerActor();
            drawDebug = checkBox.isChecked();
        }
    });
    detailTable.add(debug);
    detailWindow = createDetailWindow(detailTable);
}

Output:
         SteeringActor character = new SteeringActor(container.greenFish, false);
-        character.setCenterPosition(MathUtils.random(container.stageWidth), MathUtils.random(container.stageHeight));
+        character.setPosition(MathUtils.random(container.stageWidth), MathUtils.random(container.stageHeight), Align.center);
         character.setMaxLinearSpeed(70);


Input:
public void processMessage(QBRoomChat roomChat, QBChatMessage chatMessage) {
    Friend friend = DatabaseManager.getFriendById(context, chatMessage.getSenderId());
    String attachUrl = getAttachUrlIfExists(chatMessage);
    String roomJid = roomChat.getJid();
    long time = Long.parseLong(chatMessage.getProperty(propertyDateSent).toString());
    saveMessageToCache(new DialogMessageCache(roomJid, chatMessage.getSenderId(), chatMessage.getBody(), attachUrl, time, false));
    if (!chatMessage.getSenderId().equals(user.getId())) {
        notifyMessageReceived(chatMessage, friend);
    }
}

Output:
     Friend friend = DatabaseManager.getFriendById(context, chatMessage.getSenderId());
-    String attachUrl = getAttachUrlIfExists(chatMessage);
+    String attachUrl = ChatUtils.getAttachUrlIfExists(chatMessage);
     String roomJid = roomChat.getJid();


Input:
protected boolean isBitarchiveDirectory(File theDir) {
    ArgumentNotValid.checkNotNull(theDir, "String_Node_Str");
    try {
        theDir = theDir.getCanonicalFile();
        for (Iterator<File> i = archivePaths.iterator(); i.hasNext(); ) {
            File knowndir = i.next();
            if (knowndir.getCanonicalFile().equals(theDir)) {
                return true;
            }
        }
        return false;
    } catch (IOException e) {
        final String errMsg = "String_Node_Str";
        log.warn(errMsg, e);
        throw new IOFailure(errMsg, e);
    }
}

Output:
         theDir = theDir.getCanonicalFile();
-        for (Iterator<File> i = archivePaths.iterator(); i.hasNext(); ) {
-            File knowndir = i.next();
+        for (File knowndir : archivePaths) {
             if (knowndir.getCanonicalFile().equals(theDir)) {


Input:
public void remove(Session session) throws SQLException {
    if (trace.isDebugEnabled()) {
        trace.debug("String_Node_Str");
    }
    removeAllRows();
    store.free(rootPageId, true);
    store.removeMeta(this, session);
}

Output:
     removeAllRows();
-    store.free(rootPageId, true);
+    store.free(rootPageId);
     store.removeMeta(this, session);


Input:
public void getFile(GetFileMessage msg) {
    ArgumentNotValid.checkNotNull(msg, "String_Node_Str");
    log.debug("String_Node_Str" + msg + "String_Node_Str");
    con.resend(msg, this.allBa);
}

Output:
     log.debug("String_Node_Str" + msg + "String_Node_Str");
-    con.resend(msg, this.allBa);
+    jmsCon.resend(msg, this.allBa);
 }


Input:
private Band getComplexSrcBand(final Band iBand) {
    String name = iBand.getName();
    if (name.startsWith("String_Node_Str")) {
        name.replace("String_Node_Str", "String_Node_Str");
    } else if (name.startsWith("String_Node_Str")) {
        name.replace("String_Node_Str", "String_Node_Str");
    }
    return srcProduct.getBand(name);
}

Output:
     if (name.startsWith("String_Node_Str")) {
-        name.replace("String_Node_Str", "String_Node_Str");
+        name = name.replace("String_Node_Str", "String_Node_Str");
     } else if (name.startsWith("String_Node_Str")) {


Input:
public void testCopyFromWithOverwriteDuplicates() throws Exception {
    execute("String_Node_Str");
    ensureYellow();
    execute("String_Node_Str", new Object[][] { new Object[] { 1 }, new Object[] { 2 }, new Object[] { 3 }, new Object[] { 4 } });
    execute("String_Node_Str");
    File tmpExport = folder.newFolder("String_Node_Str");
    execute("String_Node_Str", new Object[] { tmpExport.getAbsolutePath() });
    assertThat(response.rowCount(), is(4L));
    execute("String_Node_Str", new Object[] { String.format(Locale.ENGLISH, "String_Node_Str", tmpExport.getAbsolutePath()) });
    assertThat(response.rowCount(), is(0L));
    execute("String_Node_Str", new Object[] { String.format(Locale.ENGLISH, "String_Node_Str", tmpExport.getAbsolutePath()) });
    assertThat(response.rowCount(), is(4L));
    execute("String_Node_Str");
    execute("String_Node_Str");
    assertThat(((Long) response.rows()[0][0]), is(4L));
}

Output:
     File tmpExport = folder.newFolder("String_Node_Str");
-    execute("String_Node_Str", new Object[] { tmpExport.getAbsolutePath() });
+    String uriTemplate = Paths.get(tmpExport.toURI()).toUri().toString();
+    execute("String_Node_Str", new Object[] { uriTemplate });
     assertThat(response.rowCount(), is(4L));


Input:
public void testLegacy() throws Exception {
    byte[] ip = { (byte) 0xFF, (byte) 0, (byte) 0, (byte) 0x1 };
    long u4 = 0x00000000FFFFFFFFl;
    byte[] guid = new byte[16];
    guid[0] = (byte) 1;
    guid[15] = (byte) 0xFF;
    Response[] responses = new Response[0];
    QueryReply qr = new QueryReply(guid, (byte) 5, 0xF3F1, ip, 1, responses, guid, false);
    assertEquals(1, qr.getSpeed());
    assertEquals(Integer.toHexString(qr.getPort()), 0xF3F1, qr.getPort());
    assertEquals(qr.getResults().hasNext(), false);
    responses = new Response[2];
    responses[0] = new Response(11, 22, "String_Node_Str");
    responses[1] = new Response(0x2FF2, 0xF11F, "String_Node_Str");
    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, false);
    assertEquals("String_Node_Str", qr.getIP());
    assertEquals(0xFFFF, qr.getPort());
    assertEquals(u4, qr.getSpeed());
    assertTrue(Arrays.equals(qr.getClientGUID(), guid));
    Iterator iter = qr.getResults();
    Response r1 = (Response) iter.next();
    assertEquals(r1, responses[0]);
    Response r2 = (Response) iter.next();
    assertEquals(r2, responses[1]);
    assertFalse(iter.hasNext());
    byte[] payload = new byte[11 + 11 + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    iter = qr.getResults();
    Response response = (Response) iter.next();
    assertEquals("String_Node_Str", response.getName());
    assertFalse(iter.hasNext());
    try {
        qr.getVendor();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getNeedsPush();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    payload = new byte[11 + 11 + 15];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    try {
        iter = qr.getResults();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getVendor();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    payload = new byte[11 + 11 + (4 + 1 + 4 + 5) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 76;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4 + 0] = (byte) QueryReply.COMMON_PAYLOAD_LEN;
    payload[11 + 11 + 4 + 1 + 2] = (byte) 5;
    payload[11 + 11 + 4 + 1 + 3] = (byte) 0;
    payload[11 + 11 + 4 + 1 + 4] = (byte) 'S';
    payload[11 + 11 + 4 + 1 + 4 + 1] = (byte) 'U';
    payload[11 + 11 + 4 + 1 + 4 + 2] = (byte) 'S';
    payload[11 + 11 + 4 + 1 + 4 + 3] = (byte) 'H';
    payload[11 + 11 + 4 + 1 + 4 + 4] = (byte) 0;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    try {
        iter = qr.getResults();
        Response r = (Response) iter.next();
        assertEquals("String_Node_Str", 1, r.getNameBytesSize());
        assertEquals("String_Node_Str", 0, r.getMetaBytesSize());
        byte[] name = r.getNameBytes();
        assertEquals("String_Node_Str", 'A', name[0]);
        assertEquals("String_Node_Str", "String_Node_Str", r.getName());
        assertEquals("String_Node_Str", "String_Node_Str", (new String(qr.getXMLBytes())));
    } catch (BadPacketException e) {
        fail("String_Node_Str", e);
    }
    payload = new byte[11 + 11 + (4 + 1 + 4 + 4) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 105;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4 + 0] = (byte) QueryReply.COMMON_PAYLOAD_LEN;
    payload[11 + 11 + 4 + 1] = (byte) 0xB1;
    payload[11 + 11 + 4 + 1 + 2] = (byte) 4;
    payload[11 + 11 + 4 + 1 + 3] = (byte) 0;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    String vendor = qr.getVendor();
    assertEquals(vendor, "String_Node_Str", vendor);
    vendor = qr.getVendor();
    assertEquals(vendor, "String_Node_Str", vendor);
    assertTrue(qr.getNeedsPush());
    payload = new byte[11 + 11 + (4 + 1 + 4 + 20000) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 76;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4 + 0] = (byte) QueryReply.COMMON_PAYLOAD_LEN;
    payload[11 + 11 + 4 + 1] = (byte) 0xF0;
    payload[11 + 11 + 4 + 1 + 2] = (byte) 32;
    payload[11 + 11 + 4 + 1 + 3] = (byte) 78;
    for (int i = 0; i < 20000; i++) payload[11 + 11 + 4 + 1 + 4 + i] = 'a';
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    vendor = qr.getVendor();
    assertEquals(vendor, "String_Node_Str", vendor);
    vendor = qr.getVendor();
    assertEquals(vendor, "String_Node_Str", vendor);
    assertFalse(qr.getNeedsPush());
    try {
        qr.getSupportsChat();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    payload = new byte[11 + 11 + (4 + 1 + 2) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 4 + 1 + 0] = (byte) 1;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    try {
        qr.getNeedsPush();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getVendor();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    payload = new byte[11 + 11 + (4 + 2 + 0) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 105;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4 + 0] = (byte) 2;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    qr.getResults();
    try {
        qr.getVendor();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    payload = new byte[11 + 11 + (4 + 1 + 4 + 1) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 105;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4 + 0] = (byte) QueryReply.COMMON_PAYLOAD_LEN;
    payload[11 + 11 + 4 + 1] = (byte) 0x0;
    payload[11 + 11 + 4 + 1 + 1] = (byte) 0x0;
    payload[11 + 11 + 4 + 1 + 2] = (byte) 1;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    vendor = qr.getVendor();
    assertEquals("String_Node_Str", "String_Node_Str", vendor);
    assertTrue(!qr.getNeedsPush());
    try {
        qr.getIsBusy();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getHadSuccessfulUpload();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getIsMeasuredSpeed();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    payload = new byte[11 + 11 + (4 + 1 + 4 + 1 + 1) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 73;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4] = (byte) QueryReply.COMMON_PAYLOAD_LEN;
    payload[11 + 11 + 4 + 1] = (byte) 0x1d;
    payload[11 + 11 + 4 + 1 + 1] = (byte) 0x1c;
    payload[11 + 11 + 4 + 1 + 2] = (byte) 1;
    payload[11 + 11 + 4 + 1 + 4] = (byte) 0x1;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    vendor = qr.getVendor();
    assertEquals(vendor, "String_Node_Str", vendor);
    assertTrue(qr.getNeedsPush());
    assertTrue(qr.getNeedsPush());
    assertTrue(qr.getIsBusy());
    assertTrue(qr.getIsBusy());
    assertTrue(qr.getIsMeasuredSpeed());
    assertTrue(qr.getIsMeasuredSpeed());
    assertTrue(qr.getHadSuccessfulUpload());
    assertTrue(qr.getHadSuccessfulUpload());
    assertTrue(qr.getSupportsChat());
    payload = new byte[11 + 11 + (4 + 1 + 4 + 1) + 16];
    payload[0] = 1;
    payload[11 + 8] = (byte) 65;
    payload[11 + 11 + 0] = (byte) 76;
    payload[11 + 11 + 1] = (byte) 105;
    payload[11 + 11 + 2] = (byte) 77;
    payload[11 + 11 + 3] = (byte) 69;
    payload[11 + 11 + 4] = (byte) QueryReply.COMMON_PAYLOAD_LEN;
    payload[11 + 11 + 4 + 1] = (byte) 0x1c;
    payload[11 + 11 + 4 + 1 + 1] = (byte) 0x0;
    payload[11 + 11 + 4 + 1 + 2] = (byte) 1;
    qr = new QueryReply(new byte[16], (byte) 5, (byte) 0, payload);
    vendor = qr.getVendor();
    assertEquals(vendor, "String_Node_Str", vendor);
    assertFalse(qr.getNeedsPush());
    assertFalse(qr.getIsBusy());
    assertFalse(qr.getIsMeasuredSpeed());
    assertFalse(qr.getHadSuccessfulUpload());
    try {
        qr.getSupportsChat();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    responses = new Response[2];
    responses[0] = new Response(11, 22, "String_Node_Str");
    responses[1] = new Response(0x2FF2, 0xF11F, "String_Node_Str");
    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, false, true, true, false, true, false);
    assertEquals("String_Node_Str", qr.getIP());
    assertEquals(0xFFFF, qr.getPort());
    assertEquals(u4, qr.getSpeed());
    assertTrue(Arrays.equals(qr.getClientGUID(), guid));
    iter = qr.getResults();
    r1 = (Response) iter.next();
    assertEquals(r1, responses[0]);
    r2 = (Response) iter.next();
    assertEquals(r2, responses[1]);
    assertFalse(iter.hasNext());
    assertEquals("String_Node_Str", qr.getVendor());
    assertFalse(qr.getNeedsPush());
    assertTrue(qr.getIsBusy());
    assertTrue(qr.getHadSuccessfulUpload());
    assertFalse(qr.getIsMeasuredSpeed());
    assertTrue(qr.getSupportsChat());
    assertTrue(qr.getSupportsBrowseHost());
    assertTrue(!qr.isReplyToMulticastQuery());
    responses = new Response[2];
    responses[0] = new Response(11, 22, "String_Node_Str");
    responses[1] = new Response(0x2FF2, 0xF11F, "String_Node_Str");
    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, true, false, false, true, false, false);
    assertEquals("String_Node_Str", qr.getVendor());
    assertTrue(qr.getNeedsPush());
    assertFalse(qr.getIsBusy());
    assertFalse(qr.getHadSuccessfulUpload());
    assertTrue(qr.getIsMeasuredSpeed());
    assertFalse(qr.getSupportsChat());
    assertTrue(qr.getSupportsBrowseHost());
    assertTrue(!qr.isReplyToMulticastQuery());
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    qr.write(out);
    byte[] bytes = out.toByteArray();
    int ggepLen = _ggepUtil.getQRGGEP(true, false).length;
    assertEquals((23 + 11 + 16) + (8 + 10 + 2) + (8 + 14 + 2) + (4 + 1 + QueryReply.COMMON_PAYLOAD_LEN + 1 + 1) + ggepLen, bytes.length);
    assertEquals(0x3d, bytes[bytes.length - 16 - 6 - ggepLen]);
    assertEquals(0x31, bytes[bytes.length - 16 - 5 - ggepLen]);
    qr = (QueryReply) Message.read(new ByteArrayInputStream(bytes));
    assertEquals("String_Node_Str", qr.getVendor());
    assertTrue(qr.getNeedsPush());
    assertFalse(qr.getIsBusy());
    assertFalse(qr.getHadSuccessfulUpload());
    assertTrue(qr.getIsMeasuredSpeed());
    assertFalse(qr.getSupportsChat());
    assertTrue(qr.getSupportsBrowseHost());
    assertTrue(!qr.isReplyToMulticastQuery());
    responses = new Response[2];
    responses[0] = new Response(11, 22, "String_Node_Str");
    responses[1] = new Response(0x2FF2, 0xF11F, "String_Node_Str");
    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, true, false, false, true, false, true);
    assertEquals("String_Node_Str", qr.getVendor());
    assertTrue(qr.getNeedsPush());
    assertFalse(qr.getIsBusy());
    assertFalse(qr.getHadSuccessfulUpload());
    assertTrue(qr.getIsMeasuredSpeed());
    assertFalse(qr.getSupportsChat());
    assertTrue(qr.getSupportsBrowseHost());
    assertTrue(qr.isReplyToMulticastQuery());
    out = new ByteArrayOutputStream();
    qr.write(out);
    bytes = out.toByteArray();
    ggepLen = _ggepUtil.getQRGGEP(true, true).length;
    assertEquals(bytes.length, (23 + 11 + 16) + (8 + 10 + 2) + (8 + 14 + 2) + (4 + 1 + QueryReply.COMMON_PAYLOAD_LEN + 1 + 1) + ggepLen);
    assertEquals(bytes[bytes.length - 16 - 6 - ggepLen], 0x3d);
    assertEquals(bytes[bytes.length - 16 - 5 - ggepLen], 0x31);
    qr = (QueryReply) Message.read(new ByteArrayInputStream(bytes));
    assertEquals("String_Node_Str", qr.getVendor());
    assertTrue(qr.getNeedsPush());
    assertFalse(qr.getIsBusy());
    assertFalse(qr.getHadSuccessfulUpload());
    assertTrue(qr.getIsMeasuredSpeed());
    assertFalse(qr.getSupportsChat());
    assertTrue(qr.getSupportsBrowseHost());
    assertTrue(qr.isReplyToMulticastQuery());
    responses = new Response[2];
    responses[0] = new Response(11, 22, "String_Node_Str");
    responses[1] = new Response(0x2FF2, 0xF11F, "String_Node_Str");
    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, false);
    try {
        qr.getVendor();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getNeedsPush();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getIsBusy();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getHadSuccessfulUpload();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
    try {
        qr.getIsMeasuredSpeed();
        fail("String_Node_Str");
    } catch (BadPacketException e) {
    }
}

Output:
     responses[1] = new Response(0x2FF2, 0xF11F, "String_Node_Str");
-    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, true, false, false, true, false, true);
+    qr = new QueryReply(guid, (byte) 5, 0xFFFF, ip, u4, responses, guid, true, false, false, true, false, false);
     assertEquals("String_Node_Str", qr.getVendor());


Input:
private int getSamplesIndex(final int index) {
    int realIndex = index;
    int channelPartIndex = 0;
    while (channelPartIndex < this.channelParts.size() && realIndex > this.channelParts.get(channelPartIndex).getSamplesLength()) {
        realIndex -= this.channelParts.get(channelPartIndex).getSamplesLength();
        channelPartIndex++;
    }
    return realIndex;
}

Output:
     int channelPartIndex = 0;
-    while (channelPartIndex < this.channelParts.size() && realIndex > this.channelParts.get(channelPartIndex).getSamplesLength()) {
+    while (channelPartIndex < this.channelParts.size() && realIndex >= this.channelParts.get(channelPartIndex).getSamplesLength()) {
         realIndex -= this.channelParts.get(channelPartIndex).getSamplesLength();


Input:
public boolean incrementToken() throws IOException {
    if (tailBuffer == null && !input.incrementToken()) {
        return false;
    }
    final char[] buffer = termAtt.buffer();
    if (tailBuffer != null) {
        System.arraycopy(tailBuffer, 0, buffer, 0, tailBuffer.length);
        termAtt.setLength(tailBuffer.length);
        tailBuffer = null;
    }
    int entityType = isEntity(termAtt.toString());
    if (entityType == VALID_URL) {
        keywordAttr.setKeyword(true);
        return true;
    }
    for (int i = 0; i < termAtt.length(); i++) {
        buffer[i] = Character.toLowerCase(buffer[i]);
    }
    if (entityType != INVALID_ENTITY) {
        if (isEntityDelimiter(0)) {
            keywordAttr.setKeyword(true);
            return true;
        }
        for (int i = 0; i < termAtt.length(); i++) {
            if (isEntityDelimiter(i)) {
                tailBuffer = Arrays.copyOfRange(buffer, i, termAtt.length());
                termAtt.setLength(i);
                break;
            }
        }
    } else {
        for (int i = 0; i < termAtt.length(); i++) {
            if (isNonentityDelimiter(i)) {
                tailBuffer = Arrays.copyOfRange(buffer, i + 1, termAtt.length());
                termAtt.setLength(i);
                break;
            }
        }
        if (isEntity(termAtt.toString()) != INVALID_ENTITY) {
            keywordAttr.setKeyword(true);
            return true;
        }
        for (int i = 0; i < termAtt.length(); i++) {
            if (isEntityDelimiter(i)) {
                tailBuffer = Arrays.copyOfRange(buffer, i + 1, termAtt.length());
                termAtt.setLength(i);
                break;
            }
        }
    }
    removeNonAlphanumeric();
    return true;
}

Output:
 public boolean incrementToken() throws IOException {
-    if (tailBuffer == null && !input.incrementToken()) {
+    if (tailBuffer == null && tailBufferSaved == null && !input.incrementToken()) {
         return false;


Input:
public void startRequest(final OSDRequest rq) {
    final readRequest args = (readRequest) rq.getRequestArgs();
    if (args.getObject_number() < 0) {
        rq.sendException(new OSDException(ErrorCodes.INVALID_PARAMS, "String_Node_Str", "String_Node_Str"));
        return;
    }
    if (args.getOffset() < 0) {
        rq.sendException(new OSDException(ErrorCodes.INVALID_PARAMS, "String_Node_Str", "String_Node_Str"));
        return;
    }
    if (args.getLength() < 0) {
        rq.sendException(new OSDException(ErrorCodes.INVALID_PARAMS, "String_Node_Str", "String_Node_Str"));
        return;
    }
    master.getStorageStage().readObject(args.getFile_id(), args.getObject_number(), rq.getLocationList().getLocalReplica().getStripingPolicy(), rq, new ReadObjectCallback() {

        public void readComplete(ObjectInformation result, Exception error) {
            step2(rq, args, result, error);
        }
    });
}

Output:
     }
-    master.getStorageStage().readObject(args.getFile_id(), args.getObject_number(), rq.getLocationList().getLocalReplica().getStripingPolicy(), rq, new ReadObjectCallback() {
+    final StripingPolicyImpl sp = rq.getLocationList().getLocalReplica().getStripingPolicy();
+    if (args.getLength() + args.getOffset() > sp.getStripeSizeForObject(0)) {
+        rq.sendException(new OSDException(ErrorCodes.INVALID_PARAMS, "String_Node_Str" + sp.getStripeSizeForObject(0) + "String_Node_Str", "String_Node_Str"));
+        return;
+    }
+    master.getStorageStage().readObject(args.getFile_id(), args.getObject_number(), sp, rq, new ReadObjectCallback() {


Input:
public void testCursorModel3() throws OLAPException, BirtException {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(CubeUtility.cubeName);
    cqd.createMeasure("String_Node_Str");
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    hier2.createLevel("String_Node_Str");
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor();
    EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();
    DimensionCursor productCursor1 = (DimensionCursor) rowCursor.getDimensionCursor().get(0);
    DimensionCursor productCursor2 = (DimensionCursor) rowCursor.getDimensionCursor().get(1);
    testOut.print(creator.printCubeAlongDimension(dataCursor, null, null, null, null, productCursor1, productCursor2));
    try {
        this.checkOutputFile();
    } catch (Exception e) {
        fail("String_Node_Str");
    }
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor();
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign());
     EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();


Input:
public DependencyDescription next() {
    next = successor();
    return next;
}

Output:
 public DependencyDescription next() {
-    next = successor();
+    DependencyDescription next = successor();
     return next;


Input:
private void executeCommand(Command cmd) {
    if (cmd != null) {
        boolean exec = false;
        if (processContext != null && processContext.getProcess() instanceof IProcess2) {
            IProcess2 process = (IProcess2) processContext.getProcess();
            if (process != null) {
                CommandStack commandStack = process.getCommandStack();
                if (commandStack != null) {
                    exec = true;
                    commandStack.execute(cmd);
                }
            }
        }
        if (!exec) {
            cmd.execute();
        }
    }
}

Output:
         if (processContext != null && processContext.getProcess() instanceof IProcess2) {
-            IProcess2 process = (IProcess2) processContext.getProcess();
+            IProcess2 process = processContext.getProcess();
             if (process != null) {


Input:
public boolean processRequest(RequestEvent requestEvent) {
    synchronized (messageProcessors) {
        Iterator iter = messageProcessors.iterator();
        while (iter.hasNext()) {
            SipMessageProcessor listener = (SipMessageProcessor) iter.next();
            if (!listener.processMessage(requestEvent))
                return true;
        }
    }
    String content = null;
    Request req = requestEvent.getRequest();
    try {
        content = new String(req.getRawContent(), getCharset(req));
    } catch (UnsupportedEncodingException ex) {
        logger.debug("String_Node_Str");
        content = new String(requestEvent.getRequest().getRawContent());
    }
    FromHeader fromHeader = (FromHeader) requestEvent.getRequest().getHeader(FromHeader.NAME);
    if (fromHeader == null) {
        logger.error("String_Node_Str");
        return false;
    }
    Contact from = opSetPersPresence.resolveContactID(fromHeader.getAddress().getURI().toString());
    ContentTypeHeader ctheader = (ContentTypeHeader) req.getHeader(ContentTypeHeader.NAME);
    String ctype = null;
    String cencoding = null;
    if (ctheader == null) {
        ctype = DEFAULT_MIME_TYPE;
    } else {
        ctype = ctheader.getContentType() + "String_Node_Str" + ctheader.getContentSubType();
        cencoding = ctheader.getParameter("String_Node_Str");
    }
    if (cencoding == null)
        cencoding = DEFAULT_MIME_ENCODING;
    Message newMessage = createMessage(content, ctype, cencoding, null);
    if (from == null) {
        logger.debug("String_Node_Str" + fromHeader.getAddress().getURI().toString());
        from = opSetPersPresence.createVolatileContact(fromHeader.getAddress());
    }
    try {
        Response ok = sipProvider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest());
        SipProvider jainSipProvider = (SipProvider) requestEvent.getSource();
        jainSipProvider.getNewServerTransaction(requestEvent.getRequest()).sendResponse(ok);
    } catch (ParseException exc) {
        logger.error("String_Node_Str", exc);
    } catch (SipException exc) {
        logger.error("String_Node_Str" + exc.getMessage(), exc);
    } catch (InvalidArgumentException exc) {
        logger.debug("String_Node_Str" + exc.getMessage(), exc);
    }
    MessageReceivedEvent msgReceivedEvt = new MessageReceivedEvent(newMessage, from, System.currentTimeMillis());
    fireMessageEvent(msgReceivedEvt);
    return true;
}

Output:
         Response ok = sipProvider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest());
-        SipProvider jainSipProvider = (SipProvider) requestEvent.getSource();
-        jainSipProvider.getNewServerTransaction(requestEvent.getRequest()).sendResponse(ok);
+        SipStackSharing.getOrCreateServerTransaction(requestEvent).sendResponse(ok);
     } catch (ParseException exc) {


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
        int creaturesControlled = game.getBattlefield().countAll(new FilterCreaturePermanent(), controller.getId(), game);
        controller.drawCards(creaturesControlled, game);
        controller.loseLife(creaturesControlled, game);
        return true;
    }
    return false;
}

Output:
         controller.drawCards(creaturesControlled, game);
-        controller.loseLife(creaturesControlled, game);
+        controller.loseLife(creaturesControlled, game, false);
         return true;


Input:
private void buildPoolLayer(final GL gl) {
    for (int iViewIndex = 0; iViewIndex < poolLayer.getCapacity(); iViewIndex++) {
        Transform transform = new Transform();
        transform.setTranslation(new Vec3f(4.1f, 0.1f * iViewIndex, 4));
        transform.setScale(new Vec3f(SCALING_FACTOR_POOL_LAYER, SCALING_FACTOR_POOL_LAYER, SCALING_FACTOR_POOL_LAYER));
        poolLayer.setTransformByPositionIndex(iViewIndex, transform);
    }
}

Output:
         Transform transform = new Transform();
-        transform.setTranslation(new Vec3f(4.1f, 0.1f * iViewIndex, 4));
+        transform.setTranslation(new Vec3f(4.1f, 0.2f * iViewIndex, 4));
         transform.setScale(new Vec3f(SCALING_FACTOR_POOL_LAYER, SCALING_FACTOR_POOL_LAYER, SCALING_FACTOR_POOL_LAYER));


Input:
public static void main(String[] args) throws IOException, GeneralSecurityException {
    PipelineOptionsFactory.register(Options.class);
    Options options = PipelineOptionsFactory.fromArgs(args).withValidation().as(Options.class);
    Options.Methods.validateOptions(options);
    StreamVariantsRequest prototype = CallSetNamesOptions.Methods.getRequestPrototype(options);
    OfflineAuth auth = GenomicsOptions.Methods.getGenomicsAuth(options);
    ImmutableSet<String> callSetIds = ImmutableSet.<String>builder().addAll(CallSetNamesOptions.Methods.getCallSetIds(options)).build();
    LOG.info("String_Node_Str" + "String_Node_Str" + callSetIds.size() + "String_Node_Str" + callSetIds);
    if (options.getIdentifyVariantsWithoutCalls()) {
        LOG.info("String_Node_Str");
    }
    List<StreamVariantsRequest> shardRequests = options.isAllReferences() ? ShardUtils.getVariantRequests(prototype, ShardUtils.SexChromosomeFilter.INCLUDE_XY, options.getBasesPerShard(), auth) : ShardUtils.getVariantRequests(prototype, options.getBasesPerShard(), options.getReferences());
    Pipeline p = Pipeline.create(options);
    PCollection<Variant> variants = p.begin().apply(Create.of(shardRequests)).apply(new VariantStreamer(auth, ShardBoundary.Requirement.STRICT, VARIANT_FIELDS)).apply(ParDo.of(new PrivateVariantsFilterFn(callSetIds, options.getIdentifyVariantsWithoutCalls())));
    variants.apply(ParDo.named("String_Node_Str").of(new DoFn<Variant, String>() {
        public void processElement(ProcessContext c) {
            Variant v = c.element();
            c.output(Joiner.on("String_Node_Str").join(v.getId(), v.getReferenceName(), v.getStart(), v.getEnd(), v.getReferenceBases(), Joiner.on("String_Node_Str").join(v.getAlternateBasesList())));
        }
    })).apply(TextIO.Write.to(options.getOutput()));
    p.run();
}

Output:
     Options.Methods.validateOptions(options);
-    StreamVariantsRequest prototype = CallSetNamesOptions.Methods.getRequestPrototype(options);
+    StreamVariantsRequest prototype = StreamVariantsRequest.newBuilder(CallSetNamesOptions.Methods.getRequestPrototype(options)).clearCallSetIds().build();
     OfflineAuth auth = GenomicsOptions.Methods.getGenomicsAuth(options);


Input:
public static TerminalConsoleAppender createAppender(String name, Filter filter, Layout<? extends Serializable> layout, String ignore) {
    if (name == null) {
        LOGGER.error("String_Node_Str");
        return null;
    }
    if (layout == null) {
        layout = PatternLayout.createLayout(null, null, null, null, null);
    }
    boolean ignoreExceptions = parseBoolean(ignore, true);
    return new TerminalConsoleAppender(name, filter, layout, ignoreExceptions);
}

Output:
     if (layout == null) {
-        layout = PatternLayout.createLayout(null, null, null, null, null);
+        layout = PatternLayout.createLayout(null, null, null, null, null, true, false, null, null);
     }


Input:
public static void registerMessages() {
    INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel("String_Node_Str");
    INSTANCE.registerMessage(PacketRFMonitor.class, PacketRFMonitor.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetAdjacentBlocks.class, PacketGetAdjacentBlocks.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketCrafter.class, PacketCrafter.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetInventory.class, PacketGetInventory.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketSearchItems.class, PacketSearchItems.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetConnectedBlocks.class, PacketGetConnectedBlocks.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetTransmitters.class, PacketGetTransmitters.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetReceivers.class, PacketGetReceivers.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketServerCommand.class, PacketServerCommand.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketRequestIntegerFromServer.class, PacketRequestIntegerFromServer.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetAllReceivers.class, PacketGetAllReceivers.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketForceTeleport.class, PacketForceTeleport.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetPlayers.class, PacketGetPlayers.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetFilters.class, PacketGetFilters.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketGetDelightingInfo.class, PacketGetDelightingInfo.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketReturnEnergy.class, PacketReturnEnergy.class, nextID(), Side.SERVER);
    INSTANCE.registerMessage(PacketInventoryReady.class, PacketInventoryReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketSearchReady.class, PacketSearchReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketAdjacentBlocksReady.class, PacketAdjacentBlocksReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketConnectedBlocksReady.class, PacketConnectedBlocksReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketTransmittersReady.class, PacketTransmittersReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketReceiversReady.class, PacketReceiversReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketIntegerFromServer.class, PacketIntegerFromServer.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketAllReceiversReady.class, PacketAllReceiversReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketPlayersReady.class, PacketPlayersReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketFiltersReady.class, PacketFiltersReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketDelightingInfoReady.class, PacketDelightingInfoReady.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketSyncDimensionInfo.class, PacketSyncDimensionInfo.class, nextID(), Side.CLIENT);
    INSTANCE.registerMessage(PacketGetDimensionEnergy.class, PacketGetDimensionEnergy.class, nextID(), Side.CLIENT);
}

Output:
     INSTANCE.registerMessage(PacketGetDelightingInfo.class, PacketGetDelightingInfo.class, nextID(), Side.SERVER);
-    INSTANCE.registerMessage(PacketReturnEnergy.class, PacketReturnEnergy.class, nextID(), Side.SERVER);
+    INSTANCE.registerMessage(PacketGetDimensionEnergy.class, PacketGetDimensionEnergy.class, nextID(), Side.SERVER);
     INSTANCE.registerMessage(PacketInventoryReady.class, PacketInventoryReady.class, nextID(), Side.CLIENT);


Input:
public boolean logout() throws LoginException {
    ssl = null;
    sslUtils.setAppclientSsl(ssl);
    subject.getPrincipals().remove(userPrincipal);
    succeeded = false;
    succeeded = commitSucceeded;
    alias = null;
    userPrincipal = null;
    return true;
}

Output:
     succeeded = false;
-    succeeded = commitSucceeded;
+    commitSucceeded = false;
     alias = null;


Input:
private Object[] getPredefinedExpressionsForSharing(ColumnBindingInfo[] headers) {
    Map<String, ColumnBindingInfo> commons = new LinkedHashMap<String, ColumnBindingInfo>();
    Map<String, ColumnBindingInfo> aggs = new LinkedHashMap<String, ColumnBindingInfo>();
    Map<String, ColumnBindingInfo> groups = new LinkedHashMap<String, ColumnBindingInfo>();
    Map<String, ColumnBindingInfo> groupsWithAgg = new LinkedHashMap<String, ColumnBindingInfo>();
    Map<String, ColumnBindingInfo> groupsWithoutAgg;
    for (int i = 0; i < headers.length; i++) {
        int type = headers[i].getColumnType();
        switch(type) {
            case ColumnBindingInfo.COMMON_COLUMN:
                commons.put(ExpressionUtil.createJSRowExpression(headers[i].getName()), headers[i]);
                break;
            case ColumnBindingInfo.AGGREGATE_COLUMN:
                aggs.put(ExpressionUtil.createJSRowExpression(headers[i].getName()), headers[i]);
                break;
            case ColumnBindingInfo.GROUP_COLUMN:
                groups.put(ExpressionUtil.createJSRowExpression(headers[i].getName()), headers[i]);
                break;
        }
    }
    groupsWithoutAgg = new LinkedHashMap<String, ColumnBindingInfo>(groups);
    for (Iterator<Entry<String, ColumnBindingInfo>> iter = groupsWithoutAgg.entrySet().iterator(); iter.hasNext(); ) {
        Entry<String, ColumnBindingInfo> entry = iter.next();
        String groupName = entry.getValue().getName();
        ColumnBindingInfo[] aggsValues = aggs.values().toArray(new ColumnBindingInfo[] {});
        for (int j = 0; j < aggs.size(); j++) {
            if (groupName.equals(((ComputedColumnHandle) aggsValues[j].getObjectHandle()).getAggregateOn())) {
                iter.remove();
                groupsWithAgg.put(entry.getKey(), entry.getValue());
                break;
            }
        }
    }
    Object[][] categorys = new Object[0][];
    Object[][] optionals = new Object[0][];
    categorys = new Object[groups.size() + commons.size()][2];
    int index = 0;
    for (Entry<String, ColumnBindingInfo> entry : groups.entrySet()) {
        categorys[index][0] = entry.getKey();
        categorys[index][1] = entry.getValue();
        index++;
    }
    for (Entry<String, ColumnBindingInfo> entry : commons.entrySet()) {
        categorys[index][0] = entry.getKey();
        categorys[index][1] = entry.getValue();
        index++;
    }
    if (isInheritColumnsGroups()) {
        Map<String, ColumnBindingInfo> g = new LinkedHashMap<String, ColumnBindingInfo>(2);
        DesignElementHandle reh = itemHandle;
        while (reh != null) {
            if (reh.getContainer() instanceof TableGroupHandle) {
                reh = reh.getContainer();
                for (Entry<String, ColumnBindingInfo> e : groups.entrySet()) {
                    g.put(e.getKey(), e.getValue());
                    if (reh.getName().equals(e.getValue().getName())) {
                        break;
                    }
                }
                break;
            } else if (reh.getContainer() instanceof RowHandle && reh.getContainer() != null && !(reh.getContainer().getContainer() instanceof TableGroupHandle)) {
                DesignElementHandle deh = reh;
                while (deh != null) {
                    if (deh.getContainer() instanceof ListingHandle) {
                        deh = deh.getContainer();
                        break;
                    }
                    deh = deh.getContainer();
                }
                if (deh != null && deh instanceof ListingHandle) {
                    if (((ListingHandle) deh).getDetail().findPosn(reh.getContainer()) >= 0) {
                        g = groups;
                    } else if (((ListingHandle) deh).getHeader().findPosn(reh.getContainer()) >= 0) {
                        String key = groups.keySet().toArray(new String[] {})[0];
                        g.put(key, groups.get(key));
                    }
                }
                break;
            } else if (reh.getContainer() instanceof ListingHandle) {
                reh = null;
                break;
            }
            reh = reh.getContainer();
        }
        optionals = new Object[g.size()][2];
        int i = 0;
        for (Entry<String, ColumnBindingInfo> e : g.entrySet()) {
            optionals[i][0] = e.getKey();
            optionals[i++][1] = e.getValue();
        }
    } else {
        int size = (groups.size() > 0) ? 1 : 0;
        optionals = new Object[size][2];
        if (groups.size() > 0) {
            Entry<String, ColumnBindingInfo> entry = groups.entrySet().iterator().next();
            ;
            optionals[0][0] = entry.getKey();
            optionals[0][1] = entry.getValue();
        }
    }
    Object[][] values = new Object[aggs.size() + commons.size()][2];
    index = 0;
    for (Entry<String, ColumnBindingInfo> entry : aggs.entrySet()) {
        values[index][0] = entry.getKey();
        values[index][1] = entry.getValue();
        index++;
    }
    for (Entry<String, ColumnBindingInfo> entry : commons.entrySet()) {
        values[index][0] = entry.getKey();
        values[index][1] = entry.getValue();
        index++;
    }
    return new Object[] { categorys, optionals, values };
}

Output:
     }
-    if (isInheritColumnsGroups()) {
+    if (isInheritColumnsGroups() && groups.size() > 0) {
         Map<String, ColumnBindingInfo> g = new LinkedHashMap<String, ColumnBindingInfo>(2);


Input:
private void options() {
    final JFrame popup = new JFrame("String_Node_Str");
    popup.setSize(300, 160);
    popup.setLocationRelativeTo(null);
    popup.setLayout(new FlowLayout());
    popup.setResizable(false);
    final JButton squareButton = new JButton("String_Node_Str");
    squareButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            squareOptions();
            popup.dispose();
        }
    });
    popup.add(squareButton);
    final JButton makePiece = new JButton("String_Node_Str");
    makePiece.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            if (square.isHabitable()) {
                askForPiece();
            } else {
                JOptionPane.showMessageDialog(popup, "String_Node_Str");
            }
            popup.dispose();
        }
    });
    popup.add(makePiece);
    final JButton removePiece = new JButton("String_Node_Str");
    removePiece.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            square.setPiece(null);
            square.refresh();
            popup.dispose();
        }
    });
    if (square.isOccupied())
        removePiece.setEnabled(true);
    else
        removePiece.setEnabled(false);
    popup.add(removePiece);
    popup.setVisible(true);
}

Output:
     final JFrame popup = new JFrame("String_Node_Str");
-    popup.setSize(300, 160);
+    popup.setSize(300, 90);
     popup.setLocationRelativeTo(null);


Input:
public boolean dropAllIndexes() {
    ImmutableOpenMap<String, ImmutableOpenMap<String, AliasMetaData>> indexes = this.client.admin().cluster().prepareState().execute().actionGet().getState().getMetaData().aliases();
    return false;
}

Output:
 public boolean dropAllIndexes() {
-    ImmutableOpenMap<String, ImmutableOpenMap<String, AliasMetaData>> indexes = this.client.admin().cluster().prepareState().execute().actionGet().getState().getMetaData().aliases();
-    return false;
+    boolean result = true;
+    ImmutableOpenMap<String, IndexMetaData> indexes = this.client.admin().cluster().prepareState().execute().actionGet().getState().getMetaData().getIndices();
+    for (String indexName : indexes.keys().toArray(String.class)) {
+        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indexName);
+        DeleteIndexResponse res = this.client.admin().indices().delete(deleteIndexRequest).actionGet();
+        result = indexExists(indexName);
+    }
+    return result;
 }


Input:
public void checkComfirmProcotol() {
    System.out.println("String_Node_Str");
    AndroidElement element = mDriver.findElement(By.id("String_Node_Str"));
    element.click();
    WaitUtil.implicitlyWait(1);
}

Output:
 public void checkComfirmProcotol() {
-    System.out.println("String_Node_Str");
+    WaitUtil.implicitlyWait(5);
+    LogUtil.printCurrentMethodName();
     AndroidElement element = mDriver.findElement(By.id("String_Node_Str"));


Input:
private void unlockDatabase(String password) {
    try {
        mDbHelper.open(password);
        if (dataStream != null)
            importDataStream();
        else
            fillData();
    } catch (Exception e) {
        Toast.makeText(this, "String_Node_Str", Toast.LENGTH_LONG).show();
        showPassword();
    }
}

Output:
     } catch (Exception e) {
-        Toast.makeText(this, "String_Node_Str", Toast.LENGTH_LONG).show();
+        Toast.makeText(this, getString(R.string.err_pin), Toast.LENGTH_LONG).show();
         showPassword();


Input:
public Coord2D getMiddle() {
    return (new Coord2D((ne_1quadrant.getY() + sw_3quadrant.getY()) / 2, (ne_1quadrant.getX() + sw_3quadrant.getX()) / 2));
}

Output:
 public Coord2D getMiddle() {
-    return (new Coord2D((ne_1quadrant.getY() + sw_3quadrant.getY()) / 2, (ne_1quadrant.getX() + sw_3quadrant.getX()) / 2));
+    return (new Coord2D((ne_1quadrant.getX() + sw_3quadrant.getX()) / 2, (ne_1quadrant.getY() + sw_3quadrant.getY()) / 2));
 }


Input:
public void onRotate(RotateEvent rot) {
    Entity et = rot.getThisEntity();
    int agentID = et.get(AgentIdentifiers.class).agentID;
    Direction dir = et.get(Direction.class);
    dir.direction = rot.getNewDirection();
    float rotation = dir.direction.toRotation();
    for (Session session : lookupTable.getAllSessions()) {
        MovementView.sendRotateAgent(session, agentID, rotation);
    }
}

Output:
     Direction dir = et.get(Direction.class);
-    dir.direction = rot.getNewDirection();
+    dir.direction = rot.getNewDirection().getUnit();
     float rotation = dir.direction.toRotation();


Input:
private Object populateViaThrift(EntityMetadata m, Object entity, EntityType entityType, List<String> relationNames, Map<String, Object> relations, String thriftColumnName, Object thriftColumnValue, boolean isCql3Enabled) throws InstantiationException, IllegalAccessException {
    if (relationNames == null || !relationNames.contains(thriftColumnName)) {
        if (thriftColumnValue != null) {
            MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(m.getPersistenceUnit());
            String fieldName = m.getFieldName(thriftColumnName);
            Attribute attribute = fieldName != null ? entityType.getAttribute(fieldName) : null;
            if (attribute != null) {
                entity = KunderaCoreUtils.initialize(m, entity, null);
                if (!attribute.isAssociation()) {
                    String idColumnName = ((AbstractAttribute) m.getIdAttribute()).getJPAColumnName();
                    if (!metaModel.isEmbeddable(m.getIdAttribute().getBindableJavaType()) && thriftColumnName.equals(idColumnName)) {
                        setId(m, entity, thriftColumnValue, isCql3Enabled);
                        PropertyAccessorHelper.setId(entity, m, (byte[]) thriftColumnValue);
                    }
                    if (isCql3Enabled && !m.isCounterColumnType()) {
                        if (metaModel.isEmbeddable(((AbstractAttribute) attribute).getBindableJavaType())) {
                            if (attribute.isCollection()) {
                                entity = setElementCollection(entity, thriftColumnValue, metaModel, attribute);
                            } else {
                                entity = setUdtValue(entity, thriftColumnValue, metaModel, attribute);
                            }
                        } else {
                            setFieldValueViaCQL(entity, thriftColumnValue, attribute);
                        }
                    } else {
                        setFieldValue(entity, thriftColumnValue, attribute);
                    }
                }
            } else if (metaModel.isEmbeddable(((AbstractAttribute) m.getIdAttribute()).getBindableJavaType())) {
                entity = populateCompositeId(m, entity, thriftColumnName, thriftColumnValue, metaModel, m.getIdAttribute(), m.getEntityClazz());
            } else if (clientBase.getCqlMetadata() != null) {
                if (entity == null) {
                    entity = new HashMap();
                }
                if (entity instanceof HashMap) {
                    composeAndAdd((HashMap) entity, clientBase.getCqlMetadata(), thriftColumnValue, thriftColumnName);
                }
            }
        }
    } else {
        if (relationNames != null && relationNames.contains(thriftColumnName) && thriftColumnValue != null) {
            String fieldName = m.getFieldName(thriftColumnName);
            Attribute attribute = fieldName != null ? entityType.getAttribute(fieldName) : null;
            EntityMetadata relationMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, ((AbstractAttribute) attribute).getBindableJavaType());
            Object value;
            if (isCql3Enabled && !m.getType().equals(Type.SUPER_COLUMN_FAMILY)) {
                value = getFieldValueViaCQL(thriftColumnValue, relationMetadata.getIdAttribute());
            } else {
                value = PropertyAccessorHelper.getObject(relationMetadata.getIdAttribute().getJavaType(), (byte[]) thriftColumnValue);
            }
            relations.put(thriftColumnName, value);
            if (entity == null) {
                entity = KunderaCoreUtils.initialize(m, entity, null);
            }
        }
    }
    return entity;
}

Output:
                 }
-            } else if (metaModel.isEmbeddable(((AbstractAttribute) m.getIdAttribute()).getBindableJavaType())) {
+            } else if (metaModel.isEmbeddable(((AbstractAttribute) m.getIdAttribute()).getBindableJavaType()) && !isAggregate(thriftColumnName)) {
                 entity = populateCompositeId(m, entity, thriftColumnName, thriftColumnValue, metaModel, m.getIdAttribute(), m.getEntityClazz());


Input:
public void createControl(Composite parent) {
    ChartUIUtil.bindHelp(parent, ChartHelpContextIds.SUBTASK_AXIS);
    final int COLUMN_NUMBER = 4;
    cmpContent = new Composite(parent, SWT.NONE) {
        public Point computeSize(int wHint, int hHint, boolean changed) {
            Point p = super.computeSize(wHint, hHint, changed);
            p.y = 200;
            return p;
        }
    };
    {
        GridLayout glContent = new GridLayout(1, false);
        glContent.horizontalSpacing = HORIZONTAL_SPACING;
        cmpContent.setLayout(glContent);
        GridData gd = new GridData(GridData.FILL_BOTH);
        cmpContent.setLayoutData(gd);
    }
    ScrolledComposite cmpScroll = new ScrolledComposite(cmpContent, SWT.V_SCROLL);
    {
        GridData gd = new GridData(GridData.FILL_BOTH);
        cmpScroll.setLayoutData(gd);
        cmpScroll.setMinHeight((ChartUIUtil.getOrthogonalAxisNumber(getChart()) + (ChartUIUtil.is3DType(getChart()) ? 2 : 1)) * 24 + 80);
        cmpScroll.setExpandVertical(true);
        cmpScroll.setExpandHorizontal(true);
    }
    Composite cmpList = new Composite(cmpScroll, SWT.NONE);
    {
        GridLayout glContent = new GridLayout(COLUMN_NUMBER, false);
        glContent.horizontalSpacing = 10;
        cmpList.setLayout(glContent);
        cmpScroll.setContent(cmpList);
    }
    Label lblAxis = new Label(cmpList, SWT.WRAP);
    {
        GridData gd = new GridData();
        gd.horizontalAlignment = SWT.CENTER;
        gd.widthHint = LABEL_WIDTH_HINT;
        lblAxis.setLayoutData(gd);
        lblAxis.setFont(JFaceResources.getBannerFont());
        lblAxis.setText(Messages.getString("String_Node_Str"));
    }
    Label lblVisible = new Label(cmpList, SWT.WRAP);
    {
        GridData gd = new GridData();
        gd.horizontalAlignment = SWT.CENTER;
        gd.widthHint = LABEL_WIDTH_HINT;
        lblVisible.setLayoutData(gd);
        lblVisible.setFont(JFaceResources.getBannerFont());
        lblVisible.setText(Messages.getString("String_Node_Str"));
    }
    Label lblType = new Label(cmpList, SWT.WRAP);
    {
        GridData gd = new GridData();
        gd.horizontalAlignment = SWT.CENTER;
        gd.widthHint = LABEL_WIDTH_HINT;
        lblType.setLayoutData(gd);
        lblType.setFont(JFaceResources.getBannerFont());
        lblType.setText(Messages.getString("String_Node_Str"));
    }
    Label lblColor = new Label(cmpList, SWT.WRAP);
    {
        GridData gd = new GridData();
        gd.horizontalAlignment = SWT.CENTER;
        gd.widthHint = LABEL_WIDTH_HINT;
        lblColor.setLayoutData(gd);
        lblColor.setFont(JFaceResources.getBannerFont());
        lblColor.setText(Messages.getString("String_Node_Str"));
    }
    int treeIndex = 0;
    new AxisOptionChoser(ChartUIUtil.getAxisXForProcessing((ChartWithAxes) getChart()), Messages.getString("String_Node_Str"), AngleType.X, treeIndex++).placeComponents(cmpList);
    int yaxisNumber = ChartUIUtil.getOrthogonalAxisNumber(getChart());
    for (int i = 0; i < yaxisNumber; i++) {
        String text = Messages.getString("String_Node_Str");
        new AxisOptionChoser(ChartUIUtil.getAxisYForProcessing((ChartWithAxes) getChart(), i), yaxisNumber == 1 ? text : (text + "String_Node_Str" + (i + 1)), AngleType.Y, treeIndex++).placeComponents(cmpList);
    }
    if (ChartUIUtil.is3DType(getChart())) {
        new AxisOptionChoser(ChartUIUtil.getAxisZForProcessing((ChartWithAxes) getChart()), Messages.getString("String_Node_Str"), AngleType.Z, treeIndex++).placeComponents(cmpList);
    }
}

Output:
     }
-    Label lblVisible = new Label(cmpList, SWT.WRAP);
+    Label lblVisible = new Label(cmpList, SWT.WRAP | SWT.CENTER);
     {