Input:
private boolean stateSatisfies(TurboIssue issue) {
    if (!content.isPresent())
        return false;
    String content = this.content.get().toLowerCase();
    if (content.contains("String_Node_Str")) {
        return issue.isOpen();
    } else if (content.contains("String_Node_Str")) {
        return !issue.isOpen();
    } else {
        throw new SemanticException(type, type.getValidInputs());
    }
}

Output:
     } else {
-        throw new SemanticException(type, type.getValidInputs());
+        throw new SemanticException(type, type.getDescriptionOfValidInputs());
     }


Input:
public GameResult runGame() throws HSException {
    curTurn_ = 0;
    boardModel_.placeCardHandCurrentPlayer(0);
    boardModel_.placeCardHandCurrentPlayer(1);
    boardModel_.placeCardHandCurrentPlayer(2);
    boardModel_.setDeckPos_p0(3);
    boardModel_.placeCardHandWaitingPlayer(0);
    boardModel_.placeCardHandWaitingPlayer(1);
    boardModel_.placeCardHandWaitingPlayer(2);
    boardModel_.placeCardHandWaitingPlayer(3);
    boardModel_.placeCardHandWaitingPlayer(new TheCoin());
    boardModel_.setDeckPos_p1(4);
    GameRecord record = new GameSimpleRecord();
    record.put(0, PlayerSide.CURRENT_PLAYER, (BoardModel) boardModel_.deepCopy());
    record.put(0, PlayerSide.WAITING_PLAYER, (BoardModel) boardModel_.flipPlayers().deepCopy());
    GameResult gameResult;
    for (int turnCount = 0; turnCount < maxTurns_; ++turnCount) {
        log.info("String_Node_Str" + turnCount);
        long turnStart = System.currentTimeMillis();
        gameResult = playTurn(turnCount, record, ais[s0_]);
        if (gameResult != null)
            return gameResult;
        gameResult = playTurn(turnCount, record, ais[s1_]);
        if (gameResult != null)
            return gameResult;
        long turnEnd = System.currentTimeMillis();
        long turnDelta = turnEnd - turnStart;
        if (turnDelta > ArtificialPlayer.MAX_THINK_TIME / 2) {
            log.warn("String_Node_Str", turnDelta, ArtificialPlayer.MAX_THINK_TIME);
        } else {
            log.debug("String_Node_Str", turnDelta);
        }
    }
    return new GameResult(s0_, -1, 0, record);
}

Output:
     record.put(0, PlayerSide.CURRENT_PLAYER, (BoardModel) boardModel_.deepCopy());
-    record.put(0, PlayerSide.WAITING_PLAYER, (BoardModel) boardModel_.flipPlayers().deepCopy());
+    record.put(0, PlayerSide.CURRENT_PLAYER, (BoardModel) boardModel_.flipPlayers().deepCopy());
     GameResult gameResult;


Input:
public String getProblemMessage() {
    Exception e = problem;
    if (e == null) {
        return "String_Node_Str";
    }
    String errMsg = e instanceof RuntimeException ? e.getMessage() : e.toString();
    if (errMsg == null || errMsg.length() == 0 || "String_Node_Str".equals(errMsg)) {
        errMsg = e.getClass().getName() + "String_Node_Str" + e.getStackTrace()[0].toString();
    }
    return errMsg;
}

Output:
 public String getProblemMessage() {
-    Exception e = problem;
-    if (e == null) {
-        return "String_Node_Str";
-    }
-    String errMsg = e instanceof RuntimeException ? e.getMessage() : e.toString();
-    if (errMsg == null || errMsg.length() == 0 || "String_Node_Str".equals(errMsg)) {
-        errMsg = e.getClass().getName() + "String_Node_Str" + e.getStackTrace()[0].toString();
-    }
-    return errMsg;
+    return StringUtils.getErrorMessage(problem);
 }


Input:
private Map<String, Object> getRequestMap(Request request, ServerContext context) {
    Map<String, Object> requestMap = new HashMap<String, Object>();
    JsonValue value = new JsonValue(null);
    String id = request.getResourceName();
    if (request instanceof ActionRequest) {
        value = ((ActionRequest) request).getContent();
        requestMap.put("String_Node_Str", ((ActionRequest) request).getAdditionalActionParameters());
        requestMap.put("String_Node_Str", "String_Node_Str");
        requestMap.put("String_Node_Str", ((ActionRequest) request).getAction());
    } else if (request instanceof CreateRequest) {
        CreateRequest createRequest = (CreateRequest) request;
        value = createRequest.getContent();
        requestMap.put("String_Node_Str", "String_Node_Str");
        id = createRequest.getResourceName() + "String_Node_Str" + createRequest.getNewResourceId();
    } else if (request instanceof ReadRequest) {
        requestMap.put("String_Node_Str", "String_Node_Str");
    } else if (request instanceof UpdateRequest) {
        value = ((UpdateRequest) request).getNewContent();
        requestMap.put("String_Node_Str", "String_Node_Str");
    } else if (request instanceof DeleteRequest) {
        requestMap.put("String_Node_Str", "String_Node_Str");
    } else if (request instanceof PatchRequest) {
        requestMap.put("String_Node_Str", "String_Node_Str");
    } else if (request instanceof QueryRequest) {
        requestMap.put("String_Node_Str", ((QueryRequest) request).getAdditionalQueryParameters());
        requestMap.put("String_Node_Str", "String_Node_Str");
    } else {
        requestMap.put("String_Node_Str", null);
    }
    if (context.containsContext(SecurityContext.class)) {
        requestMap.put("String_Node_Str", context.asContext(SecurityContext.class).getAuthorizationId());
    }
    if (context.containsContext(HttpContext.class)) {
        HttpContext httpContext = context.asContext(HttpContext.class);
        requestMap.put("String_Node_Str", httpContext.getHeaders());
        requestMap.put("String_Node_Str", "String_Node_Str");
        requestMap.put("String_Node_Str", httpContext.getParameters());
    } else {
        requestMap.put("String_Node_Str", "String_Node_Str");
    }
    requestMap.put("String_Node_Str", request.getRequestType());
    requestMap.put("String_Node_Str", value.getObject());
    requestMap.put("String_Node_Str", id);
    return requestMap;
}

Output:
     }
-    if (context.containsContext(HttpContext.class)) {
+    if (isFromHttp(context)) {
         HttpContext httpContext = context.asContext(HttpContext.class);


Input:
public void loadScreenshots(Property property, ProcessType processType) {
    Resource screenshotResource = getScreenshotResource(property.getItem());
    processType.getScreenshots().addAll(screenshotResource.getContents());
}

Output:
     Resource screenshotResource = getScreenshotResource(property.getItem());
-    processType.getScreenshots().addAll(screenshotResource.getContents());
+    if (screenshotResource != null) {
+        processType.getScreenshots().addAll(screenshotResource.getContents());
+    }
 }


Input:
public void run() {
    LogManager.logDebug("String_Node_Str", this);
    continueRun = true;
    if (ConsoleLogPlugin.getDefault().getPluginPreferences().getBoolean(ConsoleLogPreferenceConstants.REMEMBER_SERVER) != true) {
        new SelectServerDialog(fWindow.getShell()).open();
    }
    if (isValid()) {
        try {
            ScpClient scpclient = new ScpClient();
            serverfileName = fileName.substring(fileName.lastIndexOf('/') + 1);
            tmpfileName = "String_Node_Str" + serverfileName;
            scpclient.transfer(fileName, tmpfileName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        String[] script = buildScript();
        String[] envVars = getEnvironmentVariables();
        if (continueRun) {
            ScriptConsole console = ScriptConsole.getInstance(serverfileName);
            console.run(script, envVars, new PasswordPrompt(IDESessionSettings.password), new StapErrorParser());
            console.getCommand().addInputStreamListener(new ChartStreamDaemon2(console, dataSet, parser));
            try {
                IWorkbenchPage p = PlatformUI.getWorkbench().showPerspective(GraphingPerspective.ID, PlatformUI.getWorkbench().getActiveWorkbenchWindow());
                IViewPart ivp = p.findView(GraphSelectorView.ID);
                String name = console.getName();
                ((GraphSelectorView) ivp).createScriptSet(name.substring(name.lastIndexOf('/') + 1), dataSet);
            } catch (WorkbenchException we) {
            }
        }
    }
    LogManager.logDebug("String_Node_Str", this);
}

Output:
         } catch (Exception e) {
-            e.printStackTrace();
+            continueRun = false;
         }


Input:
private <T> T getValueByXPath(Object object, ObjectBuilder objectBuilder, StringTokenizer stringTokenizer, NamespaceResolver namespaceResolver, Class<T> returnType) {
    if (null == object) {
        return null;
    }
    String xPath = "String_Node_Str";
    XMLField xmlField = new XMLField();
    xmlField.setNamespaceResolver(namespaceResolver);
    while (stringTokenizer.hasMoreElements()) {
        String nextToken = stringTokenizer.nextToken();
        xmlField.setXPath(xPath + nextToken);
        xmlField.initialize();
        DatabaseMapping mapping = objectBuilder.getMappingForField(xmlField);
        if (null == mapping) {
            XPathFragment xPathFragment = new XPathFragment(nextToken);
            if (xPathFragment.getIndexValue() > 0) {
                xmlField.setXPath(xPath + nextToken.substring(0, nextToken.indexOf('[')));
                xmlField.initialize();
                mapping = objectBuilder.getMappingForField(xmlField);
                if (null != mapping) {
                    if (mapping.isCollectionMapping()) {
                        if (mapping.getContainerPolicy().isListPolicy()) {
                            Object childObject = ((ListContainerPolicy) mapping.getContainerPolicy()).get(xPathFragment.getIndexValue() - 1, mapping.getAttributeValueFromObject(object), null);
                            if (stringTokenizer.hasMoreElements()) {
                                ObjectBuilder childObjectBuilder = mapping.getReferenceDescriptor().getObjectBuilder();
                                return getValueByXPath(childObject, childObjectBuilder, stringTokenizer, namespaceResolver, returnType);
                            } else {
                                return (T) childObject;
                            }
                        }
                    }
                }
            }
        } else {
            if (stringTokenizer.hasMoreElements()) {
                Object childObject = mapping.getAttributeValueFromObject(object);
                ObjectBuilder childObjectBuilder = mapping.getReferenceDescriptor().getObjectBuilder();
                return getValueByXPath(childObject, childObjectBuilder, stringTokenizer, namespaceResolver, returnType);
            } else {
                return (T) mapping.getAttributeValueFromObject(object);
            }
        }
        xPath = xPath + nextToken + "String_Node_Str";
    }
    return null;
}

Output:
             XPathFragment xPathFragment = new XPathFragment(nextToken);
-            if (xPathFragment.getIndexValue() > 0) {
-                xmlField.setXPath(xPath + nextToken.substring(0, nextToken.indexOf('[')));
+            int xmlFieldIndex = xmlField.getXPathFragment().getIndexValue();
+            int fragmentIndex = xPathFragment.getIndexValue();
+            if (xmlFieldIndex > 0 || fragmentIndex > 0) {
+                int index = xmlFieldIndex - 1;
+                if (index < 0) {
+                    index = fragmentIndex - 1;
+                }
+                String strippedXPath = xmlField.getXPath();
+                while (strippedXPath.contains("String_Node_Str")) {
+                    int open = strippedXPath.lastIndexOf('[');
+                    int closed = strippedXPath.lastIndexOf(']');
+                    strippedXPath = strippedXPath.substring(0, open) + strippedXPath.substring(closed + 1);
+                }
+                xmlField.setXPath(strippedXPath);
                 xmlField.initialize();


Input:
public void receive(Event[] events) {
    EventPrinter.print(events);
    for (Event event : events) {
        switch(count.incrementAndGet()) {
            case 1:
                junit.framework.Assert.assertEquals(52.6f, event.getData(1));
                break;
            case 2:
                junit.framework.Assert.assertEquals(53.6f, event.getData(1));
                break;
            case 3:
                junit.framework.Assert.assertEquals(54.6f, event.getData(1));
                break;
            case 4:
                junit.framework.Assert.assertEquals(55.6f, event.getData(1));
                break;
            case 5:
                junit.framework.Assert.assertEquals(57.6f, event.getData(1));
                break;
            case 6:
                junit.framework.Assert.assertEquals(58.6f, event.getData(1));
                break;
            case 7:
                junit.framework.Assert.assertEquals(60.6f, event.getData(1));
                break;
            default:
                Assert.fail();
        }
    }
}

Output:
             case 1:
-                junit.framework.Assert.assertEquals(52.6f, event.getData(1));
+                Assert.assertEquals(52.6f, event.getData(1));
                 break;


Input:
private void onCql3CreateKeyspace() throws InvalidRequestException, UnavailableException, TimedOutException, SchemaDisagreementException, TException, UnsupportedEncodingException {
    String createKeyspace = CQLTranslator.CREATE_KEYSPACE;
    String placement_strategy = csmd.getPlacement_strategy(databaseName);
    String replication_conf = CQLTranslator.SIMPLE_REPLICATION;
    createKeyspace = createKeyspace.replace("String_Node_Str", Constants.ESCAPE_QUOTE + databaseName + Constants.ESCAPE_QUOTE);
    Schema schema = CassandraPropertyReader.csmd.getSchema(databaseName);
    if (schema != null && schema.getName() != null && schema.getName().equalsIgnoreCase(databaseName) && schema.getSchemaProperties() != null) {
        Properties schemaProperties = schema.getSchemaProperties();
        if (placement_strategy.equalsIgnoreCase(SimpleStrategy.class.getSimpleName()) || placement_strategy.equalsIgnoreCase(SimpleStrategy.class.getName())) {
            String replicationFactor = schemaProperties.getProperty(CassandraConstants.REPLICATION_FACTOR, CassandraConstants.DEFAULT_REPLICATION_FACTOR);
            replication_conf = replication_conf.replace("String_Node_Str", replicationFactor);
            createKeyspace = createKeyspace.replace("String_Node_Str", placement_strategy);
        } else if (placement_strategy.equalsIgnoreCase(NetworkTopologyStrategy.class.getSimpleName()) || placement_strategy.equalsIgnoreCase(NetworkTopologyStrategy.class.getName())) {
            if (schema.getDataCenters() != null && !schema.getDataCenters().isEmpty()) {
                StringBuilder builder = new StringBuilder();
                for (DataCenter dc : schema.getDataCenters()) {
                    builder.append(CQLTranslator.QUOTE_STR);
                    builder.append(dc.getName());
                    builder.append(CQLTranslator.QUOTE_STR);
                    builder.append("String_Node_Str");
                    builder.append(dc.getValue());
                    builder.append(CQLTranslator.COMMA_STR);
                }
                builder.delete(builder.lastIndexOf(CQLTranslator.COMMA_STR), builder.length());
                replication_conf = builder.toString();
            }
        }
        createKeyspace = createKeyspace.replace("String_Node_Str", placement_strategy);
        createKeyspace = createKeyspace.replace("String_Node_Str", replication_conf);
        boolean isDurableWrites = Boolean.parseBoolean(schemaProperties.getProperty(CassandraConstants.DURABLE_WRITES, "String_Node_Str"));
        createKeyspace = createKeyspace.replace("String_Node_Str", isDurableWrites + "String_Node_Str");
    } else {
        createKeyspace = createKeyspace.replace("String_Node_Str", placement_strategy);
        replication_conf = replication_conf.replace("String_Node_Str", CassandraConstants.DEFAULT_REPLICATION_FACTOR);
        createKeyspace = createKeyspace.replace("String_Node_Str", replication_conf);
        createKeyspace = createKeyspace.replace("String_Node_Str", "String_Node_Str");
    }
    cassandra_client.execute_cql3_query(ByteBuffer.wrap(createKeyspace.getBytes(Constants.CHARSET_UTF8)), Compression.NONE, ConsistencyLevel.ONE);
    KunderaCoreUtils.printQuery(createKeyspace, showQuery);
}

Output:
         createKeyspace = createKeyspace.replace("String_Node_Str", placement_strategy);
-        replication_conf = replication_conf.replace("String_Node_Str", CassandraConstants.DEFAULT_REPLICATION_FACTOR);
+        replication_conf = replication_conf.replace("String_Node_Str", (CharSequence) externalProperties.getOrDefault(CassandraConstants.REPLICATION_FACTOR, CassandraConstants.DEFAULT_REPLICATION_FACTOR));
         createKeyspace = createKeyspace.replace("String_Node_Str", replication_conf);


Input:
public static String getType(Record rec) {
    return getFirstValue(rec, SubmissionLookupProvider.TYPE);
}

Output:
 public static String getType(Record rec) {
-    return getFirstValue(rec, SubmissionLookupProvider.TYPE);
+    return SubmissionLookupUtils.getFirstValue(rec, SubmissionLookupProvider.TYPE);
 }


Input:
public void createsTargets(TargetConfiguration targetConfiguration) throws AxelorException {
    LocalDate oldDate = targetConfiguration.getFromDate();
    for (LocalDate date = oldDate; date.isBefore(targetConfiguration.getToDate()) || date.isEqual(targetConfiguration.getToDate()); date = this.getNextDate(targetConfiguration.getPeriodTypeSelect(), date)) {
        Target target2 = Target.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str", targetConfiguration.getUserInfo(), targetConfiguration.getTeam(), targetConfiguration.getPeriodTypeSelect(), targetConfiguration.getFromDate(), targetConfiguration.getToDate(), targetConfiguration.getCallEmittedNumber(), targetConfiguration.getMeetingNumber(), targetConfiguration.getOpportunityAmountEarned().doubleValue(), targetConfiguration.getOpportunityCreatedNumber(), targetConfiguration.getOpportunityCreatedWon()).fetchOne();
        if (target2 == null) {
            Target target = this.createTarget(targetConfiguration, oldDate, date.minusDays(1));
            this.update(target);
            oldDate = date;
        } else {
            throw new AxelorException(String.format("String_Node_Str", target2.getCode(), targetConfiguration.getCode()), IException.CONFIGURATION_ERROR);
        }
    }
}

Output:
 public void createsTargets(TargetConfiguration targetConfiguration) throws AxelorException {
-    LocalDate oldDate = targetConfiguration.getFromDate();
-    for (LocalDate date = oldDate; date.isBefore(targetConfiguration.getToDate()) || date.isEqual(targetConfiguration.getToDate()); date = this.getNextDate(targetConfiguration.getPeriodTypeSelect(), date)) {
-        Target target2 = Target.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str", targetConfiguration.getUserInfo(), targetConfiguration.getTeam(), targetConfiguration.getPeriodTypeSelect(), targetConfiguration.getFromDate(), targetConfiguration.getToDate(), targetConfiguration.getCallEmittedNumber(), targetConfiguration.getMeetingNumber(), targetConfiguration.getOpportunityAmountEarned().doubleValue(), targetConfiguration.getOpportunityCreatedNumber(), targetConfiguration.getOpportunityCreatedWon()).fetchOne();
-        if (target2 == null) {
-            Target target = this.createTarget(targetConfiguration, oldDate, date.minusDays(1));
-            this.update(target);
-            oldDate = date;
-        } else {
-            throw new AxelorException(String.format("String_Node_Str", target2.getCode(), targetConfiguration.getCode()), IException.CONFIGURATION_ERROR);
+    if (targetConfiguration.getPeriodTypeSelect() == ITarget.NONE) {
+        Target target = this.createTarget(targetConfiguration, targetConfiguration.getFromDate(), targetConfiguration.getToDate());
+        this.update(target);
+    } else {
+        LocalDate oldDate = targetConfiguration.getFromDate();
+        for (LocalDate date = oldDate; date.isBefore(targetConfiguration.getToDate()) || date.isEqual(targetConfiguration.getToDate()); date = this.getNextDate(targetConfiguration.getPeriodTypeSelect(), date)) {
+            Target target2 = Target.all().filter("String_Node_Str" + "String_Node_Str" + "String_Node_Str", targetConfiguration.getUserInfo(), targetConfiguration.getTeam(), targetConfiguration.getPeriodTypeSelect(), targetConfiguration.getFromDate(), targetConfiguration.getToDate(), targetConfiguration.getCallEmittedNumber(), targetConfiguration.getMeetingNumber(), targetConfiguration.getOpportunityAmountEarned().doubleValue(), targetConfiguration.getOpportunityCreatedNumber(), targetConfiguration.getOpportunityCreatedWon()).fetchOne();
+            if (target2 == null) {
+                Target target = this.createTarget(targetConfiguration, oldDate, date.minusDays(1));
+                this.update(target);
+                oldDate = date;
+            } else {
+                throw new AxelorException(String.format("String_Node_Str", target2.getCode(), targetConfiguration.getCode()), IException.CONFIGURATION_ERROR);
+            }
         }


Input:
public void chartMouseClicked(ChartMouseEvent event) {
    boolean flag = event.getTrigger().getButton() != MouseEvent.BUTTON3;
    chartComp.setDomainZoomable(flag);
    chartComp.setRangeZoomable(flag);
    final ExecutionLanguage currentEngine = analysis.getParameters().getExecutionLanguage();
    if (flag) {
        return;
    }
    ChartEntity chartEntity = event.getEntity();
    if (chartEntity != null && chartEntity instanceof CategoryItemEntity) {
        CategoryItemEntity cateEntity = (CategoryItemEntity) chartEntity;
        ICustomerDataset dataEntity = (ICustomerDataset) cateEntity.getDataset();
        final ChartDataEntity currentDataEntity = getCurrentChartDateEntity(cateEntity, dataEntity);
        if (currentDataEntity != null) {
            if (ExecutionLanguage.JAVA == currentEngine && 0 == analysis.getResults().getIndicToRowMap().size()) {
                return;
            }
            if (ExecutionLanguage.JAVA == currentEngine && !analysis.getParameters().isStoreData()) {
                return;
            }
            Menu menu = new Menu(chartComp.getShell(), SWT.POP_UP);
            chartComp.setMenu(menu);
            final Indicator currentIndicator = currentDataEntity.getIndicator();
            int createPatternFlag = 0;
            MenuItemEntity[] itemEntities = ChartTableMenuGenerator.generate(explorer, analysis, currentDataEntity);
            if (currentIndicator instanceof DatePatternFreqIndicator && null == analysis.getResults().getIndicToRowMap().get(currentIndicator).getFrequencyData()) {
                return;
            }
            for (final MenuItemEntity itemEntity : itemEntities) {
                MenuItem item = new MenuItem(menu, SWT.PUSH);
                item.setText(itemEntity.getLabel());
                item.setImage(itemEntity.getIcon());
                item.addSelectionListener(new SelectionAdapter() {
                    public void widgetSelected(SelectionEvent e) {
                        if (ExecutionLanguage.JAVA == currentEngine) {
                            try {
                                DrillDownEditorInput input = new DrillDownEditorInput(analysis, currentDataEntity, itemEntity);
                                if (input.computeColumnValueLength(input.filterAdaptDataList())) {
                                    CorePlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getActivePage().openEditor(input, "String_Node_Str");
                                } else {
                                    MessageDialog.openWarning(null, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
                                }
                            } catch (PartInitException e1) {
                                e1.printStackTrace();
                            }
                        } else {
                            Display.getDefault().asyncExec(new Runnable() {
                                public void run() {
                                    Connection tdDataProvider = SwitchHelpers.CONNECTION_SWITCH.doSwitch(analysis.getContext().getConnection());
                                    String query = itemEntity.getQuery();
                                    String editorName = currentIndicator.getName();
                                    SqlExplorerUtils.getDefault().runInDQViewer(tdDataProvider, query, editorName);
                                }
                            });
                        }
                    }
                });
                if ((currentIndicator instanceof PatternFreqIndicator || currentIndicator instanceof PatternLowFreqIndicator) && createPatternFlag == 0) {
                    MenuItem itemCreatePatt = new MenuItem(menu, SWT.PUSH);
                    itemCreatePatt.setText(DefaultMessagesImpl.getString("String_Node_Str"));
                    final PatternTransformer pattTransformer = new PatternTransformer(DbmsLanguageFactory.createDbmsLanguage(analysis));
                    itemCreatePatt.addSelectionListener(new SelectionAdapter() {
                        public void widgetSelected(SelectionEvent e) {
                            Display.getDefault().asyncExec(new Runnable() {
                                public void run() {
                                    ChartTableFactory.createPattern(analysis, itemEntity, pattTransformer);
                                }
                            });
                        }
                    });
                }
                createPatternFlag++;
            }
            ChartTableFactory.addJobGenerationMenu(menu, analysis, currentIndicator);
            menu.setVisible(true);
        }
    }
}

Output:
         if (currentDataEntity != null) {
-            if (ExecutionLanguage.JAVA == currentEngine && 0 == analysis.getResults().getIndicToRowMap().size()) {
+            final Indicator currentIndicator = currentDataEntity.getIndicator();
+            if (currentIndicator instanceof DatePatternFreqIndicator && null == analysis.getResults().getIndicToRowMap().get(currentIndicator).getFrequencyData()) {
                 return;


Input:
public static String getNormalizeParameterValue(INode node, IElementParameter ep) {
    String value = "String_Node_Str";
    value = ElementParameterParser.getValue(node, "String_Node_Str" + ep.getName() + "String_Node_Str");
    List<EParameterFieldType> escapeQuotation = Arrays.asList(EParameterFieldType.MEMO_JAVA);
    if (escapeQuotation.contains(ep.getFieldType())) {
        value = value.replaceAll("String_Node_Str", "String_Node_Str");
    }
    List<EParameterFieldType> needRemoveCRLFList = Arrays.asList(EParameterFieldType.MEMO, EParameterFieldType.MEMO_JAVA, EParameterFieldType.MEMO_SQL);
    if (needRemoveCRLFList.contains(ep.getFieldType())) {
        value = value.replaceAll("String_Node_Str", "String_Node_Str");
    }
    List<EParameterFieldType> needQuoteList = Arrays.asList(EParameterFieldType.CLOSED_LIST, EParameterFieldType.OPENED_LIST, EParameterFieldType.COMPONENT_LIST, EParameterFieldType.COLUMN_LIST, EParameterFieldType.PREV_COLUMN_LIST, EParameterFieldType.MEMO_JAVA);
    if (needQuoteList.contains(ep.getFieldType())) {
        value = "String_Node_Str" + value + "String_Node_Str";
    }
    if (EParameterFieldType.TABLE.equals(ep.getFieldType())) {
        value = ElementParameterParser.getObjectValue(node, "String_Node_Str" + ep.getName() + "String_Node_Str").toString();
        value = value.replace("String_Node_Str", "String_Node_Str");
        value = value.replace("String_Node_Str", "String_Node_Str");
        value = value.replace("String_Node_Str", "String_Node_Str");
        value = "String_Node_Str" + value + "String_Node_Str";
    }
    return value;
}

Output:
     List<EParameterFieldType> needQuoteList = Arrays.asList(EParameterFieldType.CLOSED_LIST, EParameterFieldType.OPENED_LIST, EParameterFieldType.COMPONENT_LIST, EParameterFieldType.COLUMN_LIST, EParameterFieldType.PREV_COLUMN_LIST, EParameterFieldType.MEMO_JAVA);
-    if (needQuoteList.contains(ep.getFieldType())) {
+    List<String> needQuoteListByName = Arrays.asList("String_Node_Str");
+    if (needQuoteList.contains(ep.getFieldType()) || needQuoteListByName.contains(ep.getName())) {
         value = "String_Node_Str" + value + "String_Node_Str";


Input:
public void stop() {
    listener = null;
    items = null;
}

Output:
     listener = null;
-    items = null;
+    items = Collections.emptyList();
 }


Input:
public static IllegalStateException throwUnhandledException(final Exception cause, final String msg, final Object... args) {
    final String formattedMessage = format(msg, args);
    throw new IllegalStateException(formattedMessage, cause);
}

Output:
     final String formattedMessage = format(msg, args);
-    throw new IllegalStateException(formattedMessage, cause);
+    throw new RuntimeException(formattedMessage, cause);
 }


Input:
static String getDelegateeImplementationName(Spliterator<?> spliterator) {
    try {
        if (spliterator == null || !"String_Node_Str".equals(spliterator.getClass().getName())) {
            return null;
        }
        return (String) GET_IMPL_NAME.invoke(spliterator);
    } catch (Exception e) {
        throw new Error(e);
    }
}

Output:
     try {
-        if (spliterator == null || !"String_Node_Str".equals(spliterator.getClass().getName())) {
+        if (spliterator == null || GET_IMPL_NAME == null || !"String_Node_Str".equals(spliterator.getClass().getName())) {
             return null;


Input:
public void introduce(OrcsSession session, Long branch, RelationNode source, RelationNode destination) throws OseeCoreException {
    ensureRelationsInitialized(session, source.getGraph(), source);
    Collection<? extends IRelationType> validRelationTypes = getValidRelationTypes(session, destination);
    RelationNodeAdjacencies sourceAdjacencies = source.getGraph().getAdjacencies(source);
    RelationNodeAdjacencies destinationAdjacencies = destination.getGraph().getAdjacencies(destination);
    if (sourceAdjacencies != null) {
        for (Relation sourceRel : sourceAdjacencies.getAll()) {
            if (validRelationTypes.contains(sourceRel.getRelationType())) {
                Relation destinationRel = findRelationByLocalId(destinationAdjacencies, sourceRel.getOrcsData().getLocalId());
                Relation introduceRelation = relationFactory.introduce(branch, sourceRel.getOrcsData());
                if (destinationRel == null) {
                    ArtifactReadable readable = doesRelatedArtifactExist(session, introduceRelation, destination, branch);
                    if (readable != null) {
                        RelationNode node = proxy.getInternalArtifact(readable);
                        relate(session, destination, sourceRel.getRelationType(), node);
                    }
                } else {
                    destinationRel.setOrcsData(introduceRelation.getOrcsData());
                    destinationRel.setDirty();
                }
            }
        }
    }
    String orderData = source.getOrderData();
    if (!orderData.isEmpty()) {
        destination.storeOrderData(OrderChange.Forced, source.getOrderData());
    }
}

Output:
                 Relation introduceRelation = relationFactory.introduce(branch, sourceRel.getOrcsData());
-                if (destinationRel == null) {
-                    ArtifactReadable readable = doesRelatedArtifactExist(session, introduceRelation, destination, branch);
-                    if (readable != null) {
-                        RelationNode node = proxy.getInternalArtifact(readable);
-                        relate(session, destination, sourceRel.getRelationType(), node);
-                    }
-                } else {
+                if (destinationRel != null) {
                     destinationRel.setOrcsData(introduceRelation.getOrcsData());


Input:
public void writeExpression(MethodWriter writer) {
    if (this.instance != null) {
        this.instance.writeExpression(writer);
    }
    this.field.writeGet(writer);
}

Output:
 public void writeExpression(MethodWriter writer) {
-    if (this.instance != null) {
-        this.instance.writeExpression(writer);
-    }
-    this.field.writeGet(writer);
+    this.field.writeGet(writer, this.instance);
 }


Input:
public boolean hasEdge(Statement src, Statement dst) {
    addPDGStatementNodes(src.getNode());
    addPDGStatementNodes(dst.getNode());
    switch(src.getKind()) {
        case NORMAL:
            if (cOptions.equals(ControlDependenceOptions.NONE)) {
                return getPDG(src.getNode()).hasEdge(src, dst);
            } else {
                NormalStatement ns = (NormalStatement) src;
                if (dst instanceof MethodEntryStatement) {
                    if (ns.getInstruction() instanceof SSAAbstractInvokeInstruction) {
                        SSAAbstractInvokeInstruction call = (SSAAbstractInvokeInstruction) ns.getInstruction();
                        return cg.getPossibleTargets(src.getNode(), call.getCallSite()).contains(dst.getNode());
                    } else {
                        return false;
                    }
                } else {
                    return getPDG(src.getNode()).hasEdge(src, dst);
                }
            }
        case PHI:
        case PI:
        case EXC_RET_CALLER:
        case NORMAL_RET_CALLER:
        case PARAM_CALLEE:
        case HEAP_PARAM_CALLEE:
        case HEAP_RET_CALLER:
        case METHOD_ENTRY:
            return getPDG(src.getNode()).hasEdge(src, dst);
        case EXC_RET_CALLEE:
            {
                if (dOptions.equals(DataDependenceOptions.NONE)) {
                    return false;
                }
                if (dst.getKind().equals(Kind.EXC_RET_CALLER)) {
                    ExceptionalReturnCaller r = (ExceptionalReturnCaller) dst;
                    return cg.getPossibleTargets(r.getNode(), r.getInstruction().getCallSite()).contains(src.getNode());
                } else {
                    return false;
                }
            }
        case NORMAL_RET_CALLEE:
            {
                if (dOptions.equals(DataDependenceOptions.NONE)) {
                    return false;
                }
                if (dst.getKind().equals(Kind.NORMAL_RET_CALLER)) {
                    NormalReturnCaller r = (NormalReturnCaller) dst;
                    return cg.getPossibleTargets(r.getNode(), r.getInstruction().getCallSite()).contains(src.getNode());
                } else {
                    return false;
                }
            }
        case HEAP_RET_CALLEE:
            {
                if (dOptions.equals(DataDependenceOptions.NONE)) {
                    return false;
                }
                if (dst.getKind().equals(Kind.HEAP_RET_CALLER)) {
                    HeapStatement.HeapReturnCaller r = (HeapStatement.HeapReturnCaller) dst;
                    HeapStatement h = (HeapStatement) src;
                    return h.getLocation().equals(r.getLocation()) && cg.getPossibleTargets(r.getNode(), r.getCall().getCallSite()).contains(src.getNode());
                } else {
                    return false;
                }
            }
        case PARAM_CALLER:
            {
                if (dOptions.equals(DataDependenceOptions.NONE)) {
                    return false;
                }
                if (dst.getKind().equals(Kind.PARAM_CALLEE)) {
                    ParamCallee callee = (ParamCallee) dst;
                    ParamCaller caller = (ParamCaller) src;
                    return caller.getValueNumber() == callee.getValueNumber() && cg.getPossibleTargets(caller.getNode(), caller.getInstruction().getCallSite()).contains(callee.getNode());
                } else {
                    return false;
                }
            }
        case HEAP_PARAM_CALLER:
            if (dOptions.equals(DataDependenceOptions.NONE)) {
                return false;
            }
            if (dst.getKind().equals(Kind.HEAP_PARAM_CALLEE)) {
                HeapStatement.HeapParamCallee callee = (HeapStatement.HeapParamCallee) dst;
                HeapStatement.HeapParamCaller caller = (HeapStatement.HeapParamCaller) src;
                return caller.getLocation().equals(callee.getLocation()) && cg.getPossibleTargets(caller.getNode(), caller.getCall().getCallSite()).contains(callee.getNode());
            } else {
                return false;
            }
        default:
            Assertions.UNREACHABLE(src.getKind());
            return false;
    }
}

Output:
                     ParamCaller caller = (ParamCaller) src;
-                    return caller.getValueNumber() == callee.getValueNumber() && cg.getPossibleTargets(caller.getNode(), caller.getInstruction().getCallSite()).contains(callee.getNode());
+                    SSAAbstractInvokeInstruction call = caller.getInstruction();
+                    final CGNode calleeNode = callee.getNode();
+                    if (!cg.getPossibleTargets(caller.getNode(), call.getCallSite()).contains(calleeNode)) {
+                        return false;
+                    }
+                    if (dOptions.isTerminateAtCast() && call.isDispatch() && caller.getValueNumber() == call.getReceiver()) {
+                        return false;
+                    }
+                    if (dOptions.isTerminateAtCast() && isUninformativeForReflection(calleeNode)) {
+                        return false;
+                    }
+                    for (int i = 0; i < calleeNode.getMethod().getNumberOfParameters(); i++) {
+                        if (call.getUse(i) == caller.getValueNumber()) {
+                            if (callee.getValueNumber() == i + 1) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
                 } else {


Input:
private boolean shouldGetChildren(Object item) {
    return item instanceof RequirementResourceImpl || item instanceof Repository || item instanceof Category;
}

Output:
 private boolean shouldGetChildren(Object item) {
-    return item instanceof RequirementResourceImpl || item instanceof Repository || item instanceof Category;
+    return item instanceof Resource || item instanceof Repository || item instanceof Category;
 }


Input:
public Map<String, DataSet> getLoadedDataSets(NodeRef filePlan) {
    ParameterCheck.mandatory("String_Node_Str", filePlan);
    Map<String, DataSet> availableDataSets = new HashMap<String, DataSet>(getDataSets());
    Serializable dataSetIds = nodeService.getProperty(filePlan, PROP_LOADED_DATA_SET_IDS);
    if (dataSetIds != null) {
        ArrayList<String> loadedDataSetIds = (ArrayList<String>) dataSetIds;
        for (Map.Entry<String, DataSet> entry : availableDataSets.entrySet()) {
            String key = entry.getKey();
            if (!loadedDataSetIds.contains(key)) {
                availableDataSets.remove(key);
            }
        }
        return availableDataSets;
    }
    return new HashMap<String, DataSet>();
}

Output:
         ArrayList<String> loadedDataSetIds = (ArrayList<String>) dataSetIds;
-        for (Map.Entry<String, DataSet> entry : availableDataSets.entrySet()) {
+        Iterator<Map.Entry<String, DataSet>> iterator = availableDataSets.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Entry<String, DataSet> entry = iterator.next();
             String key = entry.getKey();


Input:
public static CodeBlock.Builder getContentValuesStatement(String elementName, String fullElementName, String columnName, TypeName elementTypeName, boolean isModelContainerAdapter, BaseColumnAccess columnAccess, String variableNameString) {
    String statement = columnAccess.getColumnAccessString(elementTypeName, elementName, fullElementName, variableNameString, isModelContainerAdapter);
    CodeBlock.Builder codeBuilder = CodeBlock.builder();
    String finalAccessStatement = statement;
    boolean isBlobRaw = false;
    if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
        finalAccessStatement = (isModelContainerAdapter ? (variableNameString + elementName) : ("String_Node_Str" + fullElementName));
        TypeName typeName;
        if (columnAccess instanceof TypeConverterAccess) {
            typeName = ((TypeConverterAccess) columnAccess).typeConverterDefinition.getDbTypeName();
            isBlobRaw = (typeName.equals(ClassName.get(Blob.class)));
        } else {
            if (columnAccess instanceof EnumColumnAccess) {
                typeName = ClassName.get(String.class);
            } else if (columnAccess instanceof BlobColumnAccess) {
                typeName = ArrayTypeName.of(TypeName.BYTE);
            } else {
                typeName = elementTypeName;
            }
            if (!isModelContainerAdapter) {
                String shortAccess = ((WrapperColumnAccess) columnAccess).existingColumnAccess.getShortAccessString(elementTypeName, elementName, isModelContainerAdapter);
                codeBuilder.addStatement("String_Node_Str", typeName, finalAccessStatement, shortAccess, statement);
            } else {
                codeBuilder.addStatement("String_Node_Str", typeName, finalAccessStatement, statement);
            }
        }
    }
    String putAccess = finalAccessStatement;
    if (isBlobRaw) {
        putAccess = finalAccessStatement + "String_Node_Str";
    }
    if (!elementTypeName.isPrimitive()) {
        if (!isModelContainerAdapter && (columnAccess instanceof EnumColumnAccess || columnAccess instanceof BlobColumnAccess)) {
            codeBuilder.beginControlFlow("String_Node_Str", variableNameString + "String_Node_Str" + elementName, finalAccessStatement);
        } else {
            codeBuilder.beginControlFlow("String_Node_Str", putAccess);
        }
    }
    codeBuilder.addStatement("String_Node_Str", BindToContentValuesMethod.PARAM_CONTENT_VALUES, QueryBuilder.quote(columnName), putAccess);
    if (!elementTypeName.isPrimitive()) {
        codeBuilder.nextControlFlow("String_Node_Str").addStatement("String_Node_Str", BindToContentValuesMethod.PARAM_CONTENT_VALUES, QueryBuilder.quote(columnName)).endControlFlow();
    }
    return codeBuilder;
}

Output:
     boolean isBlobRaw = false;
-    if (columnAccess instanceof TypeConverterAccess || isModelContainerAdapter) {
+    TypeName finalTypeName = elementTypeName;
+    if (columnAccess instanceof WrapperColumnAccess || isModelContainerAdapter) {
         finalAccessStatement = (isModelContainerAdapter ? (variableNameString + elementName) : ("String_Node_Str" + fullElementName));


Input:
public void timeLinguist(int numRuns, int numFrames, int maxBeam) {
    Random random = new Random(1000);
    Timer frameTimer = Timer.getTimer("String_Node_Str");
    Timer totalTimer = Timer.getTimer("String_Node_Str");
    System.out.println("String_Node_Str" + numRuns + "String_Node_Str" + numFrames + "String_Node_Str" + maxBeam);
    totalTimer.start();
    for (int runs = 0; runs < numRuns; runs++) {
        int level = 0;
        List activeList = new ArrayList();
        activeList.add(linguist.getSearchGraph().getInitialState());
        linguist.startRecognition();
        for (int i = 0; i < numFrames; i++) {
            List oldList = activeList;
            activeList = new ArrayList(maxBeam * 10);
            frameTimer.start();
            for (int j = 0; j < oldList.size(); j++) {
                SearchState nextStates = (SearchState) oldList.get(j);
                expandState(level, activeList, nextStates);
            }
            frameTimer.stop();
            Collections.shuffle(activeList, random);
            if (activeList.size() > maxBeam) {
                activeList = activeList.subList(0, maxBeam);
            }
        }
        linguist.stopRecognition();
        frameTimer.dump();
    }
    totalTimer.stop();
    System.out.println("String_Node_Str" + maxSuccessors);
    System.out.println("String_Node_Str" + totalStates);
    System.out.println("String_Node_Str" + totalEmittingStates);
    System.out.println("String_Node_Str" + totalNonEmittingStates);
    System.out.println("String_Node_Str" + totalFinalStates);
    Timer.dumpAll();
}

Output:
     Random random = new Random(1000);
-    Timer frameTimer = Timer.getTimer("String_Node_Str");
-    Timer totalTimer = Timer.getTimer("String_Node_Str");
+    Timer frameTimer = TimerPool.getTimer("String_Node_Str");
+    Timer totalTimer = TimerPool.getTimer("String_Node_Str");
     System.out.println("String_Node_Str" + numRuns + "String_Node_Str" + numFrames + "String_Node_Str" + maxBeam);


Input:
private synchronized AdminEndpointDecider getEpd() {
    if (aed == null) {
        aed = new AdminEndpointDecider(getConfig(), Logging.logger);
    }
    return aed;
}

Output:
     if (aed == null) {
-        aed = new AdminEndpointDecider(getConfig(), Logging.logger);
+        aed = new AdminEndpointDecider(getConfig());
     }


Input:
public static ClassInfo readClassInfoFromClassfileHeader(final String relativePath, final InputStream inputStream, final HashMap<String, HashMap<String, StaticFinalFieldMatchProcessor>> classNameToStaticFieldnameToMatchProcessor, final ArrayList<String> whitelistClassRefPrefix, final ArrayList<String> blacklistClassRefPrefix) {
    try (final DataInputStream inp = new DataInputStream(new BufferedInputStream(inputStream, 8192))) {
        if (inp.readInt() != 0xCAFEBABE) {
            if (FastClasspathScanner.verbose) {
                Log.log("String_Node_Str" + relativePath);
            }
            return null;
        }
        inp.readUnsignedShort();
        inp.readUnsignedShort();
        final int cpCount = inp.readUnsignedShort();
        final Object[] constantPool = new Object[cpCount];
        final int[] indirectStringRef = new int[cpCount];
        Arrays.fill(indirectStringRef, -1);
        for (int i = 1; i < cpCount; ++i) {
            final int tag = inp.readUnsignedByte();
            switch(tag) {
                case 1:
                    constantPool[i] = inp.readUTF();
                    break;
                case 3:
                    constantPool[i] = inp.readInt();
                    break;
                case 4:
                    constantPool[i] = inp.readFloat();
                    break;
                case 5:
                    constantPool[i] = inp.readLong();
                    i++;
                    break;
                case 6:
                    constantPool[i] = inp.readDouble();
                    i++;
                    break;
                case 7:
                case 8:
                    indirectStringRef[i] = inp.readUnsignedShort();
                    break;
                case 9:
                case 10:
                case 11:
                case 12:
                    inp.skipBytes(4);
                    break;
                case 15:
                    inp.skipBytes(3);
                    break;
                case 16:
                    inp.skipBytes(2);
                    break;
                case 18:
                    inp.skipBytes(4);
                    break;
                default:
                    break;
            }
        }
        for (int i = 1; i < cpCount; i++) {
            if (indirectStringRef[i] >= 0) {
                constantPool[i] = constantPool[indirectStringRef[i]];
            }
        }
        final int flags = inp.readUnsignedShort();
        final boolean isInterface = (flags & 0x0200) != 0;
        final boolean isAnnotation = (flags & 0x2000) != 0;
        final String classNamePath = readRefdString(inp, constantPool);
        final String className = classNamePath.replace('/', '.');
        String superclassName = readRefdString(inp, constantPool);
        if (superclassName != null) {
            superclassName = superclassName.replace('/', '.');
        }
        if (className.equals("String_Node_Str")) {
            return null;
        }
        if (!className.equals(relativePath.substring(0, relativePath.length() - 6).replace('/', '.'))) {
            if (FastClasspathScanner.verbose) {
                Log.log("String_Node_Str" + className + "String_Node_Str" + relativePath + "String_Node_Str");
            }
            return null;
        }
        final ClassInfo classInfo = new ClassInfo(className, isInterface && !isAnnotation, isAnnotation, superclassName);
        final int interfaceCount = inp.readUnsignedShort();
        classInfo.interfaceNames = interfaceCount > 0 ? new ArrayList<String>(interfaceCount) : null;
        for (int i = 0; i < interfaceCount; i++) {
            classInfo.interfaceNames.add(readRefdString(inp, constantPool).replace('/', '.'));
        }
        final HashMap<String, StaticFinalFieldMatchProcessor> staticFieldnameToMatchProcessor = classNameToStaticFieldnameToMatchProcessor.get(classInfo.className);
        HashSet<String> whitelistedFieldTypes = null;
        final int fieldCount = inp.readUnsignedShort();
        for (int i = 0; i < fieldCount; i++) {
            final int accessFlags = inp.readUnsignedShort();
            final boolean isStaticFinal = (accessFlags & 0x0018) == 0x0018;
            final String fieldName = readRefdString(inp, constantPool);
            final StaticFinalFieldMatchProcessor staticFinalFieldMatchProcessor = staticFieldnameToMatchProcessor != null ? staticFieldnameToMatchProcessor.get(fieldName) : null;
            final String fieldTypeDescriptor = readRefdString(inp, constantPool);
            final int attributesCount = inp.readUnsignedShort();
            whitelistedFieldTypes = findWhitelistedTypeDescriptorParts(fieldTypeDescriptor, whitelistClassRefPrefix, blacklistClassRefPrefix, whitelistedFieldTypes);
            if (!isStaticFinal && staticFinalFieldMatchProcessor != null) {
                System.err.println(StaticFinalFieldMatchProcessor.class.getSimpleName() + "String_Node_Str" + classInfo.className + "String_Node_Str" + fieldName + "String_Node_Str");
            }
            boolean foundConstantValue = false;
            for (int j = 0; j < attributesCount; j++) {
                final String attributeName = readRefdString(inp, constantPool);
                final int attributeLength = inp.readInt();
                if (attributeName.equals("String_Node_Str") && isStaticFinal && staticFinalFieldMatchProcessor != null) {
                    Object constValue = constantPool[inp.readUnsignedShort()];
                    switch(fieldTypeDescriptor) {
                        case "String_Node_Str":
                            constValue = ((Integer) constValue).byteValue();
                            break;
                        case "String_Node_Str":
                            constValue = (char) ((Integer) constValue).intValue();
                            break;
                        case "String_Node_Str":
                            constValue = ((Integer) constValue).shortValue();
                            break;
                        case "String_Node_Str":
                            constValue = ((Integer) constValue).intValue() != 0;
                            break;
                        case "String_Node_Str":
                        case "String_Node_Str":
                        case "String_Node_Str":
                        case "String_Node_Str":
                        case "String_Node_Str":
                            break;
                        default:
                            break;
                    }
                    if (FastClasspathScanner.verbose) {
                        Log.log("String_Node_Str" + classInfo.className + "String_Node_Str" + fieldName + "String_Node_Str" + constValue);
                    }
                    staticFinalFieldMatchProcessor.processMatch(classInfo.className, fieldName, constValue);
                    foundConstantValue = true;
                } else if (attributeName.equals("String_Node_Str")) {
                    final String fieldTypeSignature = readRefdString(inp, constantPool);
                    whitelistedFieldTypes = findWhitelistedTypeDescriptorParts(fieldTypeSignature, whitelistClassRefPrefix, blacklistClassRefPrefix, whitelistedFieldTypes);
                } else {
                    inp.skipBytes(attributeLength);
                }
                if (!foundConstantValue && isStaticFinal && staticFinalFieldMatchProcessor != null) {
                    System.err.println(StaticFinalFieldMatchProcessor.class.getSimpleName() + "String_Node_Str" + classInfo.className + "String_Node_Str" + fieldName + "String_Node_Str" + "String_Node_Str");
                }
            }
        }
        classInfo.whitelistedFieldTypes = whitelistedFieldTypes;
        final int methodCount = inp.readUnsignedShort();
        for (int i = 0; i < methodCount; i++) {
            inp.skipBytes(6);
            final int attributesCount = inp.readUnsignedShort();
            for (int j = 0; j < attributesCount; j++) {
                inp.skipBytes(2);
                final int attributeLength = inp.readInt();
                inp.skipBytes(attributeLength);
            }
        }
        classInfo.annotationNames = null;
        final int attributesCount = inp.readUnsignedShort();
        for (int i = 0; i < attributesCount; i++) {
            final String attributeName = readRefdString(inp, constantPool);
            final int attributeLength = inp.readInt();
            if ("String_Node_Str".equals(attributeName)) {
                final int annotationCount = inp.readUnsignedShort();
                for (int m = 0; m < annotationCount; m++) {
                    final String annotationName = readAnnotation(inp, constantPool);
                    if (!annotationName.startsWith("String_Node_Str")) {
                        if (classInfo.annotationNames == null) {
                            classInfo.annotationNames = new ArrayList<>();
                        }
                        classInfo.annotationNames.add(annotationName);
                    }
                }
            } else {
                inp.skipBytes(attributeLength);
            }
        }
        return classInfo;
    } catch (final IOException e) {
        Log.log("String_Node_Str" + relativePath + "String_Node_Str" + e.getMessage());
        return null;
    }
}

Output:
             final int attributesCount = inp.readUnsignedShort();
-            whitelistedFieldTypes = findWhitelistedTypeDescriptorParts(fieldTypeDescriptor, whitelistClassRefPrefix, blacklistClassRefPrefix, whitelistedFieldTypes);
+            whitelistedFieldTypes = findWhitelistedTypeDescriptorParts(fieldTypeDescriptor, scanSpec, whitelistedFieldTypes);
             if (!isStaticFinal && staticFinalFieldMatchProcessor != null) {


Input:
private void testFactTableSaveAndLoad3(IDocumentManager documentManager) throws IOException, BirtException, DataException {
    Dimension[] dimensions = new Dimension[3];
    String[] levelNames = new String[3];
    levelNames[0] = "String_Node_Str";
    levelNames[1] = "String_Node_Str";
    levelNames[2] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, FactTable2.L1Col);
    iterator.setLevelMember(1, FactTable2.L2Col);
    iterator.setLevelMember(2, FactTable2.L3Col);
    ILevelDefn[] levelDefs = new ILevelDefn[3];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    levelDefs[1] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    levelDefs[2] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[0].length(), FactTable2.L1Col.length);
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(FactTable2.L1Col));
    levelDefs = new ILevelDefn[1];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[1].length(), 3);
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, FactTable2.L3Col);
    levelDefs = new ILevelDefn[1];
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[2] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false);
    hierarchy = dimensions[2].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    assertEquals(dimensions[2].length(), 12);
    FactTable2 factTable2 = new FactTable2();
    String[] measureColumnName = new String[2];
    measureColumnName[0] = "String_Node_Str";
    measureColumnName[1] = "String_Node_Str";
    FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), factTable2, dimensions, measureColumnName, new StopSign());
    factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());
    String[] dimensionNames = new String[3];
    dimensionNames[0] = "String_Node_Str";
    dimensionNames[1] = "String_Node_Str";
    dimensionNames[2] = "String_Node_Str";
    ILevel[] level = dimensions[1].getHierarchy().getLevels();
    ISelection[][] filter = new ISelection[1][1];
    filter[0][0] = SelectionFactory.createRangeSelection(new Object[] { new Integer(1) }, new Object[] { new Integer(3) }, true, false);
    Level[] findLevel = new Level[1];
    findLevel[0] = (Level) level[0];
    IDiskArray[] positionForFilter = null;
    positionForFilter = new IDiskArray[2];
    IDiskArray positionArray = dimensions[1].find(findLevel, filter);
    positionForFilter[0] = positionArray;
    assertEquals(positionArray.size(), 2);
    DimensionResultIterator[] dimesionResultSets = new DimensionResultIterator[2];
    dimesionResultSets[0] = new DimensionResultIterator(dimensions[1], positionArray);
    positionArray = dimensions[2].findAll();
    dimesionResultSets[1] = new DimensionResultIterator(dimensions[2], positionArray);
    String[] dimensionNamesForFilter = new String[2];
    dimensionNamesForFilter[0] = "String_Node_Str";
    dimensionNamesForFilter[1] = "String_Node_Str";
    positionForFilter[1] = positionArray;
    FactTableRowIterator facttableRowIterator = new FactTableRowIterator(factTable, dimensionNamesForFilter, positionForFilter, new StopSign());
    assertTrue(facttableRowIterator != null);
    AggregationDefinition[] aggregations = new AggregationDefinition[2];
    int[] sortType = new int[1];
    sortType[0] = IDimensionSortDefn.SORT_ASC;
    DimLevel[] levelsForFilter = new DimLevel[] { dimLevel21 };
    AggregationFunctionDefinition[] funcitons = new AggregationFunctionDefinition[1];
    funcitons[0] = new AggregationFunctionDefinition("String_Node_Str", IBuildInAggregation.TOTAL_SUM_FUNC);
    aggregations[0] = new AggregationDefinition(levelsForFilter, sortType, funcitons);
    sortType = new int[2];
    sortType[0] = IDimensionSortDefn.SORT_ASC;
    sortType[1] = IDimensionSortDefn.SORT_ASC;
    levelsForFilter = new DimLevel[] { dimLevel31 };
    aggregations[1] = new AggregationDefinition(levelsForFilter, sortType, funcitons);
    AggregationExecutor aggregationCalculatorExecutor = new AggregationExecutor(dimesionResultSets, facttableRowIterator, aggregations);
    IAggregationResultSet[] resultSet = aggregationCalculatorExecutor.execute(new StopSign());
    assertEquals(resultSet[0].length(), 2);
    assertEquals(resultSet[0].getAggregationDataType(0), DataType.DOUBLE_TYPE);
    assertEquals(resultSet[0].getLevelIndex(dimLevel21), 0);
    assertEquals(resultSet[0].getLevelKeyDataType(dimLevel21, "String_Node_Str"), DataType.INTEGER_TYPE);
    resultSet[0].seek(0);
    assertEquals(resultSet[0].getLevelKeyValue(0)[0], new Integer(1));
    assertEquals(resultSet[0].getAggregationValue(0), new Double(6));
    resultSet[0].seek(1);
    assertEquals(resultSet[0].getLevelKeyValue(0)[0], new Integer(2));
    assertEquals(resultSet[0].getAggregationValue(0), new Double(22));
    assertEquals(resultSet[1].length(), 8);
    assertEquals(resultSet[1].getAggregationDataType(0), DataType.DOUBLE_TYPE);
    assertEquals(resultSet[1].getLevelIndex(dimLevel31), 0);
    assertEquals(resultSet[1].getLevelKeyDataType(dimLevel31, "String_Node_Str"), DataType.INTEGER_TYPE);
    resultSet[1].seek(0);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(1));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(0));
    resultSet[1].seek(1);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(2));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(1));
    resultSet[1].seek(2);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(3));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(2));
    resultSet[1].seek(3);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(4));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(3));
    resultSet[1].seek(4);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(5));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(4));
    resultSet[1].seek(5);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(6));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(5));
    resultSet[1].seek(6);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(7));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(6));
    resultSet[1].seek(7);
    assertEquals(resultSet[1].getLevelKeyValue(0)[0], new Integer(8));
    assertEquals(resultSet[1].getAggregationValue(0), new Double(7));
}

Output:
     FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
-    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), factTable2, dimensions, measureColumnName, new StopSign());
+    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTable2, dimensions, measureColumnName, new StopSign());
     factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());


Input:
public Object createMapDBColumnSetDataSet(String[] columnHeader, ColumnSetDBMap mapDB, Long size, Indicator currIndicator, int pageSize) {
    if (getSqlexplorerService() != null) {
        return getSqlexplorerService().createMapDBColumnSetDataSet(columnHeader, mapDB, size, currIndicator, pageSize);
    }
    return null;
}

Output:
     if (getSqlexplorerService() != null) {
-        return getSqlexplorerService().createMapDBColumnSetDataSet(columnHeader, mapDB, size, currIndicator, pageSize);
+        return getSqlexplorerService().createMapDBColumnSetDataSet(columnHeader, mapDB, size, dataValidation, pageSize);
     }


Input:
public void execute() {
    node.setPropertyValue(propName, newPropValue);
    if ((EParameterName.SCHEMA + "String_Node_Str" + EParameterName.REPOSITORY_SCHEMA_TYPE).equals(propName)) {
        IElementParameter elementParameter = node.getElementParameter(propName);
        if (elementParameter != null) {
            IElementParameter schemaTypeParam = elementParameter.getParentParameter().getChildParameters().get(EParameterName.SCHEMA_TYPE.getName());
            if (schemaTypeParam != null) {
                if (newPropValue != null && !"String_Node_Str".equals(newPropValue)) {
                    schemaTypeParam.setValue(EmfComponent.REPOSITORY);
                } else {
                    schemaTypeParam.setValue(EmfComponent.BUILTIN);
                }
            }
        }
    }
    if (node.isExternalNode() && !node.isELTComponent()) {
        for (IElementParameter parameter : node.getElementParameters()) {
            if (parameter.getFieldType() == EParameterFieldType.TABLE) {
                if (!node.getMetadataList().isEmpty() && !node.getMetadataList().get(0).sameMetadataAs(newOutputMetadata)) {
                    parameter.setValue(new ArrayList<Map<String, Object>>());
                }
            }
        }
    }
    if (node.isELTComponent()) {
        IElementParameter schemaParam = node.getElementParameter("String_Node_Str");
        if (schemaParam != null && schemaParam.getValue() != null && newPropValue != null && connection != null && connection.isContextMode() && ContextParameterUtils.isContainContextParam(schemaParam.getValue().toString())) {
            ConnectionItem connectionItem = MetadataToolHelper.getConnectionItemFromRepository(newPropValue.toString());
            ConnectionContextHelper.addContextForNodeParameter(node, connectionItem, false);
        }
    }
    boolean isXstreamCdcTypeMode = false;
    if (connection != null && connection instanceof DatabaseConnection) {
        String cdcTypeMode = ((DatabaseConnection) connection).getCdcTypeMode();
        if (CDCTypeMode.XSTREAM_MODE == CDCTypeMode.indexOf(cdcTypeMode)) {
            isXstreamCdcTypeMode = true;
        }
    }
    node.getElementParameter(EParameterName.UPDATE_COMPONENTS.getName()).setValue(true);
    String componentName = node.getComponent().getName();
    if (newOutputMetadata != null) {
        Map<String, String> addMap = newOutputMetadata.getAdditionalProperties();
        if (addMap.get(TaggedValueHelper.SYSTEMTABLENAME) != null && componentName.equals("String_Node_Str")) {
            setDBTableFieldValue(node, addMap.get(TaggedValueHelper.SYSTEMTABLENAME), oldOutputMetadata.getTableName());
        } else if (isXstreamCdcTypeMode) {
            IElementParameter elementParameter = node.getElementParameter(propName);
            if (elementParameter != null) {
                if (oracleCdcComponent[0].equals(componentName) || oracleCdcComponent[1].equals(componentName)) {
                    IElementParameter schemaTypeParam = elementParameter.getParentParameter().getChildParameters().get(EParameterName.SCHEMA_TYPE.getName());
                    IElementParameter schemaParam = node.getElementParameterFromField(EParameterFieldType.SCHEMA_TYPE);
                    if (schemaTypeParam != null) {
                        schemaTypeParam.setValue(EmfComponent.BUILTIN);
                        if (schemaParam != null && schemaParam.getValue() != null && schemaParam.getValue() instanceof IMetadataTable) {
                            newOutputMetadata.setListColumns((((IMetadataTable) schemaParam.getValue()).clone(true)).getListColumns());
                        }
                        if (oracleCdcComponent[1].equals(componentName)) {
                            newOutputMetadata.setListColumns(new ArrayList<IMetadataColumn>());
                        }
                    }
                }
            }
            setDBTableFieldValue(node, newOutputMetadata.getTableName(), oldOutputMetadata.getTableName());
        } else {
            setDBTableFieldValue(node, newOutputMetadata.getTableName(), oldOutputMetadata.getTableName());
        }
        IElementParameter parameter = node.getElementParameter("String_Node_Str");
        if (parameter != null) {
            setSAPFunctionName(node, parameter.getValue() == null ? null : (String) parameter.getValue());
        }
        if (newPropValue instanceof String) {
            if (orginalTable != null && orginalTable instanceof SAPBWTable) {
                String innerIOType = ((SAPBWTable) orginalTable).getInnerIOType();
                String sourceSysName = ((SAPBWTable) orginalTable).getSourceSystemName();
                IElementParameter schemaTypeParam = node.getElementParameterFromField(EParameterFieldType.SCHEMA_TYPE);
                IMetadataTable metadataTable = null;
                if (schemaTypeParam != null) {
                    metadataTable = node.getMetadataFromConnector(schemaTypeParam.getContext());
                }
                if (metadataTable != null) {
                    if (innerIOType != null) {
                        IElementParameter param = node.getElementParameter("String_Node_Str");
                        if (param != null) {
                            param.setValue(innerIOType);
                            metadataTable.getAdditionalProperties().put(SAPBWTableHelper.SAP_INFOOBJECT_INNER_TYPE, innerIOType);
                        }
                    }
                    if (sourceSysName != null) {
                        IElementParameter param = node.getElementParameter("String_Node_Str");
                        if (param != null) {
                            param.setValue(TalendTextUtils.addQuotes(sourceSysName));
                            metadataTable.getAdditionalProperties().put(SAPBWTableHelper.SAP_DATASOURCE_SOURCESYSNAME, sourceSysName);
                        }
                    }
                }
            }
        }
        setTableRelevantParameterValues();
    }
    super.setConnection(connection);
    super.execute();
    String propertyType = (String) node.getPropertyValue(EParameterName.PROPERTY_TYPE.getName());
    if (propertyType != null) {
        if (propertyType.equals(EmfComponent.REPOSITORY)) {
            String propertyValue = (String) node.getPropertyValue(EParameterName.REPOSITORY_PROPERTY_TYPE.getName());
            IRepositoryViewObject lastVersion = UpdateRepositoryUtils.getRepositoryObjectById(propertyValue);
            if (lastVersion == null) {
                return;
            }
            Item item = lastVersion.getProperty().getItem();
            if (item instanceof ConnectionItem) {
                List<? extends IElementParameter> elementParameters = new ArrayList(node.getElementParameters());
                for (IElementParameter param : elementParameters) {
                    if (param.getRepositoryValue() != null && !param.getRepositoryValue().equals("String_Node_Str")) {
                        boolean isCustomSfConn = false;
                        if (item instanceof SalesforceSchemaConnectionItem) {
                            SalesforceSchemaConnection sfConn = (SalesforceSchemaConnection) ((SalesforceSchemaConnectionItem) item).getConnection();
                            isCustomSfConn = sfConn.isUseCustomModuleName();
                        }
                        if (param.getRepositoryValue().equals("String_Node_Str") || (param.getRepositoryValue().equals("String_Node_Str") && item instanceof SalesforceSchemaConnectionItem && !isCustomSfConn)) {
                            continue;
                        }
                        if (param.getFieldType().equals(EParameterFieldType.TABLE) && param.getRepositoryValue().equals("String_Node_Str")) {
                            List<Map<String, Object>> table = (List<Map<String, Object>>) node.getPropertyValue(param.getName());
                            IMetadataTable metaTable = node.getMetadataList().get(0);
                            RepositoryToComponentProperty.getTableXmlFileValue(((ConnectionItem) item).getConnection(), "String_Node_Str", param, table, newOutputMetadata);
                            param.setRepositoryValueUsed(true);
                        } else {
                            if (connection != null && (xmlComponent[0].equals(componentName) || xmlComponent[1].equals(componentName) || xmlComponent[2].equals(componentName)) && connection instanceof XmlFileConnection && XmlUtil.isXSDFile(TalendQuoteUtils.removeQuotes(((XmlFileConnection) connection).getXmlFilePath())) && param.getRepositoryValue().equals("String_Node_Str")) {
                            } else {
                                Object value = RepositoryToComponentProperty.getValue(((ConnectionItem) item).getConnection(), param.getRepositoryValue(), newOutputMetadata);
                                if (value != null) {
                                    param.setValue(value);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    node.setPropertyValue(EParameterName.UPDATE_COMPONENTS.getName(), Boolean.TRUE);
}

Output:
     node.setPropertyValue(propName, newPropValue);
-    if ((EParameterName.SCHEMA + "String_Node_Str" + EParameterName.REPOSITORY_SCHEMA_TYPE).equals(propName)) {
+    String mainSchemaParamName = DesignerUtilities.getMainSchemaParameterName(node);
+    if (mainSchemaParamName.equals(propName)) {
         IElementParameter elementParameter = node.getElementParameter(propName);


Input:
public View getView(final int position, View convertView, final ViewGroup parent) {
    ViewHolder holder = null;
    if (convertView == null) {
        holder = new ViewHolder();
        convertView = mInflater.inflate(R.layout.record_item, null);
        holder.icon = (ImageView) convertView.findViewById(R.id.record_icon);
        holder.inLy = convertView.findViewById(R.id.shouru_ly);
        holder.outLY = convertView.findViewById(R.id.zhichu_ly);
        holder.outTv = (TextView) convertView.findViewById(R.id.out_tv);
        holder.inTv = (TextView) convertView.findViewById(R.id.in_tv);
        holder.outRemarkTv = (TextView) convertView.findViewById(R.id.out_remark_tv);
        holder.inRemarkTv = (TextView) convertView.findViewById(R.id.in_remark_tv);
        holder.recordDateTv = (TextView) convertView.findViewById(R.id.record_date);
        holder.delV = convertView.findViewById(R.id.icon_del);
        holder.editV = convertView.findViewById(R.id.icon_edit);
        holder.lineV = convertView.findViewById(R.id.record_line);
        holder.myRoundColorView = (MyRoundColorView) convertView.findViewById(R.id.myRound);
        convertView.setTag(holder);
    } else {
        holder = (ViewHolder) convertView.getTag();
    }
    final RecordDetailDO recordDetailDO = recordDetailDOs.get(position);
    if (recordDetailDO.isDayFirstDay()) {
        recordDetailDOMap.put(recordDetailDO.getRecordDate(), recordDetailDO);
    }
    int color = mContext.getResources().getColor(ThemeUtil.getTheme(mContext).getMainColorID());
    holder.lineV.setBackgroundColor(color);
    holder.myRoundColorView.setMyRoundColor(color);
    holder.inTv.setTextColor(color);
    holder.outTv.setTextColor(color);
    holder.inRemarkTv.setTextColor(color);
    holder.outRemarkTv.setTextColor(color);
    holder.inLy.setVisibility(recordDetailDO.getRecordMoney() > 0 || (recordDetailDO.isDayFirstDay() && recordDetailDO.getTodayAllInMoney() > 0) || (recordDetailDO.isMonthFirstDay()) ? View.VISIBLE : View.INVISIBLE);
    holder.outLY.setVisibility(recordDetailDO.getRecordMoney() < 0 || (recordDetailDO.isDayFirstDay() && recordDetailDO.getTodayAllOutMoney() < 0) ? View.VISIBLE : View.INVISIBLE);
    holder.icon.setVisibility(recordDetailDO.isDayFirstDay() || recordDetailDO.isMonthFirstDay() ? View.INVISIBLE : View.VISIBLE);
    holder.recordDateTv.setVisibility(recordDetailDO.isDayFirstDay() || recordDetailDO.isMonthFirstDay() ? View.VISIBLE : View.INVISIBLE);
    holder.delV.setVisibility(lastSelOpt == position ? View.VISIBLE : View.INVISIBLE);
    holder.editV.setVisibility(lastSelOpt == position ? View.VISIBLE : View.INVISIBLE);
    if (recordDetailDO.getRecordMoney() < 0) {
        holder.outTv.setText(recordDetailDO.getRecordDesc() + "String_Node_Str" + String.format(mContext.getResources().getString(R.string.record_money_format), Math.abs(recordDetailDO.getRecordMoney())));
        holder.outRemarkTv.setText(recordDetailDO.getRemark());
    }
    if (recordDetailDO.getRecordMoney() > 0) {
        holder.inTv.setText(recordDetailDO.getRecordDesc() + "String_Node_Str" + String.format(mContext.getResources().getString(R.string.record_money_format), Math.abs(recordDetailDO.getRecordMoney())));
        holder.inRemarkTv.setText("String_Node_Str");
    }
    if (recordDetailDO.isMonthFirstDay()) {
        DateFormat format = new SimpleDateFormat("String_Node_Str");
        holder.inTv.setText(DateTimeUtil.isThisYear(recordDetailDO.getRecordDate()) ? "String_Node_Str" : format.format(recordDetailDO.getRecordDate()));
    } else {
        if (recordDetailDO.getTodayAllInMoney() >= 0 && recordDetailDO.isDayFirstDay()) {
            holder.inTv.setText(String.format(mContext.getResources().getString(R.string.record_money_format), Math.abs(recordDetailDO.getTodayAllInMoney())) + "String_Node_Str");
            holder.outRemarkTv.setText("String_Node_Str");
        }
    }
    if (recordDetailDO.getTodayAllOutMoney() <= 0 && recordDetailDO.isDayFirstDay()) {
        holder.outTv.setText("String_Node_Str" + String.format(mContext.getResources().getString(R.string.record_money_format), Math.abs(recordDetailDO.getTodayAllOutMoney())));
        holder.inRemarkTv.setText("String_Node_Str");
    }
    if (recordDetailDO.isMonthFirstDay()) {
        DateFormat format = new SimpleDateFormat("String_Node_Str");
        holder.recordDateTv.setText(format.format(recordDetailDO.getRecordDate()));
    } else {
        if (DateTimeUtil.isToday(recordDetailDO.getRecordDate())) {
            holder.recordDateTv.setText("String_Node_Str");
        } else {
            DateFormat format = new SimpleDateFormat("String_Node_Str");
            holder.recordDateTv.setText(format.format(recordDetailDO.getRecordDate()));
        }
    }
    holder.icon.setImageResource(IconTypeUtil.getTypeIcon(recordDetailDO.getIconId()));
    final ViewHolder finalHolder = holder;
    if (!recordDetailDO.isDayFirstDay() && !recordDetailDO.isMonthFirstDay()) {
        holder.icon.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                if (lastSelOpt != position) {
                    lastSelOpt = position;
                    notifyDataSetChanged();
                    YoYo.with(Techniques.BounceInRight).duration(200).playOn(finalHolder.delV);
                    YoYo.with(Techniques.BounceInLeft).duration(200).playOn(finalHolder.editV);
                } else {
                    resetOptStatus();
                }
            }
        });
    }
    holder.delV.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            final MaterialDialog materialDialog = new MaterialDialog(mContext);
            materialDialog.setTitle(mContext.getResources().getString(R.string.delete_record)).setMessage("String_Node_Str").setPositiveButton(mContext.getResources().getString(R.string.ok), new View.OnClickListener() {
                public void onClick(View v) {
                    final Record record = recordLocalDAO.getRecordById(mContext, recordDetailDO.getRecordID());
                    record.setIsDel(true);
                    recordManager.updateOldRecord(record, new Handler() {
                        public void handleMessage(Message msg) {
                            super.handleMessage(msg);
                            accountManager.updateAccountMoney(record.getAccountID(), -record.getRecordMoney(), new Handler() {
                                public void handleMessage(Message msg) {
                                    super.handleMessage(msg);
                                    ((MainActivity) mContext).getReloadAccountCallBack().reload(true);
                                    ((MainActivity) mContext).getReloadAnalysisCallBack().reload(true);
                                }
                            });
                        }
                    });
                    RecordDetailDO todayRecordDetailDO = recordDetailDOMap.get(recordDetailDO.getRecordDate());
                    if (recordDetailDO.getRecordMoney() < 0) {
                        todayRecordDetailDO.setTodayAllOutMoney(todayRecordDetailDO.getTodayAllOutMoney() - recordDetailDO.getRecordMoney());
                    } else {
                        todayRecordDetailDO.setTodayAllInMoney(todayRecordDetailDO.getTodayAllInMoney() - recordDetailDO.getRecordMoney());
                    }
                    if (recordDetailDOs.get(position - 1).isDayFirstDay() && (position == recordDetailDOs.size() - 1 || recordDetailDOs.get(position + 1).isDayFirstDay() || recordDetailDOs.get(position + 1).isMonthFirstDay())) {
                        if (recordDetailDOs.get(position - 2).isMonthFirstDay() && (position == recordDetailDOs.size() - 1 || recordDetailDOs.get(position + 1).isMonthFirstDay())) {
                            recordDetailDOs.remove(position - 2);
                            recordDetailDOs.remove(position - 2);
                            recordDetailDOs.remove(position - 2);
                        } else {
                            recordDetailDOs.remove(position - 1);
                            recordDetailDOs.remove(position - 1);
                        }
                    } else {
                        recordDetailDOs.remove(position);
                    }
                    if (recordDetailDOs.size() == 0) {
                        recordFrg.resetFoot();
                    }
                    resetOptStatus();
                    materialDialog.dismiss();
                }
            }).setNegativeButton(mContext.getResources().getString(R.string.cancel), new View.OnClickListener() {
                public void onClick(View v) {
                    materialDialog.dismiss();
                }
            }).show();
        }
    });
    holder.editV.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            Intent intent = new Intent(mContext, CreateOrEditRecordActivity.class);
            intent.putExtra(IntentConstant.OLD_RECORD, recordLocalDAO.getRecordById(mContext, recordDetailDO.getRecordID()));
            resetOptStatus();
            ((MainActivity) mContext).startActivityForResult(intent, MainActivity.REQUEST_RECORD);
        }
    });
    convertView.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            resetOptStatus();
        }
    });
    return convertView;
}

Output:
         holder.inTv.setText(recordDetailDO.getRecordDesc() + "String_Node_Str" + String.format(mContext.getResources().getString(R.string.record_money_format), Math.abs(recordDetailDO.getRecordMoney())));
-        holder.inRemarkTv.setText("String_Node_Str");
+        holder.inRemarkTv.setText(recordDetailDO.getRemark());
     }


Input:
public void handleMulticastMessage(Message msg, DatagramPacket datagram) {
    if (msg.getTTL() > 1)
        return;
    msg.hop();
    InetAddress address = datagram.getAddress();
    int port = datagram.getPort();
    if (NetworkUtils.isLocalAddress(address))
        return;
    ReplyHandler handler = new UDPReplyHandler(address, port);
    if (msg instanceof QueryRequest) {
        if (!handleUDPQueryRequestPossibleDuplicate((QueryRequest) msg, handler)) {
            ReceivedMessageStatHandler.MULTICAST_DUPLICATE_QUERIES.addMessage(msg);
        }
        if (RECORD_STATS)
            ReceivedMessageStatHandler.MULTICAST_QUERY_REQUESTS.addMessage(msg);
    } else if (msg instanceof PingRequest) {
        if (RECORD_STATS)
            ReceivedMessageStatHandler.MULTICAST_PING_REQUESTS.addMessage(msg);
        handleUDPPingRequestPossibleDuplicate((PingRequest) msg, handler, datagram);
    } else if (msg instanceof PushRequest) {
        if (RECORD_STATS)
            ReceivedMessageStatHandler.MULTICAST_PUSH_REQUESTS.addMessage(msg);
        handlePushRequest((PushRequest) msg, handler);
    }
}

Output:
     int port = datagram.getPort();
-    if (NetworkUtils.isLocalAddress(address))
+    if (NetworkUtils.isLocalAddress(address) && !ConnectionSettings.ALLOW_MULTICAST_LOOPBACK.getValue())
         return;


Input:
private void runEval(EvalConfig evalConfig) throws IOException {
    validateEvalColumnConfig(evalConfig);
    String evalSetPath = pathFinder.getEvalSetPath(evalConfig, SourceType.LOCAL);
    FileUtils.forceMkdir(new File(evalSetPath));
    syncDataToHdfs(evalConfig.getDataSet().getSource());
    switch(modelConfig.getBasic().getRunMode()) {
        case DIST:
        case MAPRED:
            runDistEval(evalConfig);
            break;
        case LOCAL:
            runAkkaEval(evalConfig);
            break;
        default:
            break;
    }
}

Output:
 private void runEval(EvalConfig evalConfig) throws IOException {
-    validateEvalColumnConfig(evalConfig);
-    String evalSetPath = pathFinder.getEvalSetPath(evalConfig, SourceType.LOCAL);
-    FileUtils.forceMkdir(new File(evalSetPath));
-    syncDataToHdfs(evalConfig.getDataSet().getSource());
+    synchronized (this) {
+        validateEvalColumnConfig(evalConfig);
+        String evalSetPath = pathFinder.getEvalSetPath(evalConfig, SourceType.LOCAL);
+        FileUtils.forceMkdir(new File(evalSetPath));
+        syncDataToHdfs(evalConfig.getDataSet().getSource());
+    }
     switch(modelConfig.getBasic().getRunMode()) {


Input:
public void testLocalExecutorWithWordCount() {
    try {
        File inFile = File.createTempFile("String_Node_Str", "String_Node_Str");
        File outFile = File.createTempFile("String_Node_Str", "String_Node_Str");
        inFile.deleteOnExit();
        outFile.deleteOnExit();
        FileWriter fw = new FileWriter(inFile);
        fw.write(WordCountITCase.TEXT);
        fw.close();
        WordCount wc = new WordCount();
        LocalExecutor.execute(wc, "String_Node_Str", inFile.toURI().toString(), outFile.toURI().toString());
    } catch (Exception e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
}

Output:
         FileWriter fw = new FileWriter(inFile);
-        fw.write(WordCountITCase.TEXT);
+        fw.write(WordCountData.TEXT);
         fw.close();


Input:
protected void strategyKilledEvent(ShortPoint2D pathTarget) {
    if (building != null) {
        if (isInTower) {
            building.removeSoldier(this);
        } else {
            building.requestFailed(movableType);
        }
    }
}

Output:
         } else {
-            building.requestFailed(movableType);
+            notifyTowerThatRequestFailed();
         }


Input:
public boolean check(Cluster cluster, Project project, int cores) {
    return jdbc.queryForInt(QUOTA_CHECK, cluster.getClusterId(), project.getProjectId(), cores) == 1;
}

Output:
 public boolean check(Cluster cluster, Project project, int cores) {
-    return jdbc.queryForInt(QUOTA_CHECK, cluster.getClusterId(), project.getProjectId(), cores) == 1;
+    return jdbc.queryForInt(QUOTA_CHECK, project.getProjectId(), cluster.getClusterId(), cores) == 1;
 }


Input:
private void handleRootFiles(final String[][] configurations, final Properties properties) throws IOException {
    if (configurations.length > 0) {
        String rootPrefix = IBuildPropertiesConstants.ROOT_PREFIX + configurations[0][0] + "String_Node_Str" + configurations[0][1] + "String_Node_Str" + configurations[0][2];
        properties.put(rootPrefix, getRootFileLocations(false));
        prepareWARFile(properties, rootPrefix);
    }
}

Output:
         properties.put(rootPrefix, getRootFileLocations(false));
-        prepareWARFile(properties, rootPrefix);
+        prepareWARFile(properties, rootPrefix, featureLocation);
     }


Input:
int stopGenericRecognition(UUID modelId, IRecognitionStatusCallback listener) {
    if (listener == null) {
        return STATUS_ERROR;
    }
    synchronized (mLock) {
        ModelData modelData = mGenericModelDataMap.get(modelId);
        if (modelData == null) {
            Slog.w(TAG, "String_Node_Str" + modelId);
            return STATUS_ERROR;
        }
        IRecognitionStatusCallback currentCallback = modelData.getCallback();
        if (DBG) {
            Slog.d(TAG, "String_Node_Str" + modelId + "String_Node_Str" + listener.asBinder());
            Slog.d(TAG, "String_Node_Str" + (currentCallback == null ? "String_Node_Str" : currentCallback.asBinder()));
        }
        if (mModuleProperties == null || mModule == null) {
            Slog.w(TAG, "String_Node_Str");
            return STATUS_ERROR;
        }
        if (currentCallback == null || !modelData.modelStarted()) {
            Slog.w(TAG, "String_Node_Str");
            return STATUS_ERROR;
        }
        if (currentCallback.asBinder() != listener.asBinder()) {
            Slog.w(TAG, "String_Node_Str");
            return STATUS_ERROR;
        }
        int status = stopGenericRecognitionLocked(modelData, false);
        if (status != SoundTrigger.STATUS_OK) {
            return status;
        }
        modelData.clearState();
        modelData.clearCallback();
        if (!computeRecognitionRunning()) {
            internalClearGlobalStateLocked();
        }
        return status;
    }
}

Output:
         }
-        if (currentCallback == null || !modelData.modelStarted()) {
+        if (currentCallback == null || !modelData.isModelStarted()) {
             Slog.w(TAG, "String_Node_Str");


Input:
public SSAAbstractInvokeInstruction getCall() {
    return call;
}

Output:
 public SSAAbstractInvokeInstruction getCall() {
-    return call;
+    return (SSAAbstractInvokeInstruction) getNode().getIR().getInstructions()[callIndex];
 }


Input:
private void addModulesToCache(List<MavenArtifact> searchResults, Map<String, ModuleToInstall> theCache) {
    for (MavenArtifact artifact : searchResults) {
        String artifactId = artifact.getArtifactId();
        String packageName = artifact.getType();
        if (packageName == null) {
            packageName = MavenConstants.TYPE_JAR;
        }
        String version = artifact.getVersion();
        String description = artifact.getDescription();
        String license = artifact.getLicense();
        String license_url = artifact.getLicenseUrl();
        String packaging = artifact.getType();
        String url = null;
        if (artifact.getUrl() != null && !"String_Node_Str".equals(artifact.getUrl())) {
            url = artifact.getUrl();
        }
        ModuleToInstall m = new ModuleToInstall();
        m.setName(artifactId + "String_Node_Str" + packageName);
        String mvnUri = MavenUrlHelper.generateMvnUrl(artifact.getGroupId(), artifactId, version, packaging, artifact.getClassifier());
        m.setMavenUri(mvnUri);
        m.setLicenseType(license);
        m.setLicenseUrl(license_url);
        m.setDescription(description);
        m.setUrl_description(url);
        m.setUrl_download(url);
        String artifactType = artifact.getType();
        m.resolveDistribution(artifactType);
        if (theCache == localCache) {
            m.setFromCustomNexus(true);
        }
        theCache.put(mvnUri, m);
    }
}

Output:
         m.setName(artifactId + "String_Node_Str" + packageName);
-        String mvnUri = MavenUrlHelper.generateMvnUrl(artifact.getGroupId(), artifactId, version, packaging, artifact.getClassifier());
+        String mvnUri = MavenUrlHelper.generateMvnUrl(artifact.getGroupId(), artifactId, version, packageName, artifact.getClassifier());
         m.setMavenUri(mvnUri);


Input:
public List<VolumeVO> searchForVolumes(ListVolumesCmd cmd) throws InvalidParameterValueException, PermissionDeniedException {
    Account account = UserContext.current().getCaller();
    Long domainId = cmd.getDomainId();
    String accountName = cmd.getAccountName();
    Long accountId = null;
    boolean isAdmin = false;
    Boolean isRecursive = cmd.isRecursive();
    if (isRecursive == null) {
        isRecursive = false;
    }
    if ((account == null) || isAdmin(account.getType())) {
        isAdmin = true;
        if (domainId != null) {
            if ((account != null) && !_domainDao.isChildDomain(account.getDomainId(), domainId)) {
                throw new PermissionDeniedException("String_Node_Str" + domainId + "String_Node_Str");
            }
            if (accountName != null) {
                Account userAccount = _accountDao.findActiveAccount(accountName, domainId);
                if (userAccount != null) {
                    accountId = userAccount.getId();
                } else {
                    throw new InvalidParameterValueException("String_Node_Str" + accountName + "String_Node_Str" + domainId);
                }
            }
        } else {
            domainId = ((account == null) ? DomainVO.ROOT_DOMAIN : account.getDomainId());
            isRecursive = true;
        }
    } else {
        accountId = account.getId();
    }
    Filter searchFilter = new Filter(VolumeVO.class, "String_Node_Str", false, cmd.getStartIndex(), cmd.getPageSizeVal());
    Object id = cmd.getId();
    Long vmInstanceId = cmd.getVirtualMachineId();
    Object name = cmd.getVolumeName();
    Object keyword = cmd.getKeyword();
    Object type = cmd.getType();
    Object zone = null;
    Object pod = null;
    if (isAdmin) {
        zone = cmd.getZoneId();
        pod = cmd.getPodId();
    } else {
        domainId = null;
    }
    SearchBuilder<VolumeVO> sb = _volumeDao.createSearchBuilder();
    sb.and("String_Node_Str", sb.entity().getName(), SearchCriteria.Op.LIKE);
    sb.and("String_Node_Str", sb.entity().getId(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getAccountId(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getAccountId(), SearchCriteria.Op.IN);
    sb.and("String_Node_Str", sb.entity().getVolumeType(), SearchCriteria.Op.LIKE);
    sb.and("String_Node_Str", sb.entity().getInstanceId(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getDataCenterId(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getPodId(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getName(), SearchCriteria.Op.NLIKE);
    sb.and("String_Node_Str", sb.entity().getName(), SearchCriteria.Op.NLIKE);
    sb.and("String_Node_Str", sb.entity().getName(), SearchCriteria.Op.NLIKE);
    sb.and("String_Node_Str", sb.entity().getStatus(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getState(), SearchCriteria.Op.NEQ);
    if (((accountId == null) && (domainId != null) && isRecursive)) {
        SearchBuilder<DomainVO> domainSearch = _domainDao.createSearchBuilder();
        domainSearch.and("String_Node_Str", domainSearch.entity().getPath(), SearchCriteria.Op.LIKE);
        sb.join("String_Node_Str", domainSearch, sb.entity().getDomainId(), domainSearch.entity().getId(), JoinBuilder.JoinType.INNER);
    } else if ((accountId == null) && (domainId != null) && !isRecursive) {
        SearchBuilder<DomainVO> domainSearch = _domainDao.createSearchBuilder();
        domainSearch.and("String_Node_Str", domainSearch.entity().getPath(), SearchCriteria.Op.EQ);
        sb.join("String_Node_Str", domainSearch, sb.entity().getDomainId(), domainSearch.entity().getId(), JoinBuilder.JoinType.INNER);
    }
    SearchCriteria<VolumeVO> sc = sb.create();
    if (keyword != null) {
        SearchCriteria<VolumeVO> ssc = _volumeDao.createSearchCriteria();
        ssc.addOr("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + keyword + "String_Node_Str");
        ssc.addOr("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + keyword + "String_Node_Str");
        sc.addAnd("String_Node_Str", SearchCriteria.Op.SC, ssc);
    }
    if (name != null) {
        sc.setParameters("String_Node_Str", "String_Node_Str" + name + "String_Node_Str");
    }
    if (id != null) {
        sc.setParameters("String_Node_Str", id);
    }
    if (accountId != null) {
        sc.setParameters("String_Node_Str", accountId);
    } else if (domainId != null) {
        DomainVO domain = _domainDao.findById(domainId);
        if (isRecursive) {
            sc.setJoinParameters("String_Node_Str", "String_Node_Str", domain.getPath() + "String_Node_Str");
        } else {
            sc.setJoinParameters("String_Node_Str", "String_Node_Str", domain.getPath());
        }
    }
    if (type != null) {
        sc.setParameters("String_Node_Str", "String_Node_Str" + type + "String_Node_Str");
    }
    if (vmInstanceId != null) {
        sc.setParameters("String_Node_Str", vmInstanceId);
    }
    if (zone != null) {
        sc.setParameters("String_Node_Str", zone);
    }
    if (pod != null) {
        sc.setParameters("String_Node_Str", pod);
    }
    sc.setParameters("String_Node_Str", Volume.State.Destroy);
    List<VolumeVO> allVolumes = _volumeDao.search(sc, searchFilter);
    List<VolumeVO> returnableVolumes = new ArrayList<VolumeVO>();
    for (VolumeVO v : allVolumes) {
        VMTemplateVO template = _templateDao.findById(v.getTemplateId());
        if (template != null && (template.getTemplateType() == TemplateType.SYSTEM)) {
        } else {
            if (v.getInstanceId() == null) {
                returnableVolumes.add(v);
            } else {
                if (account.getType() == Account.ACCOUNT_TYPE_NORMAL) {
                    VMInstanceVO owningVm = _vmInstanceDao.findById(v.getInstanceId());
                    if (owningVm != null && owningVm.getType().equals(VirtualMachine.Type.User) && owningVm.getState().equals(VirtualMachine.State.Destroyed)) {
                    } else {
                        returnableVolumes.add(v);
                    }
                } else {
                    returnableVolumes.add(v);
                }
            }
        }
    }
    return returnableVolumes;
}

Output:
     sc.setParameters("String_Node_Str", Volume.State.Destroy);
-    List<VolumeVO> allVolumes = _volumeDao.search(sc, searchFilter);
-    List<VolumeVO> returnableVolumes = new ArrayList<VolumeVO>();
-    for (VolumeVO v : allVolumes) {
-        VMTemplateVO template = _templateDao.findById(v.getTemplateId());
-        if (template != null && (template.getTemplateType() == TemplateType.SYSTEM)) {
-        } else {
-            if (v.getInstanceId() == null) {
-                returnableVolumes.add(v);
-            } else {
-                if (account.getType() == Account.ACCOUNT_TYPE_NORMAL) {
-                    VMInstanceVO owningVm = _vmInstanceDao.findById(v.getInstanceId());
-                    if (owningVm != null && owningVm.getType().equals(VirtualMachine.Type.User) && owningVm.getState().equals(VirtualMachine.State.Destroyed)) {
-                    } else {
-                        returnableVolumes.add(v);
-                    }
-                } else {
-                    returnableVolumes.add(v);
-                }
-            }
-        }
-    }
-    return returnableVolumes;
+    return _volumeDao.search(sc, searchFilter);
 }