Input:
private String fullContent(Notification notification, Context context, List<String> texts, String text) {
    LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    ViewGroup localView = (ViewGroup) inflater.inflate(notification.bigContentView.getLayoutId(), null);
    notification.bigContentView.reapply(context.getApplicationContext(), localView);
    ArrayList<View> allChildren = getAllChildren(localView);
    String viewTexts = "String_Node_Str";
    for (View view : allChildren) {
        if (view instanceof TextView) {
            Mlog.d(logTag, view.getClass().getSimpleName());
            String mText = String.valueOf(((TextView) view).getText());
            Mlog.d(logTag, mText);
            if (!mText.equals(texts.get(0)) && mText.length() > 1 && !mText.matches("String_Node_Str") && !view.getClass().getSimpleName().equals("String_Node_Str")) {
                if (mText.startsWith(texts.get(0))) {
                    mText = mText.substring(texts.get(0).length());
                    if (mText.startsWith("String_Node_Str"))
                        mText = mText.substring(1);
                    if (mText.startsWith("String_Node_Str"))
                        mText = mText.substring("String_Node_Str".length());
                    if (mText.startsWith("String_Node_Str"))
                        mText = mText.substring("String_Node_Str".length());
                }
                Mlog.d(logTag, mText);
                viewTexts = viewTexts.concat(mText).concat("String_Node_Str");
            }
        }
    }
    if (viewTexts.length() > 1 && viewTexts.length() > text.length()) {
        if (viewTexts.startsWith("String_Node_Str"))
            viewTexts = viewTexts.substring("String_Node_Str".length());
        Mlog.d(logTag, viewTexts);
        return viewTexts.substring(0, viewTexts.length() - 1);
    }
    return null;
}

Output:
     }
-    if (viewTexts.length() > 1 && viewTexts.length() > text.length()) {
+    viewTexts = viewTexts.trim();
+    if (viewTexts.length() > 1 && viewTexts.length() > 3) {
         if (viewTexts.startsWith("String_Node_Str"))


Input:
public synchronized void init(RequestContext context) throws InvalidBatchException, InvalidRequestException {
    if (this.batch != null) {
        throw new InvalidRequestException("String_Node_Str");
    }
    this.context = context;
    this.cid = context.getRequestMessage().getCommand().getHeader().getConnectionID();
    this.batchId = context.getRequestMessage().getCommand().getHeader().getBatchID();
    try {
        batch = engine.getStore().createBatchOperation();
    } catch (KVStoreException e) {
        throw new InvalidBatchException(e);
    }
}

Output:
     if (this.batch != null) {
-        throw new InvalidRequestException("String_Node_Str");
+        this.waitForBatchToFinish();
     }


Input:
public void should_parse_and_load_configuration_file_from_container_configuration_file_and_property_set_file() throws IOException {
    File newFile = testFolder.newFile("String_Node_Str");
    Files.write(Paths.get(newFile.toURI()), CONTENT.getBytes());
    File newFile2 = testFolder.newFile("String_Node_Str");
    Files.write(Paths.get(newFile2.toURI()), CONTENT2.getBytes());
    System.setProperty("String_Node_Str", "String_Node_Str");
    Map<String, String> parameters = new HashMap<String, String>();
    parameters.put("String_Node_Str", "String_Node_Str");
    parameters.put("String_Node_Str", "String_Node_Str");
    parameters.put("String_Node_Str", newFile.getAbsolutePath());
    CubeDockerConfiguration cubeConfiguration = CubeDockerConfiguration.fromMap(parameters);
    assertThat(cubeConfiguration.getDockerServerUri(), is("String_Node_Str"));
    assertThat(cubeConfiguration.getDockerServerVersion(), is("String_Node_Str"));
    Map<String, Object> dockerContainersContent = cubeConfiguration.getDockerContainersContent();
    Map<String, Object> actualTomcat = (Map<String, Object>) dockerContainersContent.get("String_Node_Str");
    assertThat(actualTomcat, is(notNullValue()));
    String image = (String) actualTomcat.get("String_Node_Str");
    assertThat(image, is("String_Node_Str"));
    assertThat(dockerContainersContent.containsKey("String_Node_Str"), is(true));
}

Output:
     parameters.put("String_Node_Str", "String_Node_Str");
-    parameters.put("String_Node_Str", newFile.getAbsolutePath());
+    parameters.put("String_Node_Str", newFile.toURI().toString());
     CubeDockerConfiguration cubeConfiguration = CubeDockerConfiguration.fromMap(parameters);


Input:
synchronized void flushRootObject(int rootObjectId) throws RepositoryException {
    Integer key = new Integer(rootObjectId);
    CacheRecord cacheRecord = (CacheRecord) rootObjectsById.get(key);
    if (cacheRecord != null) {
        flushRootObjectMap(cacheRecord.rootObjects);
    }
}

Output:
     Integer key = new Integer(rootObjectId);
-    CacheRecord cacheRecord = (CacheRecord) rootObjectsById.get(key);
+    CacheRecord cacheRecord = rootObjectsById.get(key);
     if (cacheRecord != null) {


Input:
public void onEnable() {
    INSTANCE = this;
    getLogger().info("String_Node_Str");
    serverObjectBuilder = new BukkitServerBridge(getLogger());
    plotme = new PlotMe_Core(serverObjectBuilder);
    getAPI().enable();
    doMetric();
    PluginManager pm = getServer().getPluginManager();
    pm.registerEvents(new BukkitPlotListener(), this);
    pm.registerEvents(new BukkitPlotDenyListener(), this);
    this.getCommand("String_Node_Str").setExecutor(new BukkitCommand(this));
}

Output:
     serverObjectBuilder = new BukkitServerBridge(getLogger());
-    plotme = new PlotMe_Core(serverObjectBuilder);
+    plotme = new PlotMe_Core();
+    plotme.registerServerBridge(serverObjectBuilder);
     getAPI().enable();


Input:
public void run() {
    while (!stop) {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            send();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:
         try {
-            Thread.sleep(2000);
+            Thread.sleep(SLEEP_DURATION);
         } catch (InterruptedException e) {


Input:
private void enteringEjbContainer() {
    if (interceptors == null)
        return;
    for (EjbContainerInterceptor interceptor : interceptors) {
        try {
            interceptor.preInvoke(ejbDescriptor);
        } catch (Throwable th) {
            _logger.log(Level.SEVERE, "String_Node_Str", th);
        }
    }
}

Output:
         } catch (Throwable th) {
-            _logger.log(Level.SEVERE, "String_Node_Str", th);
+            internal_logger.log(Level.SEVERE, INTERNAL_ERROR, th);
         }


Input:
private void setupWriter(Configuration configuration) throws IOException {
    TableDescriptor tableDescriptor = new TableDescriptor();
    tableDescriptor.setName("String_Node_Str");
    String uuid = UUID.randomUUID().toString();
    tableDescriptor.setTableUri(new Path(_base, "String_Node_Str").toUri().toString());
    tableDescriptor.setShardCount(2);
    TableContext tableContext = TableContext.create(tableDescriptor);
    ShardContext shardContext = ShardContext.create(tableContext, "String_Node_Str");
    Path tablePath = new Path(_base, "String_Node_Str");
    Path shardPath = new Path(tablePath, "String_Node_Str");
    String indexDirName = "String_Node_Str" + uuid;
    _path = new Path(shardPath, indexDirName + "String_Node_Str");
    _fileSystem.mkdirs(_path);
    _badRowIdsPath = new Path(shardPath, indexDirName + "String_Node_Str");
    Directory commitDirectory = new HdfsDirectory(configuration, _path);
    Directory mainDirectory = new HdfsDirectory(configuration, shardPath);
    _fieldManager = tableContext.getFieldManager();
    Analyzer analyzerForIndex = _fieldManager.getAnalyzerForIndex();
    IndexWriterConfig conf = new IndexWriterConfig(LUCENE_VERSION, analyzerForIndex);
    conf.setMergePolicy(NoMergePolicy.NO_COMPOUND_FILES);
    _commitWriter = new IndexWriter(commitDirectory, conf.clone());
    _mainWriter = new IndexWriter(mainDirectory, conf.clone());
    BufferStore.initNewBuffer(128, 128 * 128);
    _indexImporter = new IndexImporter(_mainWriter, new ReentrantReadWriteLock(), shardContext, TimeUnit.MINUTES, 10);
}

Output:
     BufferStore.initNewBuffer(128, 128 * 128);
-    _indexImporter = new IndexImporter(_mainWriter, new ReentrantReadWriteLock(), shardContext, TimeUnit.MINUTES, 10);
+    _indexImporter = new IndexImporter(getBlurIndex(shardContext, mainDirectory), shardContext, TimeUnit.MINUTES, 10);
 }


Input:
private Double getSum() {
    Double match = Double.parseDouble(getNumMatch());
    Double nomatch = Double.parseDouble(getNumNoMatch());
    return match + nomatch;
}

Output:
 private Double getSum() {
-    Double match = Double.parseDouble(getNumMatch());
-    Double nomatch = Double.parseDouble(getNumNoMatch());
-    return match + nomatch;
+    return getIndicator().getCount().doubleValue();
 }


Input:
public CalculationResultMap evaluate(Collection<Integer> cohort, Map<String, Object> parameterValues, PatientCalculationContext context) {
    Concept currentWhoStage = getConcept(Dictionary.CURRENT_WHO_STAGE);
    CalculationResultMap artStartDates = calculate(new InitialArtStartDateCalculation(), cohort, context);
    CalculationResultMap ret = new CalculationResultMap();
    for (Integer ptId : cohort) {
        SimpleResult result = null;
        Date artStartDate = EmrCalculationUtils.datetimeResultForPatient(artStartDates, ptId);
        if (artStartDate != null) {
            CalculationResultMap currentWhoStageObss = Calculations.lastObsOnOrBefore(currentWhoStage, artStartDate, Collections.singleton(ptId), context);
            Obs whoStageObs = EmrCalculationUtils.obsResultForPatient(currentWhoStageObss, ptId);
            if (whoStageObs != null) {
                result = new SimpleResult(EmrUtils.whoStage(whoStageObs.getValueCoded()), this);
            }
        }
        ret.put(ptId, result);
    }
    return ret;
}

Output:
             if (whoStageObs != null) {
-                result = new SimpleResult(EmrUtils.whoStage(whoStageObs.getValueCoded()), this);
+                Integer whoStage = EmrUtils.whoStage(whoStageObs.getValueCoded());
+                if (whoStage != null) {
+                    result = new SimpleResult(whoStage, this);
+                }
             }


Input:
public static Map getRelationWithMeasure(ICubeQueryDefinition queryDefn) throws DataException {
    Map measureRelationMap = new HashMap();
    List rowLevelList = new ArrayList();
    List columnLevelList = new ArrayList();
    if (queryDefn.getEdge(ICubeQueryDefinition.COLUMN_EDGE) != null) {
        ILevelDefinition[] levels = getLevelsOnEdge(queryDefn.getEdge(ICubeQueryDefinition.COLUMN_EDGE));
        for (int i = 0; i < levels.length; i++) {
            columnLevelList.add(new DimLevel(levels[i]));
        }
    }
    if (queryDefn.getEdge(ICubeQueryDefinition.ROW_EDGE) != null) {
        ILevelDefinition[] levels = getLevelsOnEdge(queryDefn.getEdge(ICubeQueryDefinition.ROW_EDGE));
        for (int i = 0; i < levels.length; i++) {
            rowLevelList.add(new DimLevel(levels[i]));
        }
    }
    if (queryDefn.getMeasures() != null && !queryDefn.getMeasures().isEmpty()) {
        Iterator measureIter = queryDefn.getMeasures().iterator();
        while (measureIter.hasNext()) {
            IMeasureDefinition measure = (MeasureDefinition) measureIter.next();
            measureRelationMap.put(measure.getName(), new RelationShip(rowLevelList, columnLevelList));
        }
    }
    ICubeAggrDefn[] cubeAggrs = OlapExpressionUtil.getAggrDefns(queryDefn.getBindings());
    if (cubeAggrs != null && cubeAggrs.length > 0) {
        for (int i = 0; i < cubeAggrs.length; i++) {
            if (cubeAggrs[i].getAggrName() == null)
                continue;
            List aggrOns = cubeAggrs[i].getAggrLevels();
            List usedLevelOnRow = new ArrayList();
            List usedLevelOnColumn = new ArrayList();
            for (int j = 0; j < aggrOns.size(); j++) {
                if (rowLevelList.contains(aggrOns.get(j)))
                    usedLevelOnRow.add(aggrOns.get(j));
                else if (columnLevelList.contains(aggrOns.get(j)))
                    usedLevelOnColumn.add(aggrOns.get(j));
            }
            measureRelationMap.put(cubeAggrs[i].getName(), new RelationShip(usedLevelOnRow, usedLevelOnColumn));
        }
    }
    return measureRelationMap;
}

Output:
             IMeasureDefinition measure = (MeasureDefinition) measureIter.next();
-            measureRelationMap.put(measure.getName(), new RelationShip(rowLevelList, columnLevelList));
+            measureRelationMap.put(measureMapping.get(measure.getName()), new RelationShip(rowLevelList, columnLevelList));
         }


Input:
public Vector<Entry> getEntriesForCommand(String commandId) {
    Hashtable<String, Entry> map = platform.getMenuMap();
    Menu menu = null;
    Entry entry = null;
    top: for (Suite s : platform.getInstalledSuites()) {
        for (Menu m : s.getMenus()) {
            if (currentCmd.equals(m.getId())) {
                menu = m;
                break top;
            }
            if (s.getEntries().containsKey(currentCmd)) {
                entry = s.getEntries().get(currentCmd);
                break top;
            }
        }
    }
    Vector<Entry> entries = new Vector<Entry>();
    if (entry != null) {
        entries.addElement(entry);
    }
    if (menu != null) {
        for (String cmd : menu.getCommandIds()) {
            Entry e = map.get(cmd);
            entries.addElement(e);
        }
    }
    return entries;
}

Output:
         for (Menu m : s.getMenus()) {
-            if (currentCmd.equals(m.getId())) {
+            if (commandId.equals(m.getId())) {
                 menu = m;


Input:
private <F extends Fragment & RightFragment> void setCenterFragment(int containerId, ControlFragment controlFrag, F centerFrag, boolean force) {
    setRightFragment(containerId, controlFrag, centerFrag, true);
}

Output:
 private <F extends Fragment & RightFragment> void setCenterFragment(int containerId, ControlFragment controlFrag, F centerFrag, boolean force) {
-    setRightFragment(containerId, controlFrag, centerFrag, true);
+    setRightFragmentRemoveLeft(containerId, controlFrag, centerFrag, force, true);
 }


Input:
public ObjectInputStream run() throws IOException {
    return new ObjectInputStream(is);
}

Output:
 public ObjectInputStream run() throws IOException {
-    return new ObjectInputStream(is);
+    return new ObjectInputStream(is) {
+        protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
+            return Class.forName(desc.getName(), false, classLoader);
+        }
+    };
 }


Input:
private void saveState() {
    String title = mTitleText.getText().toString();
    String body = mBodyText.getText().toString();
    if (title != null && title.length() > 0) {
        if (mRowId == null) {
            long id = mDbHelper.createNote(title, body, null);
            if (id > 0) {
                mRowId = id;
            }
        } else {
            mDbHelper.updateNote(mRowId, title, body, null);
        }
    }
    mDbHelper.close();
}

Output:
 private void saveState() {
-    String title = mTitleText.getText().toString();
-    String body = mBodyText.getText().toString();
-    if (title != null && title.length() > 0) {
-        if (mRowId == null) {
-            long id = mDbHelper.createNote(title, body, null);
-            if (id > 0) {
-                mRowId = id;
+    if (mTitleText != null && mTitleText.getText() != null) {
+        String title = mTitleText.getText().toString();
+        String body = mBodyText.getText().toString();
+        if (title != null && title.length() > 0) {
+            if (mRowId == null) {
+                long id = mDbHelper.createNote(title, body, null, null);
+                if (id > 0) {
+                    mRowId = id;
+                }
+            } else {
+                mDbHelper.updateNote(mRowId, title, body, null, null);
             }


Input:
private void drawBorder(BorderInfo[] borders) {
    ArrayList dbl = null;
    ArrayList solid = null;
    ArrayList dashed = null;
    ArrayList dotted = null;
    for (int i = 0; i < borders.length; i++) {
        if (IStyle.DOUBLE_VALUE.equals(borders[i].borderStyle)) {
            if (null == dbl) {
                dbl = new ArrayList();
            }
            dbl.add(borders[i]);
        } else if (IStyle.DASHED_VALUE.equals(borders[i].borderStyle)) {
            if (null == dashed) {
                dashed = new ArrayList();
            }
            dashed.add(borders[i]);
        } else if (IStyle.DOTTED_VALUE.equals(borders[i].borderStyle)) {
            if (null == dotted) {
                dotted = new ArrayList();
            }
            dotted.add(borders[i]);
        } else {
            if (null == solid) {
                solid = new ArrayList();
            }
            solid.add(borders[i]);
        }
    }
    if (null != dotted) {
        for (Iterator it = dotted.iterator(); it.hasNext(); ) {
            BorderInfo bi = (BorderInfo) it.next();
            pageGraphic.drawLine(bi.startX, bi.startY, bi.endX, bi.endY, bi.borderWidth, bi.borderColor, "String_Node_Str");
        }
    }
    if (null != dashed) {
        for (Iterator it = dashed.iterator(); it.hasNext(); ) {
            BorderInfo bi = (BorderInfo) it.next();
            pageGraphic.drawLine(bi.startX, bi.startY, bi.endX, bi.endY, bi.borderWidth, bi.borderColor, "String_Node_Str");
        }
    }
    if (null != solid) {
        for (Iterator it = solid.iterator(); it.hasNext(); ) {
            BorderInfo bi = (BorderInfo) it.next();
            pageGraphic.drawLine(bi.startX, bi.startY, bi.endX, bi.endY, bi.borderWidth, bi.borderColor, "String_Node_Str");
        }
    }
    if (null != dbl) {
        for (Iterator it = dbl.iterator(); it.hasNext(); ) {
            BorderInfo bi = (BorderInfo) it.next();
            int borderWidth = bi.borderWidth;
            int outerBorderWidth = borderWidth / 4;
            int innerBorderWidth = borderWidth / 4;
            int startX = bi.startX;
            int startY = bi.startY;
            int endX = bi.endX;
            int endY = bi.endY;
            Color borderColor = bi.borderColor;
            switch(bi.borderType) {
                case BorderInfo.TOP_BORDER:
                    pageGraphic.drawLine(startX, startY - borderWidth / 2 + outerBorderWidth / 2, endX, endY - borderWidth / 2 + outerBorderWidth / 2, outerBorderWidth, borderColor, "String_Node_Str");
                    pageGraphic.drawLine(startX, startY + borderWidth / 2 - innerBorderWidth / 2, endX, endY + borderWidth / 2 - innerBorderWidth / 2, innerBorderWidth, borderColor, "String_Node_Str");
                    break;
                case BorderInfo.RIGHT_BORDER:
                    pageGraphic.drawLine(startX + borderWidth / 2 - outerBorderWidth / 2, startY, endX + borderWidth / 2 - outerBorderWidth / 2, endY, outerBorderWidth, borderColor, "String_Node_Str");
                    pageGraphic.drawLine(startX - borderWidth / 2 + innerBorderWidth / 2, startY, endX - borderWidth / 2 + innerBorderWidth / 2, endY, innerBorderWidth, borderColor, "String_Node_Str");
                    break;
                case BorderInfo.BOTTOM_BORDER:
                    pageGraphic.drawLine(startX, startY + borderWidth / 2 - outerBorderWidth / 2, endX, endY + borderWidth / 2 - outerBorderWidth / 2, outerBorderWidth, borderColor, "String_Node_Str");
                    pageGraphic.drawLine(startX, startY - borderWidth / 2 + innerBorderWidth / 2, endX, endY - borderWidth / 2 + innerBorderWidth / 2, innerBorderWidth, borderColor, "String_Node_Str");
                    break;
                case BorderInfo.LEFT_BORDER:
                    pageGraphic.drawLine(startX - borderWidth / 2 + outerBorderWidth / 2, startY, endX - borderWidth / 2 + outerBorderWidth / 2, endY, outerBorderWidth, borderColor, "String_Node_Str");
                    pageGraphic.drawLine(startX + borderWidth / 2 - innerBorderWidth / 2, startY, endX + borderWidth / 2 - innerBorderWidth / 2, endY, innerBorderWidth, borderColor, "String_Node_Str");
                    break;
            }
        }
    }
}

Output:
                 case BorderInfo.TOP_BORDER:
-                    pageGraphic.drawLine(startX, startY - borderWidth / 2 + outerBorderWidth / 2, endX, endY - borderWidth / 2 + outerBorderWidth / 2, outerBorderWidth, borderColor, "String_Node_Str");
-                    pageGraphic.drawLine(startX, startY + borderWidth / 2 - innerBorderWidth / 2, endX, endY + borderWidth / 2 - innerBorderWidth / 2, innerBorderWidth, borderColor, "String_Node_Str");
+                    pageGraphic.drawLine(startX - borderWidth / 2 + outerBorderWidth / 2, startY - borderWidth / 2 + outerBorderWidth / 2, endX + borderWidth / 2 - outerBorderWidth / 2, endY - borderWidth / 2 + outerBorderWidth / 2, outerBorderWidth, borderColor, "String_Node_Str");
+                    pageGraphic.drawLine(startX - borderWidth / 2 + outerBorderWidth / 2, startY + borderWidth / 2 - innerBorderWidth / 2, endX + borderWidth / 2 - outerBorderWidth / 2, endY + borderWidth / 2 - innerBorderWidth / 2, innerBorderWidth, borderColor, "String_Node_Str");
                     break;


Input:
public void notification_onCommitRealmResults() {
    final Realm looperThreadRealm = looperThread.realm;
    looperThreadRealm.beginTransaction();
    AllJavaTypes child = looperThreadRealm.createObject(AllJavaTypes.class, 10);
    looperThreadRealm.commitTransaction();
    final AtomicInteger counter = new AtomicInteger(0);
    RealmChangeListener<RealmResults<AllJavaTypes>> listener = new RealmChangeListener<RealmResults<AllJavaTypes>>() {
        public void onChange(RealmResults<AllJavaTypes> object) {
            counter.incrementAndGet();
        }
    };
    child.getObjectParents().addChangeListener(listener);
    looperThreadRealm.beginTransaction();
    AllJavaTypes parent = looperThreadRealm.createObject(AllJavaTypes.class, 1);
    parent.setFieldObject(child);
    looperThreadRealm.commitTransaction();
    verifyPostConditions(looperThreadRealm, new PostConditions() {
        public void run(Realm realm) {
            assertEquals(2, looperThreadRealm.where(AllJavaTypes.class).findAll().size());
            assertEquals(1, counter.get());
        }
    }, child, parent);
}

Output:
 public void notification_onCommitRealmResults() {
-    final Realm looperThreadRealm = looperThread.realm;
+    final Realm looperThreadRealm = looperThread.getRealm();
     looperThreadRealm.beginTransaction();


Input:
private void applyContainerTopBorder(ContainerSizeInfo rule, int pos) {
    if (engine.getContainers().size() == 0) {
        return;
    }
    XlsContainer container = engine.getCurrentContainer();
    StyleEntry entry = container.getStyle();
    int col = engine.getAxis().getColumnIndexByCoordinate(rule.getStartCoordinate());
    int span = engine.getAxis().getColumnIndexByCoordinate(rule.getEndCoordinate()) - col;
    for (int i = col; i < span + col; i++) {
        Data data = engine.getData(i, pos);
        if (data == null || data == Data.WASTE) {
            continue;
        }
        StyleBuilder.applyTopBorder(entry, data.style);
    }
}

Output:
         Data data = engine.getData(i, pos);
-        if (data == null || data == Data.WASTE) {
+        if (data == null || data.isBlank()) {
             continue;


Input:
public void onHiddenChanged(boolean hidden) {
    super.onHiddenChanged(hidden);
    if (!hidden) {
        if (mListener != null)
            mListener.onAlarmsSetTitle("String_Node_Str");
        if (mReloadOnShow) {
            mReloadOnShow = false;
            mAdapter = new AlarmsAdapter(getActivity(), UnbounceStatsCollection.getInstance().toAlarmArrayList(getActivity()));
            mAdapter.sort(SortWakeLocks.getAlarmListComparator());
            mAdapter.notifyDataSetChanged();
            setListAdapter(mAdapter);
        }
    }
}

Output:
             mAdapter = new AlarmsAdapter(getActivity(), UnbounceStatsCollection.getInstance().toAlarmArrayList(getActivity()));
-            mAdapter.sort(SortWakeLocks.getAlarmListComparator());
-            mAdapter.notifyDataSetChanged();
+            mAdapter.sort();
             setListAdapter(mAdapter);


Input:
public void setUp() throws Exception {
    Config config = new XmlConfigBuilder().build();
    MapConfig mapConfig = config.getMapConfig(mapName);
    NearCacheConfig nearCacheConfig = new NearCacheConfig();
    nearCacheConfig.setEvictionPolicy("String_Node_Str");
    nearCacheConfig.setInMemoryFormat(InMemoryFormat.OBJECT);
    nearCacheConfig.setCacheLocalEntries(true);
    mapConfig.setNearCacheConfig(nearCacheConfig);
    final TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(instanceCount);
    hcInstance = factory.newHazelcastInstance(config);
    hcInstance2 = factory.newHazelcastInstance(config);
}

Output:
 public void setUp() throws Exception {
-    Config config = new XmlConfigBuilder().build();
+    Config config = new Config();
     MapConfig mapConfig = config.getMapConfig(mapName);


Input:
public void run(int maxDepth, DirectedSparseGraph<Node, String> graph, String edgeType, String nodeType) throws UnsupportedEncodingException, IOException {
    Queue<Node> q = new LinkedList<Node>();
    for (Node node : graph.getVertices()) {
        findNode.put(node.getCandidateURI(), node);
        q.add(node);
    }
    while (!q.isEmpty()) {
        Node currentNode = q.poll();
        int level = currentNode.getLevel();
        if (level < maxDepth) {
            List<Triple> outgoingNodes = null;
            outgoingNodes = index.search(currentNode.getCandidateURI(), null, null);
            if (outgoingNodes == null) {
                continue;
            }
            for (Triple targetNode : outgoingNodes) {
                if (targetNode.getPredicate() == null && targetNode.getObject() == null) {
                    continue;
                }
                if (targetNode.getPredicate().startsWith(edgeType) && targetNode.getObject().startsWith(nodeType)) {
                    int levelNow = level + 1;
                    Node Node = null;
                    if (findNode.containsKey(targetNode)) {
                        Node = findNode.get(targetNode);
                    } else {
                        Node = new Node(targetNode.getObject(), 0, levelNow);
                        findNode.put(targetNode.getObject(), Node);
                        q.add(Node);
                    }
                    graph.addEdge(graph.getEdgeCount() + "String_Node_Str" + targetNode.getPredicate(), currentNode, Node);
                }
            }
        }
    }
}

Output:
                     } else {
-                        Node = new Node(targetNode.getObject(), 0, levelNow);
+                        Node = new Node(targetNode.getObject(), 0, levelNow, algo);
                         findNode.put(targetNode.getObject(), Node);


Input:
public void onGlobalLayout() {
    View button = findViewById(R.id.info);
    spotlight.setMaskX(button.getRight() - (button.getWidth() / 2));
    spotlight.setMaskY(button.getBottom() - (button.getHeight() / 2));
    runEnterAnimation();
    Utils.removeOnGlobalLayoutListener(spotlight, this);
}

Output:
     runEnterAnimation();
-    Utils.removeOnGlobalLayoutListener(spotlight, this);
+    Utils.removeOnGlobalLayoutListenerCompat(spotlight, this);
 }


Input:
public static Process run(String appJar, String mainClass, String srcCaller, String srcCallee, boolean goBackward, DataDependenceOptions dOptions, ControlDependenceOptions cOptions) throws IllegalArgumentException, CancelException {
    try {
        AnalysisScope scope = AnalysisScopeReader.makeJavaBinaryAnalysisScope(appJar, new File(CallGraphTestUtil.REGRESSION_EXCLUSIONS));
        ClassHierarchy cha = ClassHierarchy.make(scope);
        Iterable<Entrypoint> entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha, mainClass);
        AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints);
        CallGraphBuilder builder = Util.makeVanillaZeroOneCFABuilder(options, new AnalysisCache(), cha, scope);
        CallGraph cg = builder.makeCallGraph(options, null);
        SDG sdg = new SDG(cg, builder.getPointerAnalysis(), dOptions, cOptions);
        CGNode callerNode = SlicerTest.findMethod(cg, srcCaller);
        Statement s = SlicerTest.findCallTo(callerNode, srcCallee);
        System.err.println("String_Node_Str" + s);
        Collection<Statement> slice = null;
        if (goBackward) {
            slice = Slicer.computeBackwardSlice(s, cg, builder.getPointerAnalysis(), dOptions, cOptions);
        } else {
            s = getReturnStatementForCall(s);
            slice = Slicer.computeForwardSlice(s, cg, builder.getPointerAnalysis(), dOptions, cOptions);
        }
        SlicerTest.dumpSlice(slice);
        Graph<Statement> g = pruneSDG(sdg, slice);
        sanityCheck(slice, g);
        Properties p = null;
        try {
            p = WalaExamplesProperties.loadProperties();
            p.putAll(WalaProperties.loadProperties());
        } catch (WalaException e) {
            e.printStackTrace();
            Assertions.UNREACHABLE();
        }
        String psFile = p.getProperty(WalaProperties.OUTPUT_DIR) + File.separatorChar + PS_FILE;
        String dotExe = p.getProperty(WalaExamplesProperties.DOT_EXE);
        DotUtil.dotify(g, makeNodeDecorator(), GVTypeHierarchy.DOT_FILE, psFile, dotExe);
        String gvExe = p.getProperty(WalaExamplesProperties.GHOSTVIEW_EXE);
        return GVUtil.launchGV(psFile, gvExe);
    } catch (WalaException e) {
        e.printStackTrace();
        return null;
    }
}

Output:
     try {
-        AnalysisScope scope = AnalysisScopeReader.makeJavaBinaryAnalysisScope(appJar, new File(CallGraphTestUtil.REGRESSION_EXCLUSIONS));
+        AnalysisScope scope = AnalysisScopeReader.makeJavaBinaryAnalysisScope(appJar, FileProvider.getFile(CallGraphTestUtil.REGRESSION_EXCLUSIONS));
         ClassHierarchy cha = ClassHierarchy.make(scope);


Input:
private boolean collidingCheckOnlySpotsInBounds(int checkX, int checkY, int checkOrientation) {
    int[][] thePiece = possibleBlocks.get(currentBlockId).getShape(checkOrientation);
    try {
        for (int y = 0; y < thePiece[0].length; ++y) {
            for (int x = 0; x < thePiece.length; ++x) {
                if (thePiece[x][y] != 0) {
                    if ((checkX + x >= 0 && checkX + x < worldWidth && checkY + y >= 0 && checkY + y < worldHeight)) {
                        int linearArrayIndex = calculateLinearArrayPosition(checkX + x, checkY + y);
                        if (worldState[linearArrayIndex] != 0) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    } catch (ArrayIndexOutOfBoundsException e) {
        System.err.println("String_Node_Str" + checkX + "String_Node_Str" + checkY + "String_Node_Str" + checkOrientation);
        System.err.println("String_Node_Str" + e);
        Thread.dumpStack();
        System.err.println("String_Node_Str");
        System.err.println("String_Node_Str");
        is_game_over = true;
        return true;
    }
}

Output:
 private boolean collidingCheckOnlySpotsInBounds(int checkX, int checkY, int checkOrientation) {
-    int[][] thePiece = possibleBlocks.get(currentBlockId).getShape(checkOrientation);
+    int[][] thePiece = POSSIBLE_BLOCKS.get(currentBlockId).getShape(checkOrientation);
     try {


Input:
public void testEven4ParitySubtreeMutation() {
    final int LOWER_SUCCESS = 85;
    final int UPPER_SUCCESS = 95;
    Evolver evolver = getEvolver();
    final EvenParity model = new EvenParity(evolver, 4);
    setupModel(model);
    model.setMutationProbability(0.1);
    model.setReproductionProbability(0.0);
    model.setMutation(new SubtreeMutation(evolver));
    final int noSuccess = getNoSuccesses(model);
    assertBetween("String_Node_Str", LOWER_SUCCESS, UPPER_SUCCESS, noSuccess);
}

Output:
     model.setMutation(new SubtreeMutation(evolver));
-    final int noSuccess = getNoSuccesses(model);
+    final int noSuccess = getNoSuccesses(model, false, false);
     assertBetween("String_Node_Str", LOWER_SUCCESS, UPPER_SUCCESS, noSuccess);


Input:
private void setupKeyboardShortcuts() {
    filterTextField.addEventHandler(KeyEvent.KEY_RELEASED, event -> {
        if (KeyboardShortcuts.BOX_TO_LIST.match(event)) {
            event.consume();
            listView.selectFirstItem();
        }
        if (!KeyboardShortcuts.DOUBLE_PRESS.match(event)) {
            currentFilterText = Optional.of(getCurrentFilterString());
        }
        if (KeyPress.isDoublePress(KeyboardShortcuts.DOUBLE_PRESS.getCode(), event.getCode())) {
            event.consume();
            if (currentFilterText.isPresent()) {
                filterTextField.setText(currentFilterText.get());
            }
            listView.selectFirstItem();
        }
        if (KeyboardShortcuts.MAXIMIZE_WINDOW.match(event)) {
            ui.maximizeWindow();
        }
        if (KeyboardShortcuts.MINIMIZE_WINDOW.match(event)) {
            ui.minimizeWindow();
        }
        if (KeyboardShortcuts.DEFAULT_SIZE_WINDOW.match(event)) {
            ui.setDefaultWidth();
        }
        if (KeyboardShortcuts.SWITCH_DEFAULT_REPO.match(event)) {
            ui.switchDefaultRepo();
        }
    });
    addEventHandler(KeyEvent.KEY_RELEASED, event -> {
        if (KeyboardShortcuts.markAsRead.match(event)) {
            markAsRead();
        }
        if (KeyboardShortcuts.markAsUnread.match(event)) {
            markAsUnread();
        }
        if (KeyboardShortcuts.SHOW_DOCS.match(event)) {
            ui.getBrowserComponent().showDocs();
        }
        if (KeyboardShortcuts.LIST_TO_BOX.match(event)) {
            setFocusToFilterBox();
        }
        if (KeyboardShortcuts.DOUBLE_PRESS.match(event) && KeyPress.isDoublePress(KeyboardShortcuts.DOUBLE_PRESS.getCode(), event.getCode())) {
            setFocusToFilterBox();
        }
        if (KeyboardShortcuts.SHOW_ISSUES.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().showIssues();
            }
        }
        if (KeyboardShortcuts.SHOW_PULL_REQUESTS.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().showPullRequests();
            }
        }
        if (KeyboardShortcuts.SHOW_HELP.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().showDocs();
            }
        }
        if (KeyboardShortcuts.SHOW_KEYBOARD_SHORTCUTS.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().showKeyboardShortcuts();
            }
        }
        if (KeyboardShortcuts.SHOW_CONTRIBUTORS.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().showContributors();
                event.consume();
            }
        }
        if (KeyboardShortcuts.scrollToTop.match(event)) {
            ui.getBrowserComponent().scrollToTop();
        }
        if (KeyboardShortcuts.scrollToBottom.match(event)) {
            if (!KeyboardShortcuts.MINIMIZE_WINDOW.match(event)) {
                ui.getBrowserComponent().scrollToBottom();
            }
        }
        if (KeyboardShortcuts.scrollUp.match(event) || KeyboardShortcuts.scrollDown.match(event)) {
            ui.getBrowserComponent().scrollPage(KeyboardShortcuts.scrollDown.match(event));
        }
        if (KeyboardShortcuts.GOTO_MODIFIER.match(event)) {
            KeyPress.setLastKeyPressedCodeAndTime(event.getCode());
        }
        if (KeyboardShortcuts.NEW_COMMENT.match(event) && ui.getBrowserComponent().isCurrentUrlIssue()) {
            ui.getBrowserComponent().switchToConversationTab();
            ui.getBrowserComponent().jumpToComment();
        }
        if (KeyboardShortcuts.SHOW_LABELS.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().newLabel();
            } else {
                changeLabels();
            }
        }
        if (KeyboardShortcuts.MANAGE_ASSIGNEES.match(event) && ui.getBrowserComponent().isCurrentUrlIssue()) {
            ui.getBrowserComponent().switchToConversationTab();
            ui.getBrowserComponent().manageAssignees(event.getCode().toString());
        }
        if (KeyboardShortcuts.SHOW_MILESTONES.match(event)) {
            if (KeyPress.isValidKeyCombination(KeyboardShortcuts.GOTO_MODIFIER.getCode(), event.getCode())) {
                ui.getBrowserComponent().showMilestones();
            } else if (ui.getBrowserComponent().isCurrentUrlIssue()) {
                ui.getBrowserComponent().switchToConversationTab();
                ui.getBrowserComponent().manageMilestones(event.getCode().toString());
            }
        }
        if (KeyboardShortcuts.MAXIMIZE_WINDOW.match(event)) {
            ui.maximizeWindow();
        }
        if (KeyboardShortcuts.MINIMIZE_WINDOW.match(event)) {
            ui.minimizeWindow();
        }
        if (KeyboardShortcuts.DEFAULT_SIZE_WINDOW.match(event)) {
            ui.setDefaultWidth();
        }
        if (KeyboardShortcuts.SWITCH_DEFAULT_REPO.match(event)) {
            ui.switchDefaultRepo();
        }
        if (KeyboardShortcuts.UNDO_LABEL_CHANGES.match(event)) {
            ui.triggerNotificationPaneAction();
        }
        for (KeyCodeCombination key : KeyboardShortcuts.jumpToFirstIssueKeys) {
            if (key.match(event)) {
                event.consume();
                listView.selectFirstItem();
            }
        }
    });
}

Output:
         }
-        for (KeyCodeCombination key : KeyboardShortcuts.jumpToFirstIssueKeys) {
+        for (KeyCodeCombination key : KeyboardShortcuts.JUMP_TO_FIRST_ISSUE_KEYS) {
             if (key.match(event)) {


Input:
public boolean hasChildren(Object element) {
    if (element instanceof TdView || element instanceof TdTable) {
        return false;
    }
    return !super.hasChildren(element);
}

Output:
     }
-    return !super.hasChildren(element);
+    return superHasChildren(element);
 }


Input:
private void fillFx(LinearLayout listFilters, int buttonId) {
    FilterFxRepresentation[] fxArray = new FilterFxRepresentation[18];
    int p = 0;
    int[] drawid = { R.drawable.filtershow_fx_0005_punch, R.drawable.filtershow_fx_0000_vintage, R.drawable.filtershow_fx_0004_bw_contrast, R.drawable.filtershow_fx_0002_bleach, R.drawable.filtershow_fx_0001_instant, R.drawable.filtershow_fx_0007_washout, R.drawable.filtershow_fx_0003_blue_crush, R.drawable.filtershow_fx_0008_washout_color, R.drawable.filtershow_fx_0006_x_process };
    int[] fxNameid = { R.string.ffx_punch, R.string.ffx_vintage, R.string.ffx_bw_contrast, R.string.ffx_bleach, R.string.ffx_instant, R.string.ffx_washout, R.string.ffx_blue_crush, R.string.ffx_washout_color, R.string.ffx_x_process };
    for (int i = 0; i < drawid.length; i++) {
        FilterFxRepresentation fx = new FilterFxRepresentation(getString(fxNameid[i]), drawid[i], fxNameid[i]);
        fxArray[p++] = fx;
    }
    ImageButton button = (ImageButton) findViewById(buttonId);
    FilterFxRepresentation nullFx = new FilterFxRepresentation(getString(R.string.none), 0, R.string.none);
    mNullFxFilter = setupFilterRepresentationButton(nullFx, listFilters, button);
    mNullFxFilter.setSelected(true);
    Vector<FilterRepresentation> filtersRepresentations = new Vector<FilterRepresentation>();
    FiltersManager.getManager().addLooks(filtersRepresentations);
    for (FilterRepresentation representation : filtersRepresentations) {
        setupFilterRepresentationButton(representation, listFilters, button);
    }
    for (int i = 0; i < p; i++) {
        setupFilterRepresentationButton(fxArray[i], listFilters, button);
    }
}

Output:
     Vector<FilterRepresentation> filtersRepresentations = new Vector<FilterRepresentation>();
-    FiltersManager.getManager().addLooks(filtersRepresentations);
+    FiltersManager.getManager().addLooks(this, filtersRepresentations);
     for (FilterRepresentation representation : filtersRepresentations) {


Input:
protected void fillMappingFile() throws ServiceException, IOException {
    String strGeneID = "String_Node_Str";
    String strAccessionNumber;
    String[] strArEnzymeQueryResult = null;
    String[] strArHomeSapiensGenes = null;
    int iNumberOfGenes;
    KEGGLocator locator = new KEGGLocator();
    KEGGPortType serv = locator.getKEGGPort();
    EUtilsServiceLocator service = new EUtilsServiceLocator();
    EUtilsServiceSoap utils = service.geteUtilsServiceSoap();
    EFetchRequest parameters = new EFetchRequest();
    parameters.setDb("String_Node_Str");
    parameters.setRettype("String_Node_Str");
    EFetchResult entrezEFetchResult = null;
    iNumberOfGenes = serv.get_number_of_genes_by_organism("String_Node_Str");
    System.out.println("String_Node_Str" + iNumberOfGenes);
    strArHomeSapiensGenes = serv.get_genes_by_organism("String_Node_Str", 1, iNumberOfGenes);
    for (int iGeneIndex = 0; iGeneIndex < strArHomeSapiensGenes.length; iGeneIndex++) {
        strGeneID = strArHomeSapiensGenes[iGeneIndex];
        System.out.println("String_Node_Str" + strGeneID);
        strArEnzymeQueryResult = serv.get_enzymes_by_gene(strGeneID);
        strGeneID = strGeneID.substring(4);
        if (strArEnzymeQueryResult.length == 0) {
            System.out.println("String_Node_Str" + strGeneID + strDelimiter);
            mappingGeneID2EnzymeOutputStream.println(strGeneID + strDelimiter);
        }
        for (int iResultIndex = 0; iResultIndex < strArEnzymeQueryResult.length; iResultIndex++) {
            System.out.println("String_Node_Str" + strGeneID + strDelimiter + strArEnzymeQueryResult[iResultIndex]);
            mappingGeneID2EnzymeOutputStream.println(strGeneID + strDelimiter + strArEnzymeQueryResult[iResultIndex]);
        }
        parameters.setId(strGeneID);
        entrezEFetchResult = utils.run_eFetch(parameters);
        GeneCommentaryType[] geneCommentaries = entrezEFetchResult.getEntrezgeneSet().getEntrezgene(0).getEntrezgene_comments().getGeneCommentary();
        for (int iGeneCommentaryIndex = 0; iGeneCommentaryIndex < geneCommentaries.length; iGeneCommentaryIndex++) {
            if (geneCommentaries[iGeneCommentaryIndex].getGeneCommentary_heading() != null && geneCommentaries[iGeneCommentaryIndex].getGeneCommentary_heading().equals("String_Node_Str")) {
                strAccessionNumber = geneCommentaries[iGeneCommentaryIndex].getGeneCommentary_comment().getGeneCommentary(0).getGeneCommentary_products().getGeneCommentary(0).getGeneCommentary_accession();
                System.out.println("String_Node_Str" + strGeneID + strDelimiter + strAccessionNumber);
                mappingGeneID2AccessionOutputStream.println(strGeneID + strDelimiter + strAccessionNumber);
                break;
            }
        }
    }
    mappingGeneID2EnzymeOutputStream.close();
    mappingGeneID2AccessionOutputStream.close();
    System.out.println("String_Node_Str");
}

Output:
     String strGeneID = "String_Node_Str";
-    String strAccessionNumber;
+    String strAccessionNumber = "String_Node_Str";
     String[] strArEnzymeQueryResult = null;


Input:
public void execute(WebScriptRequest webScriptRequest, WebScriptResponse res) throws IOException {
    try {
        SearchSQLQuery searchQuery = extractJsonContent(webScriptRequest, assistant.getJsonHelper(), SearchSQLQuery.class);
        SearchParameters sparams = buildSearchParameters(searchQuery);
        ResultSet results = searchService.query(sparams);
        FilteringResultSet frs = (FilteringResultSet) results;
        SolrSQLJSONResultSet ssjr = (SolrSQLJSONResultSet) frs.getUnFilteredResultSet();
        if (searchQuery.getFormat().equalsIgnoreCase("String_Node_Str")) {
            res.getWriter().write(ssjr.getSolrResponse());
        } else {
            CollectionWithPagingInfo<TupleList> nodes = resultMapper.toCollectionWithPagingInfo(ssjr.getDocs(), searchQuery);
            renderJsonResponse(res, nodes, assistant.getJsonHelper());
        }
        setResponse(res, DEFAULT_SUCCESS);
    } catch (Exception exception) {
        renderException(exception, res, assistant);
    }
}

Output:
     } catch (Exception exception) {
-        renderException(exception, res, assistant);
+        if (exception instanceof LuceneQueryParserException) {
+            renderException(exception, res, assistant);
+        } else {
+            renderException(new WebScriptException(400, exception.getMessage()), res, assistant);
+        }
     }


Input:
public UserProfile loadProfile(SkinSiteProfile ssp, String username) throws Exception {
    if (ssp.root == null || ssp.root.equals("String_Node_Str")) {
        CustomSkinLoader.logger.info("String_Node_Str");
        return null;
    }
    String json = HttpUtil.readHttp(ssp.root + username + "String_Node_Str");
    if (json == null || json.equals("String_Node_Str")) {
        CustomSkinLoader.logger.info("String_Node_Str");
        return null;
    }
    CustomSkinAPI profile = new Gson().fromJson(json, CustomSkinAPI.class);
    UserProfile p = new UserProfile();
    if (profile.skins != null && !profile.skins.isEmpty()) {
        Set<String> keys = profile.skins.keySet();
        for (String s : keys) {
            if (ModelManager.checkModel(s)) {
                p.skinUrl = ssp.root + TEXTURES + profile.skins.get(s);
                p.model = s;
                break;
            }
        }
        if (p.skinUrl == null) {
            p.skinUrl = ssp.root + TEXTURES + profile.skins.get(keys.toArray()[0]);
            p.model = "String_Node_Str";
        }
    } else if (profile.skin != null && !profile.skin.equals("String_Node_Str")) {
        p.skinUrl = ssp.root + TEXTURES + profile.skin;
    }
    if (profile.cape != null && !profile.cape.equals("String_Node_Str")) {
        p.capeUrl = ssp.root + TEXTURES + profile.cape;
    }
    if (p.isEmpty()) {
        CustomSkinLoader.logger.info("String_Node_Str");
        return null;
    } else {
        return p;
    }
}

Output:
     }
-    String json = HttpUtil.readHttp(ssp.root + username + "String_Node_Str");
+    String json = HttpUtil0.readHttp(ssp.root + username + "String_Node_Str");
     if (json == null || json.equals("String_Node_Str")) {


Input:
private static Test decorateTest(String testName) {
    SSLTest sslTest = new SSLTest(testName);
    String[] startupProperties = getStartupProperties();
    String[] startupArgs = new String[] {};
    NetworkServerTestSetup networkServerTestSetup = new NetworkServerTestSetup(sslTest, startupProperties, startupArgs, true, sslTest._inputStreamHolder);
    Test testSetup = SecurityManagerSetup.noSecurityManager(networkServerTestSetup);
    testSetup = new SupportFilesSetup(testSetup, null, new String[] { "String_Node_Str" }, null, new String[] { "String_Node_Str" });
    Test test = TestConfiguration.defaultServerDecorator(testSetup);
    test = TestConfiguration.changeSSLDecorator(test, "String_Node_Str");
    return test;
}

Output:
     String[] startupArgs = new String[] {};
-    NetworkServerTestSetup networkServerTestSetup = new NetworkServerTestSetup(sslTest, startupProperties, startupArgs, true, sslTest._inputStreamHolder);
+    NetworkServerTestSetup networkServerTestSetup = new NetworkServerTestSetup(sslTest, startupProperties, startupArgs, true);
     Test testSetup = SecurityManagerSetup.noSecurityManager(networkServerTestSetup);


Input:
public HashMap<Integer, Assignment> getCustomerListAssignmentFromDB(String customer) {
    HashMap<Integer, Assignment> listAssignment = new HashMap<Integer, Assignment>();
    DBConnector dbConnector = new DBConnector();
    try {
        ResultSet rs = dbConnector.askDB("String_Node_Str" + customer + "String_Node_Str");
        while (rs.next()) {
            int code = rs.getInt("String_Node_Str");
            boolean state = rs.getBoolean("String_Node_Str");
            Date dateStart = rs.getDate("String_Node_Str");
            Date dateEnd = rs.getDate("String_Node_Str");
            Address meetingPoint = getMeetingPointFromDB(code);
            HashSet dogList = getDogListFromDB(code);
            Assignment assignment = new Assignment(code, dogList, dateStart, dateEnd, meetingPoint);
            listAssignment.put(code, assignment);
        }
        dbConnector.closeConnection();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return listAssignment;
}

Output:
             boolean state = rs.getBoolean("String_Node_Str");
-            Date dateStart = rs.getDate("String_Node_Str");
-            Date dateEnd = rs.getDate("String_Node_Str");
+            Date dateStart = rs.getTimestamp("String_Node_Str");
+            Date dateEnd = rs.getTimestamp("String_Node_Str");
             Address meetingPoint = getMeetingPointFromDB(code);


Input:
protected void addDragAndDropListener() {
    int ops = DND.DROP_MOVE | DND.DROP_COPY;
    Transfer[] transfers = new Transfer[] { TemplateTransfer.getInstance() };
    getTreeViewer().addDragSupport(ops, transfers, new DesignerDragListener(getTreeViewer()));
    transfers = new Transfer[] { TemplateTransfer.getInstance() };
    DesignerDropListener dropListener = new LibraryDropListener(getTreeViewer());
    dropListener.addDropConstraint(CascadingParameterGroupHandle.class, new IDropConstraint() {
        public int validate(Object transfer, Object target) {
            return RESULT_NO;
        }
    });
    dropListener.addDropConstraint(ScalarParameterHandle.class, new IDropConstraint() {
        public int validate(Object transfer, Object target) {
            if (target instanceof ScalarParameterHandle) {
                ScalarParameterHandle targetParameter = (ScalarParameterHandle) target;
                if (targetParameter.getContainer() instanceof CascadingParameterGroupHandle)
                    return RESULT_NO;
            }
            return RESULT_UNKNOW;
        }
    });
    IDropConstraint cascadingParameterGroupChildrenConstraint = new IDropConstraint() {
        public int validate(Object transfer, Object target) {
            if (transfer instanceof Object[] && ((Object[]) transfer).length > 0 && ((Object[]) transfer)[0] instanceof ScalarParameterHandle) {
                ScalarParameterHandle transferParameter = (ScalarParameterHandle) ((Object[]) transfer)[0];
                if (transferParameter.getContainer() instanceof CascadingParameterGroupHandle)
                    return RESULT_NO;
            }
            return RESULT_UNKNOW;
        }
    };
    dropListener.addDropConstraint(ScalarParameterHandle.class, cascadingParameterGroupChildrenConstraint);
    dropListener.addDropConstraint(ParameterGroupHandle.class, cascadingParameterGroupChildrenConstraint);
    dropListener.addDropConstraint(ReportElementModel.class, cascadingParameterGroupChildrenConstraint);
    getTreeViewer().addDropSupport(ops, transfers, dropListener);
}

Output:
 protected void addDragAndDropListener() {
-    int ops = DND.DROP_MOVE | DND.DROP_COPY;
+    int ops = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;
     Transfer[] transfers = new Transfer[] { TemplateTransfer.getInstance() };


Input:
protected <T extends Element> T fetch(IRI href, Map<String, String> args) throws Exception {
    Request get = new GetRequest(href.toString()).setArgs(args);
    Response res = sendRequest(get, 200);
    Assert.assertNotNull(res);
    String xml = res.getContentAsString();
    T result = parse(new StringReader(xml));
    Assert.assertNotNull(result);
    return result;
}

Output:
     String xml = res.getContentAsString();
-    T result = parse(new StringReader(xml));
+    T result = this.<T>parse(new StringReader(xml));
     Assert.assertNotNull(result);


Input:
private Object createProxy(byte[] rowKey, Row row) {
    Object newproxy = null;
    try {
        newproxy = classMeta.getMetaClass().newInstance();
    } catch (InstantiationException e) {
        throw new UnsupportedOperationException("String_Node_Str");
    } catch (IllegalAccessException e) {
        throw new UnsupportedOperationException("String_Node_Str");
    }
    DboColumnMeta colMeta = this.getMetaDbo();
    if (classMeta.getIdField() != null && (rowKey != null)) {
        DboColumnEmbedMeta embedMeta = (DboColumnEmbedMeta) colMeta;
        Object idValue1 = embedMeta.getFkToColumnFamily().getIdColumnMeta().getStorageType().convertFromNoSql(rowKey);
        ReflectionUtil.putFieldValue(newproxy, classMeta.getIdField().field, idValue1);
        byte[] prefix = StandardConverters.convertToBytes(getColumnName());
        byte[] idBytes = StandardConverters.convertToBytes(idValue1);
        byte[] embedColumn = new byte[prefix.length + idBytes.length];
        System.arraycopy(prefix, 0, embedColumn, 0, prefix.length);
        System.arraycopy(idBytes, 0, embedColumn, prefix.length, idBytes.length);
        Collection<Column> columnsInRow = row.columnByPrefix(embedColumn);
        for (Column colInRow : columnsInRow) {
            byte[] fullNameCol = colInRow.getName();
            int colLen = fullNameCol.length - embedColumn.length;
            byte[] fk = new byte[colLen];
            for (int i = embedColumn.length; i < fullNameCol.length; i++) {
                fk[i - embedColumn.length] = fullNameCol[i];
            }
            Object colVal = colMeta.convertFromStorage2(fk);
            String colName = colMeta.convertTypeToString(colVal);
            Object columnValue = null;
            MetaField<PROXY> metaField = classMeta.getMetaFieldByCol(null, colName);
            NoSqlConverter customConv = metaField.getField().getAnnotation(NoSqlConverter.class);
            if (customConv != null) {
                columnValue = getValue(colInRow.getValue(), customConv);
            } else {
                columnValue = embedMeta.getFkToColumnFamily().getColumnMeta(colName).getStorageType().convertFromNoSql(colInRow.getValue());
            }
            if (metaField != null)
                ReflectionUtil.putFieldValue(newproxy, metaField.getField(), columnValue);
        }
    } else {
        byte[] colName = StandardConverters.convertToBytes(getColumnName());
        Collection<Column> columnsWORowKey = row.columnByPrefix(colName);
        for (Column col : columnsWORowKey) {
            byte[] fullName = col.getName();
            int embedColumnLen = fullName.length - colName.length;
            byte[] embedColumn = new byte[embedColumnLen];
            for (int i = colName.length; i < fullName.length; i++) {
                embedColumn[i - colName.length] = fullName[i];
            }
            Object colVal = colMeta.convertFromStorage2(embedColumn);
            String columnName = colMeta.convertTypeToString(colVal);
            DboColumnEmbedMeta embedMeta = (DboColumnEmbedMeta) colMeta;
            if (embedMeta.getFkToColumnFamily().getColumnMeta(columnName) == null)
                continue;
            Object columnValue = null;
            MetaField<PROXY> metaField = classMeta.getMetaFieldByCol(null, columnName);
            NoSqlConverter customConv = metaField.getField().getAnnotation(NoSqlConverter.class);
            if (customConv != null) {
                columnValue = getValue(col.getValue(), customConv);
            } else {
                columnValue = embedMeta.getFkToColumnFamily().getColumnMeta(columnName).getStorageType().convertFromNoSql(col.getValue());
            }
            if (classMeta.getMetaFieldByCol(null, columnName) != null)
                ReflectionUtil.putFieldValue(newproxy, classMeta.getMetaFieldByCol(null, columnName).getField(), columnValue);
        }
    }
    return newproxy;
}

Output:
         DboColumnEmbedMeta embedMeta = (DboColumnEmbedMeta) colMeta;
-        Object idValue1 = embedMeta.getFkToColumnFamily().getIdColumnMeta().getStorageType().convertFromNoSql(rowKey);
-        ReflectionUtil.putFieldValue(newproxy, classMeta.getIdField().field, idValue1);
+        Object idValue = null;
+        MetaField<PROXY> metaFieldId = classMeta.getIdField();
+        NoSqlConverter customConvId = metaFieldId.getField().getAnnotation(NoSqlConverter.class);
+        byte[] idBytes = null;
+        if (customConvId != null) {
+            idValue = getValue(rowKey, customConvId);
+            idBytes = getBytesValue(idValue, customConvId);
+        } else {
+            idValue = embedMeta.getFkToColumnFamily().getIdColumnMeta().getStorageType().convertFromNoSql(rowKey);
+            idBytes = StandardConverters.convertToBytes(idValue);
+        }
+        if (metaFieldId != null)
+            ReflectionUtil.putFieldValue(newproxy, metaFieldId.getField(), idValue);
         byte[] prefix = StandardConverters.convertToBytes(getColumnName());


Input:
public SearchResult search(SearchRequest searchRequest) {
    SearchCacheEntry searchCacheEntry = getSearchCacheEntry(searchRequest);
    SearchResult searchResult = new SearchResult();
    int numberOfWantedResults = searchRequest.getOffset().orElse(0) + searchRequest.getLimit().orElse(100);
    searchResult.setPickingResult(searchCacheEntry.getPickingResult());
    Map<Indexer, List<IndexerSearchResult>> indexersToSearchAndTheirResults = getIndexerSearchResultsToSearch(searchCacheEntry.getIndexerSearchResultsByIndexer());
    int numberOfResultsAlreadyFound = searchResult.calculateNumberOfResults();
    while (indexersToSearchAndTheirResults.size() > 0 && numberOfResultsAlreadyFound < numberOfWantedResults) {
        logger.debug("String_Node_Str", indexersToSearchAndTheirResults.size(), numberOfResultsAlreadyFound, numberOfWantedResults);
        indexersToSearchAndTheirResults = callSearchModules(searchRequest, indexersToSearchAndTheirResults);
        searchCacheEntry.getIndexerSearchResultsByIndexer().putAll(indexersToSearchAndTheirResults);
        searchRequestCache.put(searchRequest.hashCode(), searchCacheEntry);
        searchResult.getIndexerSearchResultMap().putAll(indexersToSearchAndTheirResults);
        List<SearchResultItem> searchResultItems = searchCacheEntry.getIndexerSearchResultsByIndexer().values().stream().flatMap(Collection::stream).filter(IndexerSearchResult::isWasSuccessful).flatMap(x -> x.getSearchResultItems().stream()).collect(Collectors.toList());
        DuplicateDetectionResult duplicateDetectionResult = duplicateDetector.detectDuplicates(searchResultItems);
        createOrUpdateIndexerSearchEntity(searchCacheEntry, indexersToSearchAndTheirResults, duplicateDetectionResult);
        searchResult.setDuplicateDetectionResult(duplicateDetectionResult);
        indexersToSearchAndTheirResults = getIndexerSearchResultsToSearch(indexersToSearchAndTheirResults);
        searchResult.getReasonsForRejection().clear();
        indexersToSearchAndTheirResults.values().forEach(x -> x.forEach(y -> y.getReasonsForRejection().entrySet().forEach(z -> searchResult.getReasonsForRejection().add(z.getElement(), z.getCount()))));
        numberOfResultsAlreadyFound = searchResult.calculateNumberOfResults();
    }
    return searchResult;
}

Output:
     }
-    return searchResult;
+    searchCacheEntry.setLastSearchResult(searchResult);
+    return searchCacheEntry.getLastSearchResult();
 }


Input:
public void onAttatch(MainContract.View view) {
    super.onAttatch(view);
    registerEvent();
}

Output:
     super.onAttatch(view);
-    registerEvent();
+    initEvent();
 }


Input:
private void writeNewPlainClassDesc(final Class<?> forClass) throws IOException {
    write(TC_CLASSDESC);
    writeUTF(classResolver.getClassName(forClass));
    descriptorCache.put(forClass, instanceSeq++);
    if (forClass.isEnum()) {
        writeLong(0L);
        write(SC_SERIALIZABLE | SC_ENUM);
        writeShort(0);
    } else if (Serializable.class.isAssignableFrom(forClass)) {
        final SerializableClass sc = registry.lookup(forClass);
        final long svu = sc.getEffectiveSerialVersionUID();
        writeLong(svu);
        if (Externalizable.class.isAssignableFrom(forClass)) {
            write(SC_EXTERNALIZABLE + SC_BLOCK_DATA);
            writeShort(0);
        } else {
            if (sc.hasWriteObject()) {
                write(SC_WRITE_METHOD + SC_SERIALIZABLE);
            } else {
                write(SC_SERIALIZABLE);
            }
            final SerializableField[] fields = sc.getFields();
            writeShort(fields.length);
            for (SerializableField field : fields) {
                final SerializableField.Kind kind = field.getKind();
                final String name = field.getName();
                final Class<?> type;
                try {
                    type = field.getType();
                } catch (ClassNotFoundException e) {
                    throw new InvalidClassException(forClass.getName(), "String_Node_Str" + name + "String_Node_Str");
                }
                if (kind != SerializableField.Kind.OBJECT) {
                    write(primitives.get(type, -1));
                    writeUTF(name);
                }
            }
            for (SerializableField field : fields) {
                final SerializableField.Kind kind = field.getKind();
                final String name = field.getName();
                final Class<?> type;
                try {
                    type = field.getType();
                } catch (ClassNotFoundException e) {
                    throw new InvalidClassException(forClass.getName(), "String_Node_Str" + name + "String_Node_Str");
                }
                if (kind == SerializableField.Kind.OBJECT) {
                    final String signature = getSignature(type);
                    write(signature.charAt(0));
                    writeUTF(name);
                    writeObject(signature);
                }
            }
        }
    } else {
        writeLong(0L);
        write(0);
        writeShort(0);
    }
    classResolver.annotateClass(blockMarshaller, forClass);
    doEndBlock();
    final Class<?> sc = forClass.getSuperclass();
    if (Serializable.class.isAssignableFrom(sc)) {
        writeClassDescFor(sc);
    } else {
        write(TC_NULL);
    }
}

Output:
             for (SerializableField field : fields) {
-                final SerializableField.Kind kind = field.getKind();
+                final Kind kind = field.getKind();
                 final String name = field.getName();


Input:
private Collection<String> getAllUsedBindingNames() {
    Set<String> set = new HashSet<String>();
    for (IQueryExpressionManager iqem : textCollection.values()) {
        IExpressionButton eb = iqem.getExpressionButton();
        if (eb != null) {
            String name = exprCodec.getBindingName(eb.getExpression());
            if (name != null) {
                set.add(name);
            }
        }
    }
    return set;
}

Output:
 private Collection<String> getAllUsedBindingNames() {
-    Set<String> set = new HashSet<String>();
+    Set<String> set = new HashSet<String>(5);
     for (IQueryExpressionManager iqem : textCollection.values()) {


Input:
private String getBodyAsMessage(ClientResponseContext responseContext) throws IOException {
    if (responseContext.hasEntity()) {
        int contentLength = responseContext.getLength();
        if (contentLength != -1) {
            byte[] buffer = new byte[contentLength];
            try {
                InputStream entityStream = responseContext.getEntityStream();
                IOUtils.readFully(entityStream, buffer);
                entityStream.close();
            } catch (EOFException e) {
                return null;
            }
            Charset charset = null;
            MediaType mediaType = responseContext.getMediaType();
            if (mediaType != null) {
                String charsetName = mediaType.getParameters().get("String_Node_Str");
                if (charsetName != null) {
                    try {
                        charset = Charset.forName(charsetName);
                    } catch (Exception e) {
                    }
                }
            }
            if (charset == null) {
                charset = Charset.defaultCharset();
            }
            return new String(buffer, charset);
        }
    }
    return null;
}

Output:
     if (responseContext.hasEntity()) {
-        int contentLength = responseContext.getLength();
-        if (contentLength != -1) {
-            byte[] buffer = new byte[contentLength];
-            try {
-                InputStream entityStream = responseContext.getEntityStream();
-                IOUtils.readFully(entityStream, buffer);
-                entityStream.close();
-            } catch (EOFException e) {
-                return null;
-            }
+        try (InputStream entityStream = responseContext.getEntityStream()) {
             Charset charset = null;


Input:
public void mouseDoubleClick(MouseEvent e) {
    String text = getTextToInsert();
    if (text.length() > 0) {
        insertText(text);
    }
}

Output:
 public void mouseDoubleClick(MouseEvent e) {
-    String text = getTextToInsert();
-    if (text.length() > 0) {
-        insertText(text);
-    }
+    insertTreeItemText();
 }


Input:
public static Set<String> getReferencedMeasure(String expr) {
    if (expr == null)
        return Collections.EMPTY_SET;
    try {
        Set<String> result = new LinkedHashSet<String>();
        Context cx = Context.enter();
        CompilerEnvirons ce = new CompilerEnvirons();
        Parser p = new Parser(ce, cx.getErrorReporter());
        AstRoot tree = p.parse(expr, null, 0);
        getScriptObjectName(tree, "String_Node_Str", result);
        return result;
    } catch (Exception e) {
        return Collections.EMPTY_SET;
    } finally {
        Context.exit();
    }
}

Output:
     if (expr == null)
-        return Collections.EMPTY_SET;
+        return Collections.emptySet();
     try {


Input:
private void writeAutoRelated(BufferedWriter writer, String category, String column, ZeroNullType dataZeroVsNulls) throws FishLinkException {
    String related = FishLinkConstants.autoRelatedCategory(category);
    if (related == null) {
        return;
    }
    String uri = categoryUris.get(related);
    if (uri == null) {
        return;
    }
    writeVocab(writer, related);
    writeUriOther(writer, uri, category, column, dataZeroVsNulls);
    try {
        writer.write("String_Node_Str");
        writer.newLine();
    } catch (IOException ex) {
        throw new FishLinkException("String_Node_Str", ex);
    }
}

Output:
     writeVocab(writer, related);
-    writeUriOther(writer, uri, category, column, dataZeroVsNulls);
+    writeUriForOther(writer, related, column, dataZeroVsNulls);
     try {


Input:
public String addStudent(int id, int capacity, int start, int end) {
    if (students.containsKey(id)) {
        return "String_Node_Str" + id;
    }
    Student student = new Student();
    HashSet<Integer> timeSlots = student.timeSlots;
    for (int i = start; i <= end; i++) {
        timeSlots.add(i);
    }
    return "String_Node_Str" + id;
}

Output:
     }
-    Student student = new Student();
-    HashSet<Integer> timeSlots = student.timeSlots;
-    for (int i = start; i <= end; i++) {
-        timeSlots.add(i);
-    }
+    Student student = new Student(capacity, start, end);
+    students.put(id, student);
     return "String_Node_Str" + id;


Input:
public String getDescription() {
    if (this.description == null) {
        StringBuilder descriptionSB = new StringBuilder();
        descriptionSB.append("String_Node_Str");
        descriptionSB.append("String_Node_Str");
        descriptionSB.append(this.schemaName);
        descriptionSB.append("String_Node_Str");
        descriptionSB.append(this.schemaChecksum);
        descriptionSB.append("String_Node_Str");
        descriptionSB.append(this.cubeName);
        descriptionSB.append("String_Node_Str");
        descriptionSB.append(this.measureName);
        descriptionSB.append("String_Node_Str");
        descriptionSB.append("String_Node_Str");
        for (SegmentColumn c : constrainedColumns) {
            descriptionSB.append("String_Node_Str");
            descriptionSB.append(c.columnExpression);
            descriptionSB.append("String_Node_Str");
            if (c.values == null) {
                descriptionSB.append("String_Node_Str");
            } else {
                for (Object value : c.values) {
                    descriptionSB.append("String_Node_Str");
                    descriptionSB.append(value);
                    descriptionSB.append("String_Node_Str");
                }
            }
            descriptionSB.deleteCharAt(descriptionSB.length() - 1);
            descriptionSB.append("String_Node_Str");
        }
        descriptionSB.append("String_Node_Str");
        descriptionSB.append("String_Node_Str");
        for (SegmentColumn c : excludedRegions) {
            descriptionSB.append("String_Node_Str");
            descriptionSB.append(c.columnExpression);
            descriptionSB.append("String_Node_Str");
            if (c.values == null) {
                descriptionSB.append("String_Node_Str");
            } else {
                for (Object value : c.values) {
                    descriptionSB.append("String_Node_Str");
                    descriptionSB.append(value);
                    descriptionSB.append("String_Node_Str");
                }
            }
            descriptionSB.deleteCharAt(descriptionSB.length() - 1);
            descriptionSB.append("String_Node_Str");
        }
        descriptionSB.append("String_Node_Str");
        descriptionSB.append("String_Node_Str");
        for (String c : compoundPredicates) {
            descriptionSB.append("String_Node_Str");
            descriptionSB.append(c);
        }
        descriptionSB.append("String_Node_Str").append("String_Node_Str").append(getUniqueID()).append("String_Node_Str");
        this.description = descriptionSB.toString();
    }
    return description;
}

Output:
         descriptionSB.append("String_Node_Str");
-        for (SegmentColumn c : constrainedColumns) {
+        for (SegmentColumn c : getSortedColumns()) {
             descriptionSB.append("String_Node_Str");


Input:
public TagChanges get() throws OpsException {
    TagChanges tagChanges = new TagChanges();
    EndpointInfo endpointInfo = endpointHelpers.findEndpoint(endpoint.getTags(), publicPort);
    if (endpointInfo == null) {
        throw new OpsException("String_Node_Str" + publicPort);
    }
    tagChanges.addTags.add(new Tag(Tag.PUBLIC_ENDPOINT, endpointInfo.publicIp + "String_Node_Str" + endpointInfo.port));
    return tagChanges;
}

Output:
     TagChanges tagChanges = new TagChanges();
-    EndpointInfo endpointInfo = endpointHelpers.findEndpoint(endpoint.getTags(), publicPort);
+    PublicEndpointBase item = endpoint.getItem();
+    if (item == null) {
+        if (!OpsContext.isDelete()) {
+            throw new OpsException("String_Node_Str");
+        } else {
+            log.warn("String_Node_Str");
+            return null;
+        }
+    }
+    EndpointInfo endpointInfo = endpointHelpers.findEndpoint(item.getTags(), publicPort);
     if (endpointInfo == null) {


Input:
public List<MoveLine> createMoveLines(Invoice invoice, Move move, Company company, Partner partner, Account account, boolean consolidate, boolean isPurchase, boolean isDebitCustomer) throws AxelorException {
    LOG.debug("String_Node_Str", invoice.getInvoiceId());
    Account account2 = account;
    List<MoveLine> moveLines = new ArrayList<MoveLine>();
    AccountManagement accountManagement = null;
    Set<AnalyticAccount> analyticAccounts = new HashSet<AnalyticAccount>();
    BigDecimal exTaxTotal = null;
    int moveLineId = 1;
    if (partner == null) {
        throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_1), invoice.getInvoiceId()), IException.MISSING_FIELD);
    }
    if (account2 == null) {
        throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_2), invoice.getInvoiceId()), IException.MISSING_FIELD);
    }
    moveLines.add(this.createMoveLine(move, partner, account2, invoice.getCompanyInTaxTotal(), isDebitCustomer, invoice.getInvoiceDate(), invoice.getDueDate(), moveLineId++, invoice.getInvoiceId()));
    for (InvoiceLine invoiceLine : invoice.getInvoiceLineList()) {
        analyticAccounts.clear();
        Product product = invoiceLine.getProduct();
        if (product == null) {
            throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_3), invoice.getInvoiceId(), company.getName()), IException.CONFIGURATION_ERROR);
        }
        accountManagement = accountManagementService.getAccountManagement(product, company);
        account2 = accountManagementService.getProductAccount(accountManagement, isPurchase);
        if (account2 == null) {
            throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_4), invoiceLine.getName(), company.getName()), IException.CONFIGURATION_ERROR);
        }
        for (AnalyticAccountManagement analyticAccountManagement : accountManagement.getAnalyticAccountManagementList()) {
            if (analyticAccountManagement.getAnalyticAccount() == null) {
                throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_5), analyticAccountManagement.getAnalyticAxis().getName(), invoiceLine.getProductName(), company.getName()), IException.CONFIGURATION_ERROR);
            }
            analyticAccounts.add(analyticAccountManagement.getAnalyticAccount());
        }
        exTaxTotal = invoiceLine.getCompanyExTaxTotal();
        LOG.debug("String_Node_Str", new Object[] { account2.getName(), exTaxTotal });
        if (exTaxTotal.compareTo(BigDecimal.ZERO) != 0) {
            MoveLine moveLine = this.createMoveLine(move, partner, account2, exTaxTotal, !isDebitCustomer, invoice.getInvoiceDate(), null, moveLineId++, invoice.getInvoiceId());
            moveLine.setAnalyticAccountSet(analyticAccounts);
            moveLine.setTaxLine(invoiceLine.getTaxLine());
            moveLines.add(moveLine);
        }
    }
    for (InvoiceLineTax invoiceLineTax : invoice.getInvoiceLineTaxList()) {
        Tax tax = invoiceLineTax.getTaxLine().getTax();
        account2 = taxAccountService.getAccount(tax, company);
        exTaxTotal = invoiceLineTax.getCompanyTaxTotal();
        if (account2 == null) {
            throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_6), tax.getName(), company.getName()), IException.CONFIGURATION_ERROR);
        }
        if (exTaxTotal.compareTo(BigDecimal.ZERO) != 0) {
            MoveLine moveLine = this.createMoveLine(move, partner, account2, exTaxTotal, !isDebitCustomer, invoice.getInvoiceDate(), null, moveLineId++, invoice.getInvoiceId());
            moveLine.setTaxLine(invoiceLineTax.getTaxLine());
            moveLines.add(moveLine);
        }
    }
    if (consolidate) {
        this.consolidateMoveLines(moveLines);
    }
    return moveLines;
}

Output:
     for (InvoiceLine invoiceLine : invoice.getInvoiceLineList()) {
-        analyticAccounts.clear();
-        Product product = invoiceLine.getProduct();
-        if (product == null) {
-            throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_3), invoice.getInvoiceId(), company.getName()), IException.CONFIGURATION_ERROR);
-        }
-        accountManagement = accountManagementService.getAccountManagement(product, company);
-        account2 = accountManagementService.getProductAccount(accountManagement, isPurchase);
-        if (account2 == null) {
-            throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_4), invoiceLine.getName(), company.getName()), IException.CONFIGURATION_ERROR);
-        }
-        for (AnalyticAccountManagement analyticAccountManagement : accountManagement.getAnalyticAccountManagementList()) {
-            if (analyticAccountManagement.getAnalyticAccount() == null) {
-                throw new AxelorException(String.format(I18n.get(IExceptionMessage.MOVE_LINE_5), analyticAccountManagement.getAnalyticAxis().getName(), invoiceLine.getProductName(), company.getName()), IException.CONFIGURATION_ERROR);
-            }
-            analyticAccounts.add(analyticAccountManagement.getAnalyticAccount());
-        }
-        exTaxTotal = invoiceLine.getCompanyExTaxTotal();
-        LOG.debug("String_Node_Str", new Object[] { account2.getName(), exTaxTotal });
+        BigDecimal exTaxTotal = invoiceLine.getCompanyExTaxTotal();
         if (exTaxTotal.compareTo(BigDecimal.ZERO) != 0) {


Input:
public CubeDesc updateCubeAndDesc(CubeInstance cube, CubeDesc desc, String newProjectName) throws UnknownHostException, IOException, JobException {
    List<JobInstance> jobInstances = this.getJobManager().listJobs(cube.getName(), null);
    for (JobInstance jobInstance : jobInstances) {
        if (jobInstance.getStatus() == JobStatusEnum.PENDING || jobInstance.getStatus() == JobStatusEnum.RUNNING) {
            throw new JobException("String_Node_Str");
        }
    }
    try {
        if (!cube.getDescriptor().calculateSignature().equals(cube.getDescriptor().getSignature())) {
            this.releaseAllSegments(cube);
        }
        CubeDesc updatedCubeDesc = getCubeDescManager().updateCubeDesc(desc);
        int cuboidCount = CuboidCLI.simulateCuboidGeneration(updatedCubeDesc);
        logger.info("String_Node_Str" + cube.getName() + "String_Node_Str" + cuboidCount + "String_Node_Str");
        ProjectManager projectManager = getProjectManager();
        if (!isCubeInProject(newProjectName, cube)) {
            String owner = SecurityContextHolder.getContext().getAuthentication().getName();
            ProjectInstance newProject = projectManager.updateRealizationToProject(RealizationType.CUBE, cube.getName(), newProjectName, owner);
            accessService.inherit(cube, newProject);
        }
        return updatedCubeDesc;
    } catch (IOException e) {
        throw new InternalErrorException("String_Node_Str", e);
    } catch (CubeIntegrityException e) {
        throw new InternalErrorException("String_Node_Str", e);
    }
}

Output:
             String owner = SecurityContextHolder.getContext().getAuthentication().getName();
-            ProjectInstance newProject = projectManager.updateRealizationToProject(RealizationType.CUBE, cube.getName(), newProjectName, owner);
+            ProjectInstance newProject = projectManager.moveRealizationToProject(RealizationType.CUBE, cube.getName(), newProjectName, owner);
             accessService.inherit(cube, newProject);


Input:
protected boolean performInsert(Object model, SlotHandle slotHandle, String type, String position, Map extendData) throws Exception {
    if (type == ReportDesignConstants.CASCADING_PARAMETER_GROUP_ELEMENT) {
        DesignElementHandle handle = super.createElement(type);
        slotHandle.add(handle);
        CascadingParametersDialog dialog = new CascadingParametersDialog(PlatformUI.getWorkbench().getDisplay().getActiveShell(), Messages.getString("String_Node_Str"));
        dialog.setInput(handle);
        return (dialog.open() == Dialog.OK);
    }
    return super.performInsert(model, slotHandle, type, position, extendData);
}

Output:
 protected boolean performInsert(Object model, SlotHandle slotHandle, String type, String position, Map extendData) throws Exception {
-    if (type == ReportDesignConstants.CASCADING_PARAMETER_GROUP_ELEMENT) {
+    if (ReportDesignConstants.CASCADING_PARAMETER_GROUP_ELEMENT.equals(type)) {
         DesignElementHandle handle = super.createElement(type);


Input:
public String getCanonicalForm(Dimension nativeSize, ImageApiProfile profile, Quality defaultQuality) {
    return String.format("String_Node_Str", identifier != null ? urlEncode(identifier) + "String_Node_Str" : "String_Node_Str", region.getCanonicalForm(nativeSize), size.getCanonicalForm(nativeSize, profile), rotation.toString(), quality.equals(defaultQuality) ? "String_Node_Str" : quality.toString(), format.toString());
}

Output:
 public String getCanonicalForm(Dimension nativeSize, ImageApiProfile profile, Quality defaultQuality) {
-    return String.format("String_Node_Str", identifier != null ? urlEncode(identifier) + "String_Node_Str" : "String_Node_Str", region.getCanonicalForm(nativeSize), size.getCanonicalForm(nativeSize, profile), rotation.toString(), quality.equals(defaultQuality) ? "String_Node_Str" : quality.toString(), format.toString());
+    Dimension scaleReference = nativeSize;
+    Rectangle2D canonicalRegion = RegionRequest.fromString(region.getCanonicalForm(nativeSize)).getRegion();
+    if (canonicalRegion != null) {
+        scaleReference = new Dimension((int) canonicalRegion.getWidth(), (int) canonicalRegion.getHeight());
+    }
+    return String.format("String_Node_Str", identifier != null ? urlEncode(identifier) + "String_Node_Str" : "String_Node_Str", region.getCanonicalForm(nativeSize), size.getCanonicalForm(scaleReference, profile), rotation.toString(), quality.equals(defaultQuality) ? "String_Node_Str" : quality.toString(), format.toString());
 }


Input:
public void configure() {
    bind(ThriftClientProvider.class).toProvider(ThriftClientProviderSupplier.class);
    bind(QueueClientFactory.class).to(HBaseQueueClientFactory.class).in(Singleton.class);
    bind(QueueAdmin.class).to(HBaseQueueAdmin.class).in(Singleton.class);
    bind(HBaseTableUtil.class).toProvider(HBaseTableUtilFactory.class);
    bind(TxMetricsCollector.class).to(TransactionManagerMetricsCollector.class).in(Scopes.SINGLETON);
    bind(TransactionSystemClientService.class).to(DistributedTransactionSystemClientService.class);
    install(new TransactionModules().getDistributedModules());
    install(new TransactionExecutorModule());
}

Output:
     bind(TransactionSystemClientService.class).to(DistributedTransactionSystemClientService.class);
-    install(new TransactionModules().getDistributedModules());
+    install(new TransactionModules(txClientId).getDistributedModules());
     install(new TransactionExecutorModule());


Input:
public Container limit(int maxcardinality) {
    if (maxcardinality >= this.cardinality) {
        return clone();
    }
    if (maxcardinality < ArrayContainer.DEFAULT_MAX_SIZE) {
        ArrayContainer ac = new ArrayContainer(maxcardinality);
        int pos = 0;
        for (int k = 0; (ac.cardinality < maxcardinality) && (k < bitmap.length); ++k) {
            long bitset = bitmap[k];
            while ((ac.cardinality < maxcardinality) && (bitset != 0)) {
                long t = bitset & -bitset;
                ac.content[pos++] = (short) (k * 64 + Long.bitCount(t - 1));
                ac.cardinality++;
                bitset ^= t;
            }
        }
        return ac;
    }
    BitmapContainer bc = new BitmapContainer(maxcardinality, this.bitmap);
    int s = Util.toIntUnsigned(select(maxcardinality));
    int usedwords = (s + 63) / 64;
    int todelete = this.bitmap.length - usedwords;
    for (int k = 0; k < todelete; ++k) bc.bitmap[bc.bitmap.length - 1 - k] = 0;
    int lastword = s % 64;
    if (lastword != 0) {
        bc.bitmap[s / 64] = (bc.bitmap[s / 64] << (64 - lastword)) >> (64 - lastword);
    }
    return bc;
}

Output:
     }
-    if (maxcardinality < ArrayContainer.DEFAULT_MAX_SIZE) {
+    if (maxcardinality <= ArrayContainer.DEFAULT_MAX_SIZE) {
         ArrayContainer ac = new ArrayContainer(maxcardinality);


Input:
public static Path exportSubgraphToHDFS(GraphDatabaseService db) throws IOException, URISyntaxException {
    FileSystem fs = FileUtil.getHadoopFileSystem();
    Path pt = new Path(ConfigurationLoader.getInstance().getHadoopHdfsUri() + EDGE_LIST_RELATIVE_FILE_PATH);
    BufferedWriter br = new BufferedWriter(new OutputStreamWriter(fs.create(pt)));
    Transaction tx = db.beginTx();
    Iterable<Node> nodes = GlobalGraphOperations.at(db).getAllNodes();
    br.write("String_Node_Str" + "String_Node_Str");
    int nodeTotal = IteratorUtil.count(nodes);
    final int[] nodeCount = { 0 };
    final int[] pathCount = { 0 };
    int pathCountBlocks = 10000;
    int size = IteratorUtil.count(nodes.iterator());
    nodes.iterator().forEachRemaining(n -> {
        Iterable<org.neo4j.graphdb.Path> nPaths = db.traversalDescription().depthFirst().relationships(withName(ConfigurationLoader.getInstance().getMazerunnerRelationshipType()), Direction.OUTGOING).evaluator(Evaluators.fromDepth(1)).evaluator(Evaluators.toDepth(1)).traverse(n);
        for (org.neo4j.graphdb.Path path : nPaths) {
            try {
                String line = path.startNode().getId() + "String_Node_Str" + path.endNode().getId();
                br.write(line + "String_Node_Str");
                pathCount[0]++;
                if (pathCount[0] > pathCountBlocks) {
                    pathCount[0] = 0;
                    System.out.println("String_Node_Str" + MessageFormat.format("String_Node_Str", ((double) nodeCount[0] / (double) nodeTotal)));
                }
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
        }
        nodeCount[0]++;
    });
    System.out.println("String_Node_Str" + MessageFormat.format("String_Node_Str", 1.0));
    br.flush();
    br.close();
    tx.success();
    tx.close();
    return pt;
}

Output:
     FileSystem fs = FileUtil.getHadoopFileSystem();
-    Path pt = new Path(ConfigurationLoader.getInstance().getHadoopHdfsUri() + EDGE_LIST_RELATIVE_FILE_PATH);
+    Path pt = new Path(ConfigurationLoader.getInstance().getHadoopHdfsUri() + EDGE_LIST_RELATIVE_FILE_PATH.replace("String_Node_Str", "String_Node_Str"));
     BufferedWriter br = new BufferedWriter(new OutputStreamWriter(fs.create(pt)));


Input:
private static void addPropertiesForRuleStr(ICalendar.Component component, String propertyName, String ruleStr) {
    if (TextUtils.isEmpty(ruleStr)) {
        return;
    }
    String[] rrules = ruleStr.split(RULE_SEPARATOR);
    for (String rrule : rrules) {
        ICalendar.Property prop = new ICalendar.Property(propertyName);
        prop.setValue(rrule);
        component.addProperty(prop);
    }
}

Output:
     }
-    String[] rrules = ruleStr.split(RULE_SEPARATOR);
+    String[] rrules = getRuleStrings(ruleStr);
     for (String rrule : rrules) {


Input:
static CallerInfoToken startGetCallerInfo(Context context, Connection c, CallerInfoAsyncQuery.OnQueryCompleteListener listener, Object cookie) {
    CallerInfoToken cit;
    if (c == null) {
        cit = new CallerInfoToken();
        cit.asyncQuery = null;
        return cit;
    }
    Object userDataObject = c.getUserData();
    if (userDataObject instanceof Uri) {
        cit = new CallerInfoToken();
        cit.currentInfo = new CallerInfo();
        cit.asyncQuery = CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context, (Uri) userDataObject, sCallerInfoQueryListener, c);
        cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
        cit.isFinal = false;
        c.setUserData(cit);
        if (DBG)
            log("String_Node_Str" + userDataObject);
    } else if (userDataObject == null) {
        String number = c.getAddress();
        int cnapSpecialCase;
        cit = new CallerInfoToken();
        cit.currentInfo = new CallerInfo();
        if (DBG)
            log("String_Node_Str" + number);
        if (!TextUtils.isEmpty(number)) {
            cit.currentInfo.cnapName = c.getCnapName();
            cit.currentInfo.name = cit.currentInfo.cnapName;
            cit.currentInfo.numberPresentation = c.getNumberPresentation();
            cit.currentInfo.namePresentation = c.getCnapNamePresentation();
            if (DBG)
                log("String_Node_Str" + cit.currentInfo.cnapName + "String_Node_Str" + cit.currentInfo.numberPresentation);
            if (cit.currentInfo.numberPresentation == Connection.PRESENTATION_ALLOWED) {
                cnapSpecialCase = checkCnapSpecialCases(number);
                if (cnapSpecialCase != CNAP_SPECIAL_CASE_NO) {
                    if (cnapSpecialCase == Connection.PRESENTATION_RESTRICTED) {
                        number = context.getString(R.string.private_num);
                    } else if (cnapSpecialCase == Connection.PRESENTATION_UNKNOWN) {
                        number = context.getString(R.string.unknown);
                    }
                    cit.currentInfo.numberPresentation = cnapSpecialCase;
                }
            }
            cit.currentInfo.phoneNumber = number;
            cit.asyncQuery = CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context, number, sCallerInfoQueryListener, c);
            cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
            cit.isFinal = false;
        } else {
            if (DBG)
                log("String_Node_Str");
            cit.isFinal = true;
        }
        c.setUserData(cit);
        if (DBG)
            log("String_Node_Str" + number);
    } else if (userDataObject instanceof CallerInfoToken) {
        cit = (CallerInfoToken) userDataObject;
        if (cit.asyncQuery != null) {
            cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
            if (DBG)
                log("String_Node_Str" + listener.getClass().toString());
        } else {
            if (DBG)
                log("String_Node_Str");
            if (cit.currentInfo == null) {
                cit.currentInfo = new CallerInfo();
            }
            cit.isFinal = true;
        }
    } else {
        cit = new CallerInfoToken();
        cit.currentInfo = (CallerInfo) userDataObject;
        cit.asyncQuery = null;
        cit.isFinal = true;
        if (DBG)
            log("String_Node_Str");
    }
    return cit;
}

Output:
             if (DBG)
-                log("String_Node_Str");
-            if (cit.currentInfo == null) {
-                cit.currentInfo = new CallerInfo();
+                log("String_Node_Str" + updatedNumber);
+            if (!TextUtils.isEmpty(updatedNumber)) {
+                cit.currentInfo.phoneNumber = updatedNumber;
+                cit.currentInfo.cnapName = c.getCnapName();
+                cit.currentInfo.name = cit.currentInfo.cnapName;
+                cit.currentInfo.numberPresentation = c.getNumberPresentation();
+                cit.currentInfo.namePresentation = c.getCnapNamePresentation();
+                if (DBG)
+                    log("String_Node_Str" + cit.currentInfo.cnapName + "String_Node_Str" + cit.currentInfo.numberPresentation);
+                cit.asyncQuery = CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context, updatedNumber, sCallerInfoQueryListener, c);
+                cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
+                cit.isFinal = false;
+            } else {
+                if (DBG)
+                    log("String_Node_Str");
+                if (cit.currentInfo == null) {
+                    cit.currentInfo = new CallerInfo();
+                }
+                cit.isFinal = true;
             }


Input:
public org.hl7.fhir.dstu2.model.TestScript.TestScriptVariableComponent convertTestScriptVariableComponent(org.hl7.fhir.dstu3.model.TestScript.TestScriptVariableComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.TestScript.TestScriptVariableComponent tgt = new org.hl7.fhir.dstu2.model.TestScript.TestScriptVariableComponent();
    copyElement(src, tgt);
    tgt.setName(src.getName());
    tgt.setHeaderField(src.getHeaderField());
    tgt.setPath(src.getPath());
    tgt.setSourceId(src.getSourceId());
    return tgt;
}

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


Input:
public void testInvalidIdRestartInstances() throws Exception {
    String path = String.format("String_Node_Str", Constants.Gateway.API_VERSION_3, Constants.Service.APP_FABRIC_HTTP);
    HttpResponse response = doPut(path);
    Assert.assertEquals(HttpResponseStatus.BAD_REQUEST.getCode(), response.getStatusLine().getStatusCode());
    path = String.format("String_Node_Str", Constants.Gateway.API_VERSION_3, Constants.Service.APP_FABRIC_HTTP);
    response = doGet(path);
    Assert.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatusLine().getStatusCode());
    RestartServiceInstancesStatus result = GSON.fromJson(new String(ByteStreams.toByteArray(response.getEntity().getContent()), Charsets.UTF_8), RestartServiceInstancesStatus.class);
    Assert.assertNotNull(result);
    Assert.assertEquals(Constants.Service.APP_FABRIC_HTTP, result.getServiceName());
    Assert.assertEquals(RestartServiceInstancesStatus.RestartStatus.FAILURE, result.getStatus());
}

Output:
     String path = String.format("String_Node_Str", Constants.Gateway.API_VERSION_3, Constants.Service.APP_FABRIC_HTTP);
-    HttpResponse response = doPut(path);
+    HttpResponse response = doPost(path);
     Assert.assertEquals(HttpResponseStatus.BAD_REQUEST.getCode(), response.getStatusLine().getStatusCode());


Input:
protected void beginDraw(boolean clear0) {
    if (!clear0 && glColorFbo[0] != 0) {
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, glColorFbo[0]);
        GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, glColorTex[backTex], 0);
        usingFBOlayer = true;
    } else {
        usingFBOlayer = false;
    }
}

Output:
 protected void beginDraw(boolean clear0) {
-    if (!clear0 && glColorFbo[0] != 0) {
+    if ((!clear0 || FORCE_SCREEN_FBO) && glColorFbo[0] != 0) {
         GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, glColorFbo[0]);


Input:
public static int getComboID(ItemStack sandwich) {
    for (int i = 0; i < combos.length; i++) if (combos[i].matches(sandwich))
        return i;
    return 0;
}

Output:
 public static int getComboID(ItemStack sandwich) {
-    for (int i = 0; i < combos.length; i++) if (combos[i].matches(sandwich))
+    for (int i = 1; i < combos.length && combos[i] != null; i++) if (combos[i].matches(sandwich))
         return i;


Input:
public void commitQueue() {
    if (removed) {
        commitPoll();
    } else {
        offerAgain();
    }
}

Output:
     } else {
-        offerAgain();
+        offerAgain(false);
     }


Input:
String removeSpace(String v) {
    return v;
}

Output:
 String removeSpace(String v) {
-    return v;
+    StringBuilder sb = new StringBuilder(v.length());
+    try {
+        BufferedReader reader = new BufferedReader(new StringReader(v));
+        String line = reader.readLine();
+        while (line != null) {
+            line = line.trim();
+            if (!line.startsWith("String_Node_Str")) {
+                sb.append(line);
+                sb.append('\n');
+            }
+            line = reader.readLine();
+        }
+    } catch (IOException ex) {
+    }
+    return sb.toString();
 }


Input:
public void setUp() throws Exception {
    this.db = new MockDatabase();
    ActiveRecordBase.bootStrap(this.db, getApplicationContext());
    exampleRecord = new ExampleRecord();
    subRecord = new SubRecord();
    subRecord.record = exampleRecord;
    subRecord.id = (long) 123;
    exampleRecord.id = (long) 321;
    exampleRecord.subrecord = subRecord;
    blog = new Blog();
    blog.id = (long) 2;
    post1 = new Post();
    post2 = new Post();
    post1.id = (long) 1;
    post1.blog = blog;
    post2.id = (long) 3;
    post2.blog = blog;
    blog.posts.addAll(post1, post2);
}

Output:
     this.db = new MockDatabase();
-    ActiveRecordBase.bootStrap(this.db, getApplicationContext());
+    ActiveRecordBase.bootStrap(this.db, null);
     exampleRecord = new ExampleRecord();


Input:
protected void __init(HttpServletRequest request) throws Exception {
    if (ParameterAccessor.isGetImageOperator(request)) {
        return;
    }
    this.category = "String_Node_Str";
    this.masterPageContent = ParameterAccessor.isMasterPageContent(request);
    this.isDesigner = ParameterAccessor.isDesigner(request);
    this.bookmark = ParameterAccessor.getBookmark(request);
    this.reportPage = ParameterAccessor.getPage(request);
    this.reportPageRange = ParameterAccessor.getPageRange(request);
    if (IBirtConstants.SERVLET_PATH_FRAMESET.equalsIgnoreCase(request.getServletPath())) {
        this.reportDocumentName = ParameterAccessor.getReportDocument(request, null, true);
    } else {
        this.reportDocumentName = ParameterAccessor.getReportDocument(request, null, false);
    }
    this.reportDesignName = ParameterAccessor.getReport(request, null);
    this.format = ParameterAccessor.getFormat(request);
    this.maxRows = ParameterAccessor.getMaxRows(request);
    BirtResources.setLocale(ParameterAccessor.getLocale(request));
    ReportEngineService.getInstance().setMaxRows(this.maxRows);
    this.requestType = request.getHeader(ParameterAccessor.HEADER_REQUEST_TYPE);
    processReport(request);
    this.reportTitle = ParameterAccessor.getTitle(request);
    this.isShowTitle = ParameterAccessor.isShowTitle(request);
    this.isShowToolbar = ParameterAccessor.isShowToolbar(request);
    this.isShowNavigationbar = ParameterAccessor.isShowNavigationbar(request);
    this.moduleOptions = BirtUtility.getModuleOptions(request);
    this.reportDesignHandle = getDesignHandle(request);
    if (this.reportDesignHandle == null)
        return;
    __initParameters(request);
}

Output:
     this.reportPageRange = ParameterAccessor.getPageRange(request);
-    if (IBirtConstants.SERVLET_PATH_FRAMESET.equalsIgnoreCase(request.getServletPath())) {
+    if (IBirtConstants.SERVLET_PATH_FRAMESET.equalsIgnoreCase(request.getServletPath()) || IBirtConstants.SERVLET_PATH_DOWNLOAD.equalsIgnoreCase(request.getServletPath())) {
         this.reportDocumentName = ParameterAccessor.getReportDocument(request, null, true);


Input:
public static boolean isVideo(String mimeType) {
    return getTopLevelType(mimeType).equals(BASE_TYPE_VIDEO);
}

Output:
 public static boolean isVideo(String mimeType) {
-    return getTopLevelType(mimeType).equals(BASE_TYPE_VIDEO);
+    return BASE_TYPE_VIDEO.equals(getTopLevelType(mimeType));
 }