Input:
public void register(SInternalServicePluginConfiguration internalServicePluginConfiguration, final PluginConfiguration pluginConfiguration) {
    ServiceDescriptor serviceDescriptor = StoreFactory.eINSTANCE.createServiceDescriptor();
    serviceDescriptor.setProviderName("String_Node_Str");
    serviceDescriptor.setIdentifier(getClass().getName());
    serviceDescriptor.setName("String_Node_Str");
    serviceDescriptor.setDescription("String_Node_Str");
    serviceDescriptor.setReadRevision(true);
    serviceDescriptor.setNotificationProtocol(AccessMethod.INTERNAL);
    serviceDescriptor.setTrigger(Trigger.NEW_REVISION);
    registerNewRevisionHandler(serviceDescriptor, new NewRevisionHandler() {
        public void newRevision(BimServerClientInterface bimServerClientInterface, long poid, long roid, String userToken, long soid, SObjectType settings) throws ServerException, UserException {
            Date startDate = new Date();
            Long topicId = null;
            try {
                topicId = bimServerClientInterface.getRegistry().registerProgressOnRevisionTopic(SProgressTopicType.RUNNING_SERVICE, poid, roid, "String_Node_Str");
                SLongActionState state = new SLongActionState();
                state.setTitle("String_Node_Str");
                state.setState(SActionState.STARTED);
                state.setProgress(-1);
                state.setStart(startDate);
                bimServerClientInterface.getRegistry().updateProgressTopic(topicId, state);
                SSerializerPluginConfiguration stepSerializerRemote = bimServerClientInterface.getBimsie1ServiceInterface().getSerializerByContentType("String_Node_Str");
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                bimServerClientInterface.download(roid, stepSerializerRemote.getOid(), outputStream);
                BimServerClientInterface localClient = getLocalBimServerClientInterface(new UserTokenAuthentication(userToken));
                PluginConfiguration pluginConfiguration = new org.bimserver.plugins.PluginConfiguration(settings);
                String localProjectName = pluginConfiguration.getString("String_Node_Str");
                List<SProject> projectsByName = localClient.getBimsie1ServiceInterface().getProjectsByName(localProjectName);
                if (projectsByName.isEmpty()) {
                    throw new UserException("String_Node_Str" + localProjectName + "String_Node_Str");
                }
                SProject localProject = projectsByName.get(0);
                SDeserializerPluginConfiguration localDeserializer = localClient.getBimsie1ServiceInterface().getDeserializerByName("String_Node_Str");
                localClient.getBimsie1ServiceInterface().checkin(localProject.getOid(), "String_Node_Str", localDeserializer.getOid(), (long) outputStream.size(), "String_Node_Str", new DataHandler(new InputStreamDataSource(new ByteArrayInputStream(outputStream.toByteArray()))), true);
            } catch (PublicInterfaceNotFoundException e) {
                LOGGER.error("String_Node_Str", e);
            } catch (ServiceException e) {
                LOGGER.error("String_Node_Str", e);
            } catch (ChannelConnectionException e) {
                LOGGER.error("String_Node_Str", e);
            } finally {
                SLongActionState state = new SLongActionState();
                state.setProgress(100);
                state.setTitle("String_Node_Str");
                state.setState(SActionState.FINISHED);
                state.setStart(startDate);
                state.setEnd(new Date());
                try {
                    bimServerClientInterface.getRegistry().updateProgressTopic(topicId, state);
                    bimServerClientInterface.getRegistry().unregisterProgressTopic(topicId);
                } catch (PublicInterfaceNotFoundException e) {
                    LOGGER.error("String_Node_Str", e);
                }
            }
        }
    });
}

Output:
     serviceDescriptor.setProviderName("String_Node_Str");
-    serviceDescriptor.setIdentifier(getClass().getName());
+    serviceDescriptor.setIdentifier("String_Node_Str" + internalServicePluginConfiguration.getOid());
     serviceDescriptor.setName("String_Node_Str");


Input:
public void setFiles(Map<String, String> files) {
    m_fileList.resize(files.size(), 2);
    m_files = files;
    int i = 0;
    for (Map.Entry<String, String> file : files.entrySet()) {
        CheckBox fileCheckBox = new CheckBox();
        fileCheckBox.setVisible(m_editionMode);
        m_fileList.setWidget(i, 0, fileCheckBox);
        String webappContext = HTMLUtil.getWebContext();
        String htmlLink = "String_Node_Str" + webappContext + "String_Node_Str" + file.getValue() + "String_Node_Str" + file.getKey() + "String_Node_Str";
        m_fileList.setHTML(i, 1, htmlLink);
        i++;
    }
}

Output:
         String webappContext = HTMLUtil.getWebContext();
-        String htmlLink = "String_Node_Str" + webappContext + "String_Node_Str" + file.getValue() + "String_Node_Str" + file.getKey() + "String_Node_Str";
+        String htmlLink = "String_Node_Str" + (webappContext == null ? "String_Node_Str" : webappContext + "String_Node_Str") + "String_Node_Str" + file.getValue() + "String_Node_Str" + file.getKey() + "String_Node_Str";
         m_fileList.setHTML(i, 1, htmlLink);


Input:
private void exchange(HttpExchange exchange, CommandType type) {
    InputStream bodyStream = exchange.getRequestBody();
    Scanner scanner = new Scanner(bodyStream);
    String body = "String_Node_Str";
    String uuid = null;
    String username = null;
    System.out.println("String_Node_Str" + type);
    if (type != CommandType.LOGIN_COMMAND) {
        try {
            uuid = exchange.getRequestHeaders().get("String_Node_Str").get(0);
        } catch (NullPointerException e) {
            System.out.println("String_Node_Str");
            Response errorResponse = new MinimalResponse(StatusCode.UNAUTHORIZED);
            try {
                respond(exchange, errorResponse);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            scanner.close();
            return;
        }
    } else {
        System.out.println("String_Node_Str");
    }
    while (scanner.hasNext()) {
        body = body.concat(scanner.next());
    }
    scanner.close();
    Response response = null;
    try {
        username = Authenticate.getUsername(uuid);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("String_Node_Str" + body);
    System.out.println("String_Node_Str");
    try {
        response = commandHandler.processNewCommand(body, exchange.getRequestURI().toString(), username, type);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("String_Node_Str");
    try {
        respond(exchange, response);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
     while (scanner.hasNext()) {
-        body = body.concat(scanner.next());
+        body = body.concat("String_Node_Str" + scanner.next());
     }


Input:
public void update(Object entity, final String path, final HttpMethod verb, PrettyOutput... prettyOutput) {
    checkConnection();
    try {
        if (verb == HttpMethod.PUT) {
            ResponseEntity<String> response = restUpdate(path, entity);
            if (!validateAuthorization(response)) {
                return;
            }
            processResponse(response, HttpMethod.PUT, prettyOutput);
        } else {
            throw new Exception(Constants.HTTP_VERB_ERROR);
        }
    } catch (Exception e) {
        throw new CliRestException(getExceptionMessage(e));
    }
}

Output:
     } catch (Exception e) {
-        throw new CliRestException(getExceptionMessage(e));
+        throw new CliRestException(CommandsUtils.getExceptionMessage(e));
     }


Input:
private Object[] checkNumericValue(NumericConstant nc) {
    Double d = null;
    Object[] shift = new Object[3];
    if (nc instanceof IntConstant) {
        d = new Double(((IntConstant) nc).value);
    } else if (nc instanceof DoubleConstant) {
        d = new Double(((DoubleConstant) nc).value);
    } else if (nc instanceof FloatConstant) {
        d = new Double(((FloatConstant) nc).value);
    } else if (nc instanceof LongConstant) {
        d = new Double(((LongConstant) nc).value);
    }
    if (d != null) {
        shift[2] = new Boolean(d.doubleValue() < 0);
        double[] tmp = checkShiftValue(d.doubleValue());
        if (tmp[0] != 0) {
            shift[0] = new Integer((int) tmp[0]);
            if (tmp[1] != 0)
                shift[1] = new Double(tmp[1]);
            else
                shift[1] = null;
        } else
            d = null;
    }
    if (d == null) {
        shift[0] = null;
        shift[1] = null;
    }
    return shift;
}

Output:
 private Object[] checkNumericValue(NumericConstant nc) {
-    Double d = null;
-    Object[] shift = new Object[3];
+    Double dnc = null;
     if (nc instanceof IntConstant) {


Input:
static Predicate<Statement> fromConfig(final Configuration config) {
    List<LoadingType> loadingTypes = loadingTypesFromConfig(config);
    if (loadingTypes == null || loadingTypes.isEmpty())
        return DUMMY_PREDICATE;
    return fromLoadingTypes(loadingTypes);
}

Output:
 static Predicate<Statement> fromConfig(final Configuration config) {
-    List<LoadingType> loadingTypes = loadingTypesFromConfig(config);
+    List<LoadingType> loadingTypes = LoadingType.fromConfig(config);
     if (loadingTypes == null || loadingTypes.isEmpty())


Input:
public void buildEnvVars(AbstractBuild<?, ?> build, Map<String, String> env) {
    super.buildEnvVars(build, env);
    TagAction tagAction = build.getAction(TagAction.class);
    if (tagAction != null) {
        if (tagAction.getBuildChange() != null) {
            String change = getChangeNumber(tagAction);
            env.put("String_Node_Str", change);
        }
        if (tagAction.getClient() != null) {
            String client = tagAction.getClient();
            env.put("String_Node_Str", client);
        }
        if (tagAction.getPort() != null) {
            String port = tagAction.getPort();
            env.put("String_Node_Str", port);
        }
        if (tagAction.getUser() != null) {
            String user = tagAction.getUser();
            env.put("String_Node_Str", user);
        }
        Descriptor<SCM> scm = Jenkins.getInstance().getDescriptor(PerforceScm.class);
        DescriptorImpl p4scm = (DescriptorImpl) scm;
        if (tagAction.getTicket() != null && !p4scm.isHideTicket()) {
            String ticket = tagAction.getTicket();
            env.put("String_Node_Str", ticket);
        }
    }
}

Output:
         }
-        Descriptor<SCM> scm = Jenkins.getInstance().getDescriptor(PerforceScm.class);
-        DescriptorImpl p4scm = (DescriptorImpl) scm;
-        if (tagAction.getTicket() != null && !p4scm.isHideTicket()) {
-            String ticket = tagAction.getTicket();
-            env.put("String_Node_Str", ticket);
+        Jenkins j = Jenkins.getInstance();
+        if (j != null) {
+            Descriptor<SCM> scm = j.getDescriptor(PerforceScm.class);
+            DescriptorImpl p4scm = (DescriptorImpl) scm;
+            if (tagAction.getTicket() != null && !p4scm.isHideTicket()) {
+                String ticket = tagAction.getTicket();
+                env.put("String_Node_Str", ticket);
+            }
         }


Input:
private static void copyFile(File src, File dest) throws IOException {
    if (!dest.exists()) {
        dest.getParentFile().mkdirs();
        dest.createNewFile();
    }
    FileChannel srcChannel = null;
    FileChannel destChannel = null;
    try {
        srcChannel = new FileInputStream(src).getChannel();
        destChannel = new FileOutputStream(dest).getChannel();
        destChannel.transferFrom(srcChannel, 0, srcChannel.size());
    } finally {
        if (srcChannel != null) {
            srcChannel.close();
        }
        if (destChannel != null) {
            destChannel.close();
        }
    }
}

Output:
     if (!dest.exists()) {
-        dest.getParentFile().mkdirs();
-        dest.createNewFile();
+        mkDirs(dest.getParentFile());
+        mkFile(dest);
     }


Input:
public Boolean run(CommandSender sender, String[] args) {
    Object[] names = Jail.prisoners.keySet().toArray();
    for (Object p : names) {
        JailPrisoner prisoner = Jail.prisoners.get((String) p);
        String playername = prisoner.getName();
        Player player = Jail.instance.getServer().getPlayerExact(playername);
        if (player == null) {
            prisoner.setOfflinePending(true);
            prisoner.setRemainingTime(0);
            InputOutput.UpdatePrisoner(prisoner);
            Jail.prisoners.put(prisoner.getName(), prisoner);
        } else {
            PrisonerManager.UnJail(prisoner, player);
        }
    }
    return true;
}

Output:
         JailPrisoner prisoner = Jail.prisoners.get((String) p);
-        String playername = prisoner.getName();
-        Player player = Jail.instance.getServer().getPlayerExact(playername);
-        if (player == null) {
-            prisoner.setOfflinePending(true);
-            prisoner.setRemainingTime(0);
-            InputOutput.UpdatePrisoner(prisoner);
-            Jail.prisoners.put(prisoner.getName(), prisoner);
-        } else {
-            PrisonerManager.UnJail(prisoner, player);
-        }
+        prisoner.release();
     }


Input:
public ClassLoader getClassLoader(ClassLoader parent, DeploymentContext context) {
    try {
        String moduleDir = context.getSource().getURI().getPath();
        String moduleName = context.getSource().getName();
        List<URI> appLibs = null;
        try {
            appLibs = context.getAppLibs();
            if (_logger.isLoggable(Level.FINEST)) {
                _logger.log(Level.FINEST, "String_Node_Str" + "String_Node_Str" + moduleName + "String_Node_Str" + appLibs);
            }
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
        ClassLoader carCL;
        if (isEmbedded(context)) {
            String applicationName = ConnectorsUtil.getApplicationName(context);
            String embeddedRarName = ConnectorsUtil.getEmbeddedRarModuleName(applicationName, moduleName);
            carCL = loader.createRARClassLoader(moduleDir, parent.getParent().getParent(), embeddedRarName, appLibs);
        } else {
            carCL = loader.createRARClassLoader(moduleDir, null, moduleName, appLibs);
        }
        try {
            final DeploymentContext dc = context;
            final ClassLoader cl = carCL;
            AccessController.doPrivileged(new PermsArchiveDelegate.SetPermissionsAction(SMGlobalPolicyUtil.CommponentType.rar, dc, cl));
        } catch (PrivilegedActionException e) {
            throw (SecurityException) e.getException();
        }
        return carCL;
    } catch (ConnectorRuntimeException e) {
        throw new RuntimeException(e);
    }
}

Output:
         } catch (PrivilegedActionException e) {
-            throw (SecurityException) e.getException();
+            throw new SecurityException(e.getException());
         }


Input:
public void run() {
    for (int i = 0; i < friends.size(); i++) {
        int bestIndex = getBestFriend(i);
        final Friend f = friends.get(bestIndex);
        if (f.hasDownloadedProfilePicture())
            continue;
        File file = new File(getCacheDir(), f.getUID());
        Bitmap picture = Tools.getBitmapFromFile(file);
        if (picture == null) {
            picture = Tools.downloadBitmap(f.getProfilePictureURL());
        }
        if (picture != null) {
            f.setProfilePic(picture);
            Tools.storePictureToFile(file, picture);
        }
        updateProfilePictureAtIndex(f, bestIndex);
        if (bestIndex != i)
            i--;
    }
}

Output:
             continue;
-        File file = new File(getCacheDir(), f.getUID());
+        File file = new File(getCacheDir(), f.getSaveProfiePictureFileName());
         Bitmap picture = Tools.getBitmapFromFile(file);


Input:
protected void collect(OSMWay way, TreeMap<Double, Integer> weightToPrioMap) {
    String highway = way.getTag("String_Node_Str");
    if (way.hasTag("String_Node_Str", "String_Node_Str"))
        weightToPrioMap.put(100d, PREFER.getValue());
    double maxSpeed = getMaxSpeed(way);
    if (safeHighwayTags.contains(highway) || maxSpeed > 0 && maxSpeed <= 20) {
        weightToPrioMap.put(40d, PREFER.getValue());
        if (way.hasTag("String_Node_Str", intendedValues)) {
            if (way.hasTag("String_Node_Str", "String_Node_Str"))
                weightToPrioMap.put(40d, REACH_DEST.getValue());
            else
                weightToPrioMap.put(40d, UNCHANGED.getValue());
        }
    } else if (maxSpeed > 50 || avoidHighwayTags.contains(highway)) {
        if (way.hasTag("String_Node_Str", "String_Node_Str"))
            weightToPrioMap.put(45d, WORST.getValue());
        else if (way.hasTag("String_Node_Str", "String_Node_Str"))
            weightToPrioMap.put(45d, REACH_DEST.getValue());
        else
            weightToPrioMap.put(45d, AVOID_AT_ALL_COSTS.getValue());
    }
    if (way.hasTag("String_Node_Str", "String_Node_Str") || way.hasTag("String_Node_Str", "String_Node_Str"))
        weightToPrioMap.put(44d, AVOID_IF_POSSIBLE.getValue());
}

Output:
     } else if (maxSpeed > 50 || avoidHighwayTags.contains(highway)) {
-        if (way.hasTag("String_Node_Str", "String_Node_Str"))
-            weightToPrioMap.put(45d, WORST.getValue());
-        else if (way.hasTag("String_Node_Str", "String_Node_Str"))
-            weightToPrioMap.put(45d, REACH_DEST.getValue());
-        else
-            weightToPrioMap.put(45d, AVOID_AT_ALL_COSTS.getValue());
+        if (maxSpeed > 0 && maxSpeed <= 30) {
+            if (way.hasTag("String_Node_Str", "String_Node_Str") || way.hasTag("String_Node_Str", "String_Node_Str"))
+                weightToPrioMap.put(40d, PREFER.getValue());
+            else
+                weightToPrioMap.put(40d, UNCHANGED.getValue());
+        } else {
+            if (way.hasTag("String_Node_Str", "String_Node_Str"))
+                weightToPrioMap.put(45d, WORST.getValue());
+            else if (way.hasTag("String_Node_Str", "String_Node_Str") || way.hasTag("String_Node_Str", "String_Node_Str"))
+                weightToPrioMap.put(45d, REACH_DEST.getValue());
+            else
+                weightToPrioMap.put(45d, AVOID_AT_ALL_COSTS.getValue());
+        }
     }


Input:
private void checkSchema() {
    boolean canEditSchema = false;
    boolean noSchema = false;
    for (IElementParameter param : this.getElementParameters()) {
        if (param.isShow(getElementParameters()) && param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE)) {
            canEditSchema = true;
            break;
        }
    }
    INodeConnector mainConnector;
    if (isELTComponent()) {
        mainConnector = this.getConnectorFromType(EConnectionType.TABLE);
    } else {
        mainConnector = this.getConnectorFromType(EConnectionType.FLOW_MAIN);
    }
    List<INodeConnector> mainConnectors = this.getConnectorsFromType(EConnectionType.FLOW_MAIN);
    if (mainConnector != null && !isExternalNode()) {
        IMetadataTable table = getMetadataFromConnector(mainConnector.getName());
        if (canEditSchema && table != null) {
            if (LanguageManager.getCurrentLanguage() == ECodeLanguage.JAVA) {
                for (int i = 0; i < table.getListColumns().size(); i++) {
                    IMetadataColumn column = table.getListColumns().get(i);
                    if (column.isCustom()) {
                        continue;
                    }
                    String value = column.getPattern();
                    String typevalue = column.getTalendType();
                    if (JavaTypesManager.DATE.getId().equals(typevalue) || PerlTypesManager.DATE.equals(typevalue)) {
                        if (value == null || "String_Node_Str".equals(value)) {
                            String errorMessage = Messages.getString("String_Node_Str");
                            Problems.add(ProblemStatus.WARNING, this, errorMessage);
                            noSchema = true;
                        }
                    }
                }
            }
            if ((mainConnector.getMaxLinkInput() == 0 || ("String_Node_Str".equals(getComponent().getName()) && (mainConnector.getMaxLinkInput() != 0) && getCurrentActiveLinksNbOutput(EConnectionType.FLOW_MAIN) > 0)) && (mainConnector.getMaxLinkOutput() != 0)) {
                if (table.getListColumns().size() == 0) {
                    String errorMessage = Messages.getString("String_Node_Str");
                    Problems.add(ProblemStatus.WARNING, this, errorMessage);
                    noSchema = true;
                }
            }
        } else {
            if ((mainConnector.getMaxLinkInput() != 0) && (mainConnector.getMaxLinkOutput() != 0)) {
                if (table != null && table.getListColumns().size() == 0) {
                    noSchema = true;
                }
            }
            if (getCurrentActiveLinksNbInput(EConnectionType.FLOW_MAIN) == 0 && noSchema) {
                if ((getCurrentActiveLinksNbOutput(EConnectionType.FLOW_MAIN) > 0) || (getCurrentActiveLinksNbOutput(EConnectionType.FLOW_REF) > 0)) {
                    String errorMessage = Messages.getString("String_Node_Str");
                    Problems.add(ProblemStatus.ERROR, this, errorMessage);
                }
            }
        }
    }
    ICoreTisService service = null;
    if (GlobalServiceRegister.getDefault().isServiceRegistered(ICoreTisService.class)) {
        service = (ICoreTisService) GlobalServiceRegister.getDefault().getService(ICoreTisService.class);
    }
    if (mainConnector != null && !noSchema && canEditSchema) {
        if (getMetadataList() != null) {
            for (IMetadataTable meta : getMetadataList()) {
                if (meta == null) {
                    continue;
                }
                int nbDynamic = 0;
                for (IMetadataColumn col : meta.getListColumns()) {
                    if (col.getTalendType() != null && col.getTalendType().equals("String_Node_Str")) {
                        nbDynamic++;
                    }
                }
                if (!isJoblet()) {
                    if (nbDynamic > 1) {
                        String errorMessage = Messages.getString("String_Node_Str");
                        Problems.add(ProblemStatus.ERROR, this, errorMessage);
                    }
                    if (nbDynamic > 0 && service == null) {
                        String errorMessage = Messages.getString("String_Node_Str");
                        Problems.add(ProblemStatus.ERROR, this, errorMessage);
                    }
                    if (nbDynamic > 0 && service != null) {
                        if (!service.isSupportDynamicType(this.getComponent().getName())) {
                            String errorMessage = Messages.getString("String_Node_Str");
                            Problems.add(ProblemStatus.ERROR, this, errorMessage);
                        }
                    }
                }
            }
        }
    }
    if (mainConnector != null && !noSchema && (!canEditSchema || isExternalNode())) {
        if (mainConnector.isMultiSchema()) {
            if (getMetadataList() != null) {
                for (IMetadataTable meta : getMetadataList()) {
                    String componentName = this.getComponent().getName();
                    if (!componentName.equals("String_Node_Str") && meta.getListColumns().size() == 0 && !isCheckMultiSchemaForMSField() && checkSchemaForEBCDIC(meta)) {
                        String tableLabel = meta.getTableName();
                        if (meta.getLabel() != null) {
                            tableLabel = meta.getLabel();
                        }
                        String errorMessage = Messages.getString("String_Node_Str", tableLabel);
                        Problems.add(ProblemStatus.ERROR, this, errorMessage);
                    }
                }
            }
        }
    }
    schemaSynchronized = true;
    if ((component.isSchemaAutoPropagated() && getComponent().getName().equals("String_Node_Str")) && (getMetadataList().size() != 0)) {
        for (INodeConnector nodeConnector : mainConnectors) {
            INodeConnector actualConnector = nodeConnector;
            if (actualConnector != null) {
                int maxFlowInput = actualConnector.getMaxLinkInput();
                if (maxFlowInput <= 1 || getComponent().useLookup() || isELTComponent()) {
                    IMetadataTable inputMeta = null, outputMeta = getMetadataList().get(0);
                    if ((actualConnector.getMaxLinkInput() != 0) && (actualConnector.getMaxLinkOutput() != 0)) {
                        IConnection inputConnecion = null;
                        for (IConnection connection : inputs) {
                            if (connection.isActivate() && (connection.getLineStyle().equals(EConnectionType.FLOW_MAIN) || connection.getLineStyle().equals(EConnectionType.TABLE))) {
                                inputMeta = connection.getMetadataTable();
                                inputConnecion = connection;
                            }
                        }
                        if (inputMeta != null) {
                            if ((!outputMeta.sameMetadataAs(inputMeta, IMetadataColumn.OPTIONS_IGNORE_KEY | IMetadataColumn.OPTIONS_IGNORE_NULLABLE | IMetadataColumn.OPTIONS_IGNORE_COMMENT | IMetadataColumn.OPTIONS_IGNORE_PATTERN | IMetadataColumn.OPTIONS_IGNORE_DBCOLUMNNAME | IMetadataColumn.OPTIONS_IGNORE_DBTYPE | IMetadataColumn.OPTIONS_IGNORE_DEFAULT | IMetadataColumn.OPTIONS_IGNORE_BIGGER_SIZE))) {
                                if (!outputMeta.sameMetadataAs(inputMeta, IMetadataColumn.OPTIONS_NONE) && outputMeta.sameMetadataAs(inputMeta, IMetadataColumn.OPTIONS_IGNORE_LENGTH)) {
                                    String warningMessage = Messages.getString("String_Node_Str", inputConnecion.getName());
                                    Problems.add(ProblemStatus.WARNING, this, warningMessage);
                                } else {
                                    schemaSynchronized = false;
                                    String errorMessage = Messages.getString("String_Node_Str", inputConnecion.getName());
                                    Problems.add(ProblemStatus.ERROR, this, errorMessage);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    if ((component.isSchemaAutoPropagated() || getComponent().getComponentType() == EComponentType.JOBLET) && (getMetadataList().size() != 0)) {
        IConnection inputConnecion = null;
        INodeConnector nodeConn = getConnectorFromName(EConnectionType.FLOW_MAIN.getName());
        if (nodeConn != null) {
            int maxFlowInput = nodeConn.getMaxLinkInput();
            if (maxFlowInput <= 1 || getComponent().useLookup() || isELTComponent()) {
                IMetadataTable inputMeta = null, outputMeta = getMetadataList().get(0);
                for (IConnection connection : inputs) {
                    if (connection.isActivate() && (connection.getLineStyle().equals(EConnectionType.FLOW_MAIN) || connection.getLineStyle().equals(EConnectionType.TABLE))) {
                        inputMeta = connection.getMetadataTable();
                        inputConnecion = connection;
                    }
                }
                if (inputMeta != null) {
                    INodeConnector connector = getConnectorFromName(outputMeta.getAttachedConnector());
                    if (connector != null && ((connector.getMaxLinkInput() != 0 && connector.getMaxLinkOutput() != 0) || getComponent().getComponentType() == EComponentType.JOBLET_INPUT_OUTPUT) && (!outputMeta.sameMetadataAs(inputMeta, IMetadataColumn.OPTIONS_IGNORE_KEY | IMetadataColumn.OPTIONS_IGNORE_NULLABLE | IMetadataColumn.OPTIONS_IGNORE_COMMENT | IMetadataColumn.OPTIONS_IGNORE_PATTERN | IMetadataColumn.OPTIONS_IGNORE_DBCOLUMNNAME | IMetadataColumn.OPTIONS_IGNORE_DBTYPE | IMetadataColumn.OPTIONS_IGNORE_DEFAULT | IMetadataColumn.OPTIONS_IGNORE_BIGGER_SIZE))) {
                        if (!outputMeta.sameMetadataAs(inputMeta, IMetadataColumn.OPTIONS_NONE) && outputMeta.sameMetadataAs(inputMeta, IMetadataColumn.OPTIONS_IGNORE_LENGTH)) {
                            String warningMessage = Messages.getString("String_Node_Str", inputConnecion.getName());
                            Problems.add(ProblemStatus.WARNING, this, warningMessage);
                        } else {
                            schemaSynchronized = false;
                            String errorMessage = Messages.getString("String_Node_Str", inputConnecion.getName());
                            Problems.add(ProblemStatus.ERROR, this, errorMessage);
                        }
                    }
                }
                if (outputMeta != null) {
                    for (int i = 0; i < outputMeta.getListColumns().size(); i++) {
                        IMetadataColumn column = outputMeta.getListColumns().get(i);
                        String sourceType = column.getType();
                        String typevalue = column.getTalendType();
                        String currentDbmsId = outputMeta.getDbms();
                        if (currentDbmsId != null && !TypesManager.checkDBType(currentDbmsId, typevalue, sourceType)) {
                            String errorMessage = "String_Node_Str";
                            Problems.add(ProblemStatus.WARNING, this, errorMessage);
                        }
                    }
                }
            }
        } else {
            for (IElementParameter param : this.getElementParameters()) {
                if (param.isShow(getElementParameters()) && param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE)) {
                    IMetadataTable table = getMetadataFromConnector(param.getContext());
                    IElementParameter connParam = param.getChildParameters().get(EParameterName.CONNECTION.getName());
                    if (table != null && connParam != null && !StringUtils.isEmpty((String) connParam.getValue())) {
                        for (IConnection connection : inputs) {
                            if (connection.isActivate() && connection.getName().equals(connParam.getValue())) {
                                if (!table.sameMetadataAs(connection.getMetadataTable(), IMetadataColumn.OPTIONS_IGNORE_KEY | IMetadataColumn.OPTIONS_IGNORE_NULLABLE | IMetadataColumn.OPTIONS_IGNORE_COMMENT | IMetadataColumn.OPTIONS_IGNORE_PATTERN | IMetadataColumn.OPTIONS_IGNORE_DBCOLUMNNAME | IMetadataColumn.OPTIONS_IGNORE_DBTYPE | IMetadataColumn.OPTIONS_IGNORE_DEFAULT | IMetadataColumn.OPTIONS_IGNORE_BIGGER_SIZE)) {
                                    schemaSynchronized = false;
                                    String errorMessage = Messages.getString("String_Node_Str", connection.getName());
                                    Problems.add(ProblemStatus.ERROR, this, errorMessage);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    if (component.useMerge() && !this.getConnectorFromType(EConnectionType.FLOW_MERGE).isMergeAllowDifferentSchema()) {
        if (getMetadataList().get(0).getListColumns().size() == 0) {
            String errorMessage = Messages.getString("String_Node_Str");
            Problems.add(ProblemStatus.ERROR, this, errorMessage);
        } else {
            if (inputs.size() > 0) {
                IMetadataTable firstSchema = inputs.get(0).getMetadataTable();
                boolean isSame = firstSchema.sameMetadataAs(getMetadataList().get(0));
                if (!isSame) {
                    String warningMessage = Messages.getString("String_Node_Str", getUniqueName());
                    Problems.add(ProblemStatus.WARNING, this, warningMessage);
                }
            }
        }
        if (inputs.size() > 1) {
            IMetadataTable firstSchema = inputs.get(0).getMetadataTable();
            boolean isSame = true;
            for (int i = 1; i < inputs.size(); i++) {
                if (!firstSchema.sameMetadataAs(inputs.get(i).getMetadataTable(), IMetadataColumn.OPTIONS_IGNORE_DBCOLUMNNAME | IMetadataColumn.OPTIONS_IGNORE_DEFAULT | IMetadataColumn.OPTIONS_IGNORE_COMMENT | IMetadataColumn.OPTIONS_IGNORE_DBTYPE)) {
                    isSame = false;
                    break;
                }
            }
            if (!isSame) {
                String warningMessage = Messages.getString("String_Node_Str", getUniqueName());
                Problems.add(ProblemStatus.WARNING, this, warningMessage);
            }
        }
    }
    syncSpecialSchema();
}

Output:
                         String currentDbmsId = outputMeta.getDbms();
-                        if (currentDbmsId != null && !TypesManager.checkDBType(currentDbmsId, typevalue, sourceType)) {
+                        if (!typevalue.equals("String_Node_Str") && currentDbmsId != null && !TypesManager.checkDBType(currentDbmsId, typevalue, sourceType)) {
                             String errorMessage = "String_Node_Str";


Input:
private void queueEvents(final E state) {
    for (final Request event : this.messages.get(state)) {
        EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), event.getCallback().toString()).debug();
        if (event.getCallback() instanceof BroadcastCallback) {
            final BroadcastCallback callback = (BroadcastCallback) event.getCallback();
            this.pendingEvents.addAll(Lists.transform(Clusters.getInstance().listValues(), new Function<Cluster, CheckedListenableFuture>() {
                public CheckedListenableFuture apply(final Cluster c) {
                    EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), c.getName(), event.getClass().getSimpleName(), event.getRequest().toSimpleString()).info();
                    EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), c.getName(), event.getClass().getSimpleName(), event.getRequest()).debug();
                    final Request request = AsyncRequests.newRequest(callback.newInstance());
                    request.getRequest().regardingUserRequest(callback.getRequest());
                    return request.dispatch(c.getConfiguration());
                }
            }));
        } else {
            EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), this.cluster.getName(), event.getClass().getSimpleName(), event.getRequest().toSimpleString()).info();
            EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), this.cluster.getName(), event.getClass().getSimpleName(), event.getRequest()).debug();
            this.pendingEvents.add(event.dispatch(this.cluster.getConfiguration()));
        }
    }
}

Output:
         } else {
-            EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), this.cluster.getName(), event.getClass().getSimpleName(), event.getRequest().toSimpleString()).info();
-            EventRecord.caller(StatefulMessageSet.class, EventType.VM_STARTING, state.name(), this.cluster.getName(), event.getClass().getSimpleName(), event.getRequest()).debug();
+            LOG.debug("String_Node_Str" + state.name() + "String_Node_Str" + this.cluster.getName() + "String_Node_Str" + event.getClass().getSimpleName() + "String_Node_Str" + event.getCallback());
             this.pendingEvents.add(event.dispatch(this.cluster.getConfiguration()));


Input:
public boolean matches(TokenCredentials tokenCredentials) {
    String tk = tokenCredentials.getToken();
    int pos = tk.lastIndexOf(DELIM);
    if (pos > -1) {
        tk = tk.substring(pos + 1);
    }
    if (key == null || !PasswordUtil.isSame(key, getKeyValue(tk, userId))) {
        return false;
    }
    for (String name : mandatoryAttributes.keySet()) {
        String expectedValue = mandatoryAttributes.get(name);
        if (!expectedValue.equals(tokenCredentials.getAttribute(name))) {
            return false;
        }
    }
    Collection<String> attrNames = Arrays.asList(tokenCredentials.getAttributeNames());
    for (String name : publicAttributes.keySet()) {
        if (!attrNames.contains(name)) {
            tokenCredentials.setAttribute(name, publicAttributes.get(name).toString());
        }
    }
    return true;
}

Output:
     }
-    for (String name : mandatoryAttributes.keySet()) {
-        String expectedValue = mandatoryAttributes.get(name);
+    for (Map.Entry<String, String> mandatory : mandatoryAttributes.entrySet()) {
+        String name = mandatory.getKey();
+        String expectedValue = mandatory.getValue();
         if (!expectedValue.equals(tokenCredentials.getAttribute(name))) {


Input:
public boolean isItemValid(ItemStack compareStack) {
    for (ItemStack itemStack : itemStacks) {
        if (compareStack.isItemEqual(itemStack)) {
            return true;
        }
    }
    return false;
}

Output:
     for (ItemStack itemStack : itemStacks) {
-        if (compareStack.isItemEqual(itemStack)) {
+        if (compareStack.isItemEqual(itemStack) || (!this.isMetadataSensitive && compareStack.itemID == itemStack.itemID)) {
             return true;


Input:
public static void updateComponentSchema(ComponentProperties componentProperties, String schemaPropertyName, IMetadataTable metadataTable, IElementParameter param) {
    if (componentProperties == null || schemaPropertyName == null || metadataTable == null) {
        return;
    }
    Schema schema = convertTalendSchemaIntoComponentSchema(ConvertionHelper.convert(metadataTable));
    componentProperties.setValue(schemaPropertyName, schema);
    Map<String, String> additionalProperties = metadataTable.getAdditionalProperties();
    additionalProperties.put(IComponentConstants.COMPONENT_PROPERTIES_TAG, componentProperties.toSerialized());
    additionalProperties.put(IComponentConstants.COMPONENT_SCHEMA_TAG, schemaPropertyName);
    if (param != null) {
        param.setValue(schema.toString());
    }
}

Output:
     Schema schema = convertTalendSchemaIntoComponentSchema(ConvertionHelper.convert(metadataTable));
-    componentProperties.setValue(schemaPropertyName, schema);
-    Map<String, String> additionalProperties = metadataTable.getAdditionalProperties();
-    additionalProperties.put(IComponentConstants.COMPONENT_PROPERTIES_TAG, componentProperties.toSerialized());
-    additionalProperties.put(IComponentConstants.COMPONENT_SCHEMA_TAG, schemaPropertyName);
-    if (param != null) {
-        param.setValue(schema.toString());
+    INodeConnector connector = node.getConnectorFromName(metadataTable.getAttachedConnector());
+    if (connector != null && connector instanceof GenericNodeConnector) {
+        node.getComponentProperties().setConnectedSchema(((GenericNodeConnector) connector).getComponentConnector(), schema, true);
+        for (IElementParameter param : node.getElementParameters()) {
+            if (EParameterFieldType.SCHEMA_REFERENCE.equals(param.getFieldType()) && connector.getName().equals(param.getContext())) {
+                param.setValue(schema);
+            }
+        }
     }


Input:
private int search(String key) throws IOException {
    if (!checkActive()) {
        return -1;
    }
    String target = external2internal(key);
    int total = getCardinality();
    int low = -1;
    int high = total;
    while (high - low > 1) {
        int mid = (low + high) >>> 1;
        if (normalizeForSearch(getEntry(key, mid).getKey()).compareTo(target) < 0) {
            low = mid;
        } else {
            high = mid;
        }
    }
    if (high < total && normalizeForSearch(getEntry(key, high).getKey()).compareTo(target) == 0) {
        return high;
    }
    if (normalizeForSearch(getEntry(key, 0).getKey()).compareTo(target) == 0) {
        return 0;
    }
    return -(high - 1);
}

Output:
     }
-    return -(high - 1);
+    return -(high + 1);
 }


Input:
public void onClick(View view) {
    FragmentManager fm = getSupportFragmentManager();
    ChoosePlaceDialogFragment choosePlaceDialogFragment = ChoosePlaceDialogFragment.newInstance(city.id);
    choosePlaceDialogFragment.show(fm, ChoosePlaceDialogFragment.class.getName());
}

Output:
 public void onClick(View view) {
-    FragmentManager fm = getSupportFragmentManager();
-    ChoosePlaceDialogFragment choosePlaceDialogFragment = ChoosePlaceDialogFragment.newInstance(city.id);
-    choosePlaceDialogFragment.show(fm, ChoosePlaceDialogFragment.class.getName());
+    chooseRegion();
 }


Input:
private String getInputName(StructureMapGroupComponent g, StructureMapInputMode mode, String def) throws DefinitionException {
    String name = null;
    for (StructureMapGroupInputComponent inp : g.getInput()) {
        if (inp.getMode() == mode)
            if (name == null)
                throw new DefinitionException("String_Node_Str");
            else
                name = g.getName();
    }
    return name == null ? def : name;
}

Output:
         if (inp.getMode() == mode)
-            if (name == null)
+            if (name != null)
                 throw new DefinitionException("String_Node_Str");


Input:
public String getColumnName(int index) throws BirtException {
    index = getColumnIndex(index);
    MetaDataEntry entry = (MetaDataEntry) metaEntries.get(index);
    return entry.name;
}

Output:
     index = getColumnIndex(index);
-    MetaDataEntry entry = (MetaDataEntry) metaEntries.get(index);
-    return entry.name;
+    if (null != parentMetaData) {
+        return parentMetaData.getColumnName(index);
+    } else {
+        MetaDataEntry entry = (MetaDataEntry) metaEntries.get(index);
+        return entry.name;
+    }
 }


Input:
protected void endPrefixMappings(Element elem) throws SAXException {
    NamedNodeMap attrs = elem.getAttributes();
    int numOfAtts = attrs.getLength();
    for (int i = 0; i < numOfAtts; i++) {
        Attr next = (Attr) attrs.item(i);
        String attrPrefix = next.getPrefix();
        if (attrPrefix != null && attrPrefix.equals(XMLConstants.XMLNS)) {
            getContentHandler().endPrefixMapping(next.getLocalName());
        } else if (attrPrefix == null) {
            String name = next.getLocalName();
            if (name == null) {
                name = next.getNodeName();
            }
            if (name != null) {
                getContentHandler().endPrefixMapping(XMLConstants.EMPTY_STRING);
            }
        }
    }
}

Output:
     NamedNodeMap attrs = elem.getAttributes();
-    int numOfAtts = attrs.getLength();
-    for (int i = 0; i < numOfAtts; i++) {
+    for (int i = 0, numOfAtts = attrs.getLength(); i < numOfAtts; i++) {
         Attr next = (Attr) attrs.item(i);


Input:
public void handleKey(SelectionKey key) {
    if (key.isValid() && key.isConnectable()) {
        PendingConnect data = (PendingConnect) key.attachment();
        Peer peer = data.peer;
        System.out.println("String_Node_Str" + peer.getHash());
        SocketChannel channel = (SocketChannel) key.channel();
        ConnectionHandler handler = new ConnectionHandler(peer, channel, key);
        try {
            if (channel.finishConnect()) {
                key.interestOps((key.interestOps() | SelectionKey.OP_READ) & ~SelectionKey.OP_CONNECT);
                key.attach(handler);
                peer.connectionOpened();
            } else {
                peer.destroy();
            }
        } catch (Exception e) {
            Log.warn("String_Node_Str", channel.socket().getRemoteSocketAddress());
            peer.destroy();
        }
    } else if (key.isValid() && key.isAcceptable()) {
        SocketChannel socketChannel = null;
        Peer peer = null;
        try {
            socketChannel = serverSocketChannel.accept();
            InetSocketAddress socketAddress = (InetSocketAddress) socketChannel.getRemoteAddress();
            if (!allowConnection(socketAddress)) {
                socketChannel.close();
                return;
            }
            socketChannel.configureBlocking(false);
            SelectionKey newKey = socketChannel.register(selector, SelectionKey.OP_READ);
            new Peer(network, Peer.IN, socketAddress);
            peersManager.addPeerToGroup(NetworkConstant.Network_Peer_In_Group, peer);
            ConnectionHandler handler = new ConnectionHandler(peer, socketChannel, newKey);
            newKey.attach(handler);
            peer.connectionOpened();
        } catch (Exception e) {
            if (socketChannel != null) {
                Log.warn("String_Node_Str", socketChannel.socket().getRemoteSocketAddress());
                try {
                    socketChannel.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (peer != null) {
                peer.destroy();
            }
        }
    } else {
        ConnectionHandler handler = (ConnectionHandler) key.attachment();
        if (handler != null) {
            ConnectionHandler.handleKey(key);
        }
    }
}

Output:
             new Peer(network, Peer.IN, socketAddress);
-            peersManager.addPeerToGroup(NetworkConstant.Network_Peer_In_Group, peer);
+            peersManager.addPeerToGroup(NetworkConstant.NETWORK_PEER_IN_GROUP, peer);
             ConnectionHandler handler = new ConnectionHandler(peer, socketChannel, newKey);


Input:
public String getInterfaceLanguagePreference(XWikiContext context) {
    String language = "String_Node_Str", requestLanguage = "String_Node_Str", userPreferenceLanguage = "String_Node_Str", navigatorLanguage = "String_Node_Str", cookieLanguage = "String_Node_Str", contextLanguage = "String_Node_Str";
    boolean setCookie = false;
    if (!context.getWiki().isMultiLingual(context)) {
        language = Util.normalizeLanguage(context.getWiki().getXWikiPreference("String_Node_Str", "String_Node_Str", context));
        context.setInterfaceLanguage(language);
        return language;
    }
    try {
        requestLanguage = Util.normalizeLanguage(context.getRequest().getParameter("String_Node_Str"));
    } catch (Exception ex) {
    }
    contextLanguage = context.getInterfaceLanguage();
    try {
        String user = context.getUser();
        XWikiDocument userdoc = null;
        userdoc = getDocument(user, context);
        if (userdoc != null) {
            userPreferenceLanguage = userdoc.getStringValue("String_Node_Str", "String_Node_Str");
        }
    } catch (XWikiException e) {
    }
    if (context.getRequest() != null) {
        String accept = context.getRequest().getHeader("String_Node_Str");
        if ((accept != null) && (!accept.equals("String_Node_Str"))) {
            String[] alist = StringUtils.split(accept, "String_Node_Str");
            if ((alist != null) && !(alist.length == 0)) {
                context.setLanguage(alist[0]);
                navigatorLanguage = alist[0];
            }
        }
    }
    try {
        cookieLanguage = Util.normalizeLanguage(getUserPreferenceFromCookie("String_Node_Str", context));
    } catch (Exception e) {
    }
    if ((requestLanguage != null) && (!requestLanguage.equals("String_Node_Str"))) {
        if (requestLanguage.equals("String_Node_Str")) {
            setCookie = true;
        } else {
            language = requestLanguage;
            context.setLanguage(language);
            Cookie cookie = new Cookie("String_Node_Str", language);
            cookie.setMaxAge(60 * 60 * 24 * 365 * 10);
            cookie.setPath("String_Node_Str");
            context.getResponse().addCookie(cookie);
            return language;
        }
    }
    if (contextLanguage != null && contextLanguage != "String_Node_Str") {
        language = contextLanguage;
    } else if (cookieLanguage != null && cookieLanguage != "String_Node_Str") {
        language = cookieLanguage;
    } else if (userPreferenceLanguage != null && userPreferenceLanguage != "String_Node_Str") {
        language = userPreferenceLanguage;
    } else if (navigatorLanguage != null && navigatorLanguage != "String_Node_Str") {
        language = navigatorLanguage;
    }
    context.setLanguage(language);
    if (setCookie) {
        Cookie cookie = new Cookie("String_Node_Str", language);
        cookie.setMaxAge(60 * 60 * 24 * 365 * 10);
        cookie.setPath("String_Node_Str");
        context.getResponse().addCookie(cookie);
    }
    return language;
}

Output:
         language = contextLanguage;
-    } else if (cookieLanguage != null && cookieLanguage != "String_Node_Str") {
+    } else if (StringUtils.isNotEmpty(cookieLanguage)) {
         language = cookieLanguage;


Input:
IDataQueryDefinition createQuery(ExtendedItemHandle handle, IDataQueryDefinition parent) throws BirtException {
    IModelAdapter modelAdapter = context.getDataRequestSession().getModelAdaptor();
    if (handle.getDataSet() != null || (handle.getCube() == null && parent instanceof IBaseQueryDefinition)) {
        ReportItemHandle itemHandle = null;
        if (ChartItemUtil.isChartInheritGroups(handle)) {
            DesignElementHandle container = handle.getContainer();
            while (container != null) {
                if (container instanceof ListingHandle) {
                    itemHandle = (ListingHandle) container;
                    return new ChartSharingQueryHelper(handle, cm, modelAdapter).createQuery(parent);
                }
                container = container.getContainer();
            }
        } else {
            itemHandle = ChartItemUtil.getReportItemReference(handle);
        }
        if (itemHandle != null) {
            return new ChartSharingQueryHelper(itemHandle, cm, modelAdapter).createQuery(parent);
        }
        return new ChartBaseQueryHelper(handle, cm, modelAdapter).createBaseQuery(parent);
    } else if (handle.getCube() != null || parent instanceof ICubeQueryDefinition) {
        if (handle.getContainer() instanceof MultiViewsHandle) {
            ExtendedItemHandle bindingHandle = (ExtendedItemHandle) ChartItemUtil.getReportItemReference(handle);
            IDataQueryDefinition cubeQuery = CrosstabQueryUtil.createCubeQuery((CrosstabReportItemHandle) bindingHandle.getReportItem(), parent, true, true, true, true, true, true);
            return cubeQuery;
        }
        return ChartReportItemUtil.instanceCubeQueryHelper(handle, cm, modelAdapter).createCubeQuery(parent);
    }
    return null;
}

Output:
             ExtendedItemHandle bindingHandle = (ExtendedItemHandle) ChartItemUtil.getReportItemReference(handle);
-            IDataQueryDefinition cubeQuery = CrosstabQueryUtil.createCubeQuery((CrosstabReportItemHandle) bindingHandle.getReportItem(), parent, true, true, true, true, true, true);
+            IDataQueryDefinition cubeQuery = CrosstabQueryUtil.createCubeQuery((CrosstabReportItemHandle) bindingHandle.getReportItem(), parent, modelAdapter, true, true, true, true, true, true);
             return cubeQuery;


Input:
public static void main(String[] args) throws IOException {
    File out = new File("String_Node_Str");
    if (out.exists()) {
        if (!out.delete()) {
            throw new RuntimeException("String_Node_Str" + out.getAbsolutePath());
        }
    }
    Path testFile = new Path(out.toURI());
    Configuration configuration = new Configuration();
    MessageType schema = new MessageType("String_Node_Str", new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.INT32, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.BINARY, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.BINARY, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.INT32, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.BINARY, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.DOUBLE, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.BINARY, "String_Node_Str"), new PrimitiveType(Repetition.OPTIONAL, PrimitiveTypeName.BINARY, "String_Node_Str"));
    MemPageStore pageStore = new MemPageStore(150000);
    ColumnWriteStoreImpl store = new ColumnWriteStoreImpl(pageStore, 20 * 1024, 1 * 1024, false);
    MessageColumnIO columnIO = new ColumnIOFactory(true).getColumnIO(schema);
    RecordConsumer recordWriter = columnIO.getRecordWriter(store);
    int recordCount = 0;
    for (int i = 0; i < 150000; i++) {
        recordWriter.startMessage();
        writeField(recordWriter, 0, "String_Node_Str", i % 10 == 0 ? null : i);
        writeField(recordWriter, 1, "String_Node_Str", i % 11 == 0 ? null : "String_Node_Str" + i);
        writeField(recordWriter, 2, "String_Node_Str", i % 12 == 0 ? null : "String_Node_Str" + i);
        writeField(recordWriter, 3, "String_Node_Str", i % 13 == 0 ? null : i);
        writeField(recordWriter, 4, "String_Node_Str", i % 14 == 0 ? null : "String_Node_Str" + i);
        writeField(recordWriter, 5, "String_Node_Str", i % 15 == 0 ? null : 1.2d * i);
        writeField(recordWriter, 6, "String_Node_Str", i % 16 == 0 ? null : "String_Node_Str" + i);
        writeField(recordWriter, 7, "String_Node_Str", i % 17 == 0 ? null : "String_Node_Str" + i);
        recordWriter.endMessage();
        ++recordCount;
    }
    store.flush();
    System.out.printf("String_Node_Str", store.memSize(), store.maxColMemSize(), store.allocatedSize());
    System.out.println(store.memUsageString());
    writeToFile(testFile, configuration, schema, pageStore, recordCount);
    try {
        readTestFile(testFile, configuration);
    } catch (Exception e) {
        LOG.error("String_Node_Str", e);
    }
}

Output:
     MemPageStore pageStore = new MemPageStore(150000);
-    ColumnWriteStoreImpl store = new ColumnWriteStoreImpl(pageStore, 20 * 1024, 1 * 1024, false);
+    ColumnWriteStoreImpl store = new ColumnWriteStoreImpl(pageStore, 20 * 1024, 1 * 1024, 20 * 1024, false);
     MessageColumnIO columnIO = new ColumnIOFactory(true).getColumnIO(schema);


Input:
protected void readMovieFromNfoFile(File nfoFile) {
    FileInputStream fisTargetFile = null;
    try {
        fisTargetFile = new FileInputStream(nfoFile);
        String targetFileStr = IOUtils.toString(fisTargetFile, "String_Node_Str");
        if (targetFileStr.contains("String_Node_Str")) {
            while (targetFileStr.length() > 0 && !targetFileStr.startsWith("String_Node_Str")) {
                if (targetFileStr.length() > 1) {
                    targetFileStr = targetFileStr.substring(1, targetFileStr.length());
                } else
                    break;
            }
        }
        XbmcXmlMovieBean xmlMovieBean = XbmcXmlMovieBean.makeFromXML(targetFileStr);
        if (xmlMovieBean != null) {
            Movie movieFromNfo = xmlMovieBean.toMovie();
            guiMain.movieToWriteToDiskList.add(movieFromNfo);
            if (guiMain.getCurrentlySelectedPosterFileList().get(0).exists()) {
                Thumb[] currentPosters = guiMain.movieToWriteToDiskList.get(0).getPosters();
                Thumb fileFromDisk;
                if (currentPosters.length > 0 && currentPosters[0] != null && currentPosters[0].getThumbURL() != null)
                    fileFromDisk = new Thumb(guiMain.getCurrentlySelectedPosterFileList().get(0), currentPosters[0].getThumbURL().toString());
                else {
                    fileFromDisk = new Thumb(guiMain.getCurrentlySelectedPosterFileList().get(0));
                    currentPosters = new Thumb[1];
                }
                currentPosters[0] = fileFromDisk;
            } else if (guiMain.movieToWriteToDiskList.get(0).hasPoster()) {
            }
        }
    } catch (FileNotFoundException e) {
        JOptionPane.showMessageDialog(null, ExceptionUtils.getStackTrace(e), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(null, ExceptionUtils.getStackTrace(e), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
    } finally {
        try {
            fisTargetFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            guiMain.updateAllFieldsOfFileDetailPanel(false, false);
        }
    }
}

Output:
                 Thumb[] currentPosters = guiMain.movieToWriteToDiskList.get(0).getPosters();
-                Thumb fileFromDisk;
-                if (currentPosters.length > 0 && currentPosters[0] != null && currentPosters[0].getThumbURL() != null)
-                    fileFromDisk = new Thumb(guiMain.getCurrentlySelectedPosterFileList().get(0), currentPosters[0].getThumbURL().toString());
-                else {
-                    fileFromDisk = new Thumb(guiMain.getCurrentlySelectedPosterFileList().get(0));
-                    currentPosters = new Thumb[1];
+                File currentPosterFile = guiMain.getCurrentlySelectedPosterFileList().get(0);
+                Thumb thumbFromDisk;
+                if (currentPosterFile != null) {
+                    if (currentPosters.length > 0 && guiMain.getCurrentlySelectedPosterFileList().size() > 0 && currentPosters[0] != null && currentPosters[0].getThumbURL() != null)
+                        thumbFromDisk = new Thumb(guiMain.getCurrentlySelectedPosterFileList().get(0), currentPosters[0].getThumbURL().toString());
+                    else {
+                        thumbFromDisk = new Thumb(guiMain.getCurrentlySelectedPosterFileList().get(0));
+                        currentPosters = new Thumb[1];
+                    }
+                    currentPosters[0] = thumbFromDisk;
                 }


Input:
void addToFrom(SqlQuery query, RolapLevel level, RolapCube cube) {
    if (xmlHierarchy == null) {
        throw Util.newError("String_Node_Str" + getUniqueName() + "String_Node_Str");
    }
    final boolean failIfExists = false;
    if (cube != null) {
        HierarchyUsage hierarchyUsage = getSchema().getUsage(this, cube);
        query.addFrom(cube.getFact(), failIfExists);
        query.addFrom(hierarchyUsage.primaryKeyTable, failIfExists);
        query.addWhere(query.quoteIdentifier(cube.getAlias(), hierarchyUsage.foreignKey) + "String_Node_Str" + query.quoteIdentifier(hierarchyUsage.primaryKeyTable.getAlias(), hierarchyUsage.primaryKey));
    }
    MondrianDef.Relation relation = xmlHierarchy.relation;
    if (relation instanceof MondrianDef.Join) {
        MondrianDef.Join join = (MondrianDef.Join) relation;
        if (level != null) {
            relation = relationSubset(relation, level.nameExp.getTableAlias());
        }
    }
    query.addFrom(relation, failIfExists);
}

Output:
     if (relation instanceof MondrianDef.Join) {
-        MondrianDef.Join join = (MondrianDef.Join) relation;
-        if (level != null) {
-            relation = relationSubset(relation, level.nameExp.getTableAlias());
+        if (expression != null) {
+            relation = relationSubset(relation, expression.getTableAlias());
         }


Input:
private int block() throws HU01Exception {
    ByteBuffer b = buffer.slice();
    b.order(buffer.order());
    if (b.remaining() < 20) {
        return 0;
    }
    int magic = b.getInt(0);
    if (magic != SCBH_MAGIC) {
        char[] chars = new char[] { (char) (magic & 0xff), (char) ((magic >> 8) & 0xff), (char) ((magic >> 16) & 0xff), (char) ((magic >> 24) & 0xff) };
        throw new HU01Exception("String_Node_Str" + new String(chars) + "String_Node_Str");
    }
    int headerSize = b.getInt(4);
    int decompressedBlockSize = b.getInt(8);
    long crc = b.getInt(12) & 0xffffffffL;
    int compressedBlockSize = b.getInt(16);
    if (b.remaining() < headerSize + compressedBlockSize) {
        return 0;
    }
    if (decoded == null || decoded.capacity() < decompressedBlockSize) {
        decoded = allocateBuffer(decompressedBlockSize);
    }
    decoded.clear();
    if (compressedBlockSize == decompressedBlockSize && decompressedBlockSize < TABLE_SIZE) {
        b.position(headerSize);
        b.limit(headerSize + compressedBlockSize);
        decoded.put(b);
    } else {
        b.position(headerSize);
        b.limit(b.position() + TABLE_SIZE);
        if (!HU01.build_decompression_table(b.slice(), table)) {
            throw new HU01Exception("String_Node_Str");
        }
        b.position(headerSize + TABLE_SIZE);
        b.limit(headerSize + compressedBlockSize);
        HU01.decompress_hu01_block(b.slice(), table, decoded);
    }
    decoded.position(0);
    decoded.limit(decompressedBlockSize);
    buffer.position(buffer.position() + headerSize + compressedBlockSize);
    CRC32 crc32 = new CRC32();
    crc32.update(decoded.array(), decoded.position(), decoded.limit());
    if (crc32.getValue() != crc) {
        throw new HU01Exception("String_Node_Str" + Long.toHexString(crc) + "String_Node_Str" + Long.toHexString(crc32.getValue()) + "String_Node_Str");
    }
    return decompressedBlockSize;
}

Output:
     decoded.clear();
-    if (compressedBlockSize == decompressedBlockSize && decompressedBlockSize < TABLE_SIZE) {
+    if (compressedBlockSize == decompressedBlockSize && decompressedBlockSize < 2048) {
         b.position(headerSize);


Input:
public void handleCommand(ChannelUID channelUID, Command command) {
    logger.debug("String_Node_Str", channelUID, command);
    if (command instanceof RefreshType) {
        return;
    }
    if (dscAlarmBridgeHandler != null && dscAlarmBridgeHandler.isConnected() && channelUID.getId() == ZONE_BYPASS_MODE) {
        if (command == OnOffType.OFF) {
            String data = String.valueOf(getPartitionNumber()) + "String_Node_Str" + String.format("String_Node_Str", getZoneNumber()) + "String_Node_Str";
            dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.KeySequence, data);
        } else if (command == OnOffType.ON) {
            String data = String.valueOf(getPartitionNumber()) + "String_Node_Str" + String.format("String_Node_Str", getZoneNumber()) + "String_Node_Str";
            dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.KeySequence, data);
        }
    }
}

Output:
     }
-    if (dscAlarmBridgeHandler != null && dscAlarmBridgeHandler.isConnected() && channelUID.getId() == ZONE_BYPASS_MODE) {
-        if (command == OnOffType.OFF) {
-            String data = String.valueOf(getPartitionNumber()) + "String_Node_Str" + String.format("String_Node_Str", getZoneNumber()) + "String_Node_Str";
-            dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.KeySequence, data);
-        } else if (command == OnOffType.ON) {
-            String data = String.valueOf(getPartitionNumber()) + "String_Node_Str" + String.format("String_Node_Str", getZoneNumber()) + "String_Node_Str";
-            dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.KeySequence, data);
-        }
+    if (dscAlarmBridgeHandler != null && dscAlarmBridgeHandler.isConnected() && channelUID.getId().equals(ZONE_BYPASS_MODE)) {
+        String data = String.valueOf(getPartitionNumber()) + "String_Node_Str" + String.format("String_Node_Str", getZoneNumber()) + "String_Node_Str";
+        dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.KeySequence, data);
     }


Input:
protected void handleRequest(RequestTypeEnum theRequestType, HttpServletRequest theRequest, HttpServletResponse theResponse) throws ServletException, IOException {
    for (IServerInterceptor next : myInterceptors) {
        boolean continueProcessing = next.incomingRequestPreProcessed(theRequest, theResponse);
        if (!continueProcessing) {
            ourLog.debug("String_Node_Str");
            return;
        }
    }
    String fhirServerBase = null;
    boolean requestIsBrowser = requestIsBrowser(theRequest);
    RequestDetails requestDetails = new RequestDetails();
    requestDetails.setServer(this);
    requestDetails.setRequestType(theRequestType);
    requestDetails.setServletRequest(theRequest);
    requestDetails.setServletResponse(theResponse);
    try {
        String resourceName = null;
        String requestFullPath = StringUtils.defaultString(theRequest.getRequestURI());
        String servletPath = StringUtils.defaultString(theRequest.getServletPath());
        StringBuffer requestUrl = theRequest.getRequestURL();
        String servletContextPath = "String_Node_Str";
        if (getServletContext() != null) {
            servletContextPath = StringUtils.defaultString(getServletContext().getContextPath());
        }
        if (ourLog.isTraceEnabled()) {
            ourLog.trace("String_Node_Str", requestFullPath);
            ourLog.trace("String_Node_Str", servletPath);
            ourLog.trace("String_Node_Str", requestUrl);
            ourLog.trace("String_Node_Str", servletContextPath);
        }
        IdDt id = null;
        String operation = null;
        String compartment = null;
        String requestPath = getRequestPath(requestFullPath, servletContextPath, servletPath);
        if (requestPath.length() > 0 && requestPath.charAt(0) == '/') {
            requestPath = requestPath.substring(1);
        }
        fhirServerBase = getServerBaseForRequest(theRequest);
        String completeUrl = StringUtils.isNotBlank(theRequest.getQueryString()) ? requestUrl + "String_Node_Str" + theRequest.getQueryString() : requestUrl.toString();
        Map<String, String[]> params = new HashMap<String, String[]>(theRequest.getParameterMap());
        requestDetails.setParameters(params);
        StringTokenizer tok = new StringTokenizer(requestPath, "String_Node_Str");
        if (tok.hasMoreTokens()) {
            resourceName = tok.nextToken();
            if (partIsOperation(resourceName)) {
                operation = resourceName;
                resourceName = null;
            }
        }
        requestDetails.setResourceName(resourceName);
        ResourceBinding resourceBinding = null;
        BaseMethodBinding<?> resourceMethod = null;
        if (Constants.URL_TOKEN_METADATA.equals(resourceName) || theRequestType == RequestTypeEnum.OPTIONS) {
            resourceMethod = myServerConformanceMethod;
        } else if (resourceName == null) {
            resourceBinding = myServerBinding;
        } else {
            resourceBinding = myResourceNameToBinding.get(resourceName);
            if (resourceBinding == null) {
                throw new InvalidRequestException("String_Node_Str" + resourceName + "String_Node_Str" + myResourceNameToBinding.keySet());
            }
        }
        if (tok.hasMoreTokens()) {
            String nextString = tok.nextToken();
            if (partIsOperation(nextString)) {
                operation = nextString;
            } else {
                id = new IdDt(resourceName, UrlUtil.unescape(nextString));
            }
        }
        if (tok.hasMoreTokens()) {
            String nextString = tok.nextToken();
            if (nextString.equals(Constants.PARAM_HISTORY)) {
                if (tok.hasMoreTokens()) {
                    String versionString = tok.nextToken();
                    if (id == null) {
                        throw new InvalidRequestException("String_Node_Str" + requestPath);
                    }
                    id = new IdDt(resourceName, id.getIdPart(), UrlUtil.unescape(versionString));
                } else {
                    operation = Constants.PARAM_HISTORY;
                }
            } else if (partIsOperation(nextString)) {
                if (operation != null) {
                    throw new InvalidRequestException("String_Node_Str" + requestPath);
                }
                operation = nextString;
            } else {
                compartment = nextString;
            }
        }
        String secondaryOperation = null;
        while (tok.hasMoreTokens()) {
            String nextString = tok.nextToken();
            if (operation == null) {
                operation = nextString;
            } else if (secondaryOperation == null) {
                secondaryOperation = nextString;
            } else {
                throw new InvalidRequestException("String_Node_Str" + nextString + "String_Node_Str" + requestPath);
            }
        }
        if (theRequestType == RequestTypeEnum.PUT) {
            String contentLocation = theRequest.getHeader(Constants.HEADER_CONTENT_LOCATION);
            if (contentLocation != null) {
                id = new IdDt(contentLocation);
            }
        }
        requestDetails.setId(id);
        requestDetails.setOperation(operation);
        requestDetails.setSecondaryOperation(secondaryOperation);
        requestDetails.setCompartmentName(compartment);
        String acceptEncoding = theRequest.getHeader(Constants.HEADER_ACCEPT_ENCODING);
        boolean respondGzip = false;
        if (acceptEncoding != null) {
            String[] parts = acceptEncoding.trim().split("String_Node_Str");
            for (String string : parts) {
                if (string.equals("String_Node_Str")) {
                    respondGzip = true;
                }
            }
        }
        requestDetails.setRespondGzip(respondGzip);
        requestDetails.setRequestPath(requestPath);
        requestDetails.setFhirServerBase(fhirServerBase);
        requestDetails.setCompleteUrl(completeUrl);
        String pagingAction = theRequest.getParameter(Constants.PARAM_PAGINGACTION);
        if (getPagingProvider() != null && isNotBlank(pagingAction)) {
            requestDetails.setOtherOperationType(OtherOperationTypeEnum.GET_PAGE);
            if (theRequestType != RequestTypeEnum.GET) {
                throw new InvalidRequestException(getFhirContext().getLocalizer().getMessage(RestfulServer.class, "String_Node_Str"));
            }
            handlePagingRequest(requestDetails, theResponse, pagingAction);
            return;
        }
        if (resourceMethod == null) {
            if (resourceBinding != null) {
                resourceMethod = resourceBinding.getMethod(requestDetails);
            }
        }
        if (resourceMethod == null) {
            if (isBlank(requestPath)) {
                throw new InvalidRequestException(myFhirContext.getLocalizer().getMessage(RestfulServer.class, "String_Node_Str"));
            } else {
                throw new InvalidRequestException(myFhirContext.getLocalizer().getMessage(RestfulServer.class, "String_Node_Str", theRequestType.name(), requestPath, params.keySet()));
            }
        }
        requestDetails.setResourceOperationType(resourceMethod.getResourceOperationType());
        requestDetails.setSystemOperationType(resourceMethod.getSystemOperationType());
        requestDetails.setOtherOperationType(resourceMethod.getOtherOperationType());
        for (IServerInterceptor next : myInterceptors) {
            boolean continueProcessing = next.incomingRequestPostProcessed(requestDetails, theRequest, theResponse);
            if (!continueProcessing) {
                ourLog.debug("String_Node_Str");
                return;
            }
        }
        resourceMethod.invokeServer(this, requestDetails);
    } catch (NotModifiedException e) {
        for (int i = getInterceptors().size() - 1; i >= 0; i--) {
            IServerInterceptor next = getInterceptors().get(i);
            if (!next.handleException(requestDetails, e, theRequest, theResponse)) {
                ourLog.debug("String_Node_Str");
                return;
            }
        }
        writeExceptionToResponse(theResponse, e);
    } catch (AuthenticationException e) {
        for (int i = getInterceptors().size() - 1; i >= 0; i--) {
            IServerInterceptor next = getInterceptors().get(i);
            if (!next.handleException(requestDetails, e, theRequest, theResponse)) {
                ourLog.debug("String_Node_Str");
                return;
            }
        }
        if (requestIsBrowser) {
            theResponse.setHeader("String_Node_Str", "String_Node_Str");
        }
        writeExceptionToResponse(theResponse, e);
    } catch (Throwable e) {
        BaseServerResponseException exception = null;
        for (int i = getInterceptors().size() - 1; i >= 0; i--) {
            IServerInterceptor next = getInterceptors().get(i);
            exception = next.preProcessOutgoingException(requestDetails, exception, theRequest);
            if (exception != null) {
                ourLog.debug("String_Node_Str");
                break;
            }
        }
        if (exception == null) {
            exception = new ExceptionHandlingInterceptor().preProcessOutgoingException(requestDetails, e, theRequest);
        }
        for (int i = getInterceptors().size() - 1; i >= 0; i--) {
            IServerInterceptor next = getInterceptors().get(i);
            if (!next.handleException(requestDetails, exception, theRequest, theResponse)) {
                ourLog.debug("String_Node_Str");
                return;
            }
        }
        new ExceptionHandlingInterceptor().handleException(requestDetails, exception, theRequest, theResponse);
    }
}

Output:
             IServerInterceptor next = getInterceptors().get(i);
-            exception = next.preProcessOutgoingException(requestDetails, exception, theRequest);
+            exception = next.preProcessOutgoingException(requestDetails, e, theRequest);
             if (exception != null) {


Input:
public IParameterDefn[] getParameterDefn() {
    return new IParameterDefn[] {};
}

Output:
 public IParameterDefn[] getParameterDefn() {
-    return new IParameterDefn[] {};
+    return new IParameterDefn[] { new ParameterDefn(Constants.EXPRESSION_NAME, Constants.EXPRESSION_DISPLAY_NAME, true, true, SupportedDataTypes.INTEGER_DOUBLE, "String_Node_Str") };
 }


Input:
private int compileOuterColRefExpr(Node refNode) {
    int count = 0;
    Node rowFirstNode = refNode.getFirstChild();
    if (refNode.getType() == Token.GETPROP || refNode.getType() == Token.GETELEM) {
        if (rowFirstNode.getType() == Token.NAME && rowFirstNode.getString().equals(ROW_INDICATOR)) {
            Node rowColumn = rowFirstNode.getNext();
            if (rowColumn.getType() == Token.STRING) {
                if ("String_Node_Str".equals(rowColumn.getString()))
                    count++;
            }
            return count;
        } else if (rowFirstNode.getType() == Token.GETPROP) {
            if (compileOuterColRefExpr(rowFirstNode) == -1)
                return -1;
            else
                count = count + compileOuterColRefExpr(rowFirstNode);
            Node nextChild = rowFirstNode.getNext();
            if (nextChild.getType() == Token.STRING) {
                if ("String_Node_Str".equals(nextChild.getString()))
                    count++;
            }
        } else
            return -1;
        return count;
    } else
        return -1;
}

Output:
     Node rowFirstNode = refNode.getFirstChild();
-    if (refNode.getType() == Token.GETPROP || refNode.getType() == Token.GETELEM) {
+    if (refNode.getType() == Token.GETPROP || refNode.getType() == Token.GETELEM || refNode.getType() == Token.SETPROP || refNode.getType() == Token.SETELEM) {
         if (rowFirstNode.getType() == Token.NAME && rowFirstNode.getString().equals(ROW_INDICATOR)) {


Input:
public void run() {
    if (executed)
        return;
    executed = true;
    log.error("String_Node_Str", event.toString());
    Context context = sourceContext.getContextManager().retrieveContext(sourceContext, null, false, false);
    FaultMessage emsg = event.getMessage();
    FaultMessage m = emsg;
    Map<String, Object> extendedData = emsg != null ? emsg.getExtended() : null;
    do {
        if (m != null && m.getCode() != null && m.isSecurityFault()) {
            emsg = m;
            extendedData = emsg != null ? emsg.getExtended() : null;
            break;
        }
        if (m != null && m.getCause() instanceof FaultEvent)
            m = (FaultMessage) ((FaultEvent) m.getCause()).getCause();
        else if (m.getCause() instanceof FaultMessage)
            m = (FaultMessage) m.getCause();
        else
            m = null;
    } while (m != null);
    serverSession.handleFaultEvent(event, emsg);
    serverSession.handleFault(context, componentName, operation, emsg);
    boolean handled = false;
    Fault fault = new Fault(emsg.getCode(), emsg.getDescription(), emsg.getDetails());
    fault.setContent(event.getMessage());
    fault.setCause(event.getCause());
    TideFaultEvent faultEvent = new TideFaultEvent(context, serverSession, componentResponder, fault, extendedData);
    if (tideResponder != null) {
        tideResponder.fault(faultEvent);
        if (faultEvent.isDefaultPrevented())
            handled = true;
    }
    if (!handled) {
        ExceptionHandler[] exceptionHandlers = context.getContextManager().getContext(null).allByType(ExceptionHandler.class);
        if (exceptionHandlers != null && emsg != null) {
            for (ExceptionHandler handler : exceptionHandlers) {
                if (handler.accepts(emsg)) {
                    handler.handle(context, emsg, faultEvent);
                    handled = true;
                    break;
                }
            }
            if (!handled)
                log.error("String_Node_Str" + emsg.getCode() + "String_Node_Str" + emsg.getDescription());
        } else if (exceptionHandlers != null && exceptionHandlers.length > 0 && event.getMessage() instanceof FaultMessage) {
            exceptionHandlers[0].handle(context, (FaultMessage) event.getMessage(), faultEvent);
        } else {
            log.error("String_Node_Str" + event.toString());
        }
    }
    if (!handled && !serverSession.isLogoutInProgress())
        context.getEventBus().raiseEvent(context, ServerSession.CONTEXT_FAULT, event.getMessage());
    serverSession.tryLogout();
}

Output:
     Context context = sourceContext.getContextManager().retrieveContext(sourceContext, null, false, false);
-    FaultMessage emsg = event.getMessage();
-    FaultMessage m = emsg;
-    Map<String, Object> extendedData = emsg != null ? emsg.getExtended() : null;
-    do {
-        if (m != null && m.getCode() != null && m.isSecurityFault()) {
-            emsg = m;
-            extendedData = emsg != null ? emsg.getExtended() : null;
-            break;
-        }
-        if (m != null && m.getCause() instanceof FaultEvent)
-            m = (FaultMessage) ((FaultEvent) m.getCause()).getCause();
-        else if (m.getCause() instanceof FaultMessage)
-            m = (FaultMessage) m.getCause();
-        else
-            m = null;
-    } while (m != null);
-    serverSession.handleFaultEvent(event, emsg);
+    FaultMessage emsg = null;
+    Map<String, Object> extendedData = null;
+    if (event instanceof FaultEvent) {
+        emsg = ((FaultEvent) event).getMessage();
+        FaultMessage m = emsg;
+        extendedData = emsg != null ? emsg.getExtended() : null;
+        do {
+            if (m != null && m.getCode() != null && m.isSecurityFault()) {
+                emsg = m;
+                extendedData = emsg != null ? emsg.getExtended() : null;
+                break;
+            }
+            if (m != null && m.getCause() instanceof FaultEvent)
+                m = (FaultMessage) ((FaultEvent) m.getCause()).getCause();
+            else if (m.getCause() instanceof FaultMessage)
+                m = (FaultMessage) m.getCause();
+            else
+                m = null;
+        } while (m != null);
+        serverSession.handleFaultEvent((FaultEvent) event, emsg);
+    } else
+        serverSession.handleIssueEvent((IssueEvent) event);
     serverSession.handleFault(context, componentName, operation, emsg);


Input:
public static String formatRow(String[] field, JSONObject jsonObj) {
    StringBuffer row = new StringBuffer();
    int count = 0;
    for (String column : field) {
        count++;
        String temp = jsonObj.get(column).toString();
        if (column.contentEquals("String_Node_Str") || column.contentEquals("String_Node_Str")) {
            String col = temp.replace("String_Node_Str", "String_Node_Str");
            temp = col;
        }
        if (column.contentEquals("String_Node_Str")) {
            String cols = "String_Node_Str";
            if (temp.contains("String_Node_Str")) {
                cols = temp.replace("String_Node_Str", "String_Node_Str");
            }
            temp = cols;
        }
        row.append(temp);
        if (count < field.length) {
            row.append("String_Node_Str");
        }
    }
    row.append(System.getProperty("String_Node_Str"));
    return row.toString();
}

Output:
         }
-        if (column.contentEquals("String_Node_Str")) {
-            String cols = "String_Node_Str";
+        if (column.contentEquals("String_Node_Str") || column.contentEquals("String_Node_Str")) {
+            String emt = "String_Node_Str" + "String_Node_Str";
+            if (temp.contains(emt)) {
+                String cols = "String_Node_Str";
+                cols = temp.replace(emt, "String_Node_Str");
+                temp = cols;
+            }
             if (temp.contains("String_Node_Str")) {


Input:
protected void formOK(UserRequest ureq) {
    String searchValue = getSearchValue(ureq);
    if (StringHelper.containsNonWhitespace(searchValue)) {
        if (StringHelper.isLong(searchValue)) {
            doSelect(ureq);
        } else if (searchValue.length() >= 3) {
            Map<String, String> userProperties = new HashMap<String, String>();
            userProperties.put(UserConstants.FIRSTNAME, searchValue);
            userProperties.put(UserConstants.LASTNAME, searchValue);
            userProperties.put(UserConstants.EMAIL, searchValue);
            List<Identity> res = searchUsers(searchValue, userProperties, false);
            if (res.size() == 1) {
                Identity chosenIdent = res.get(0);
                fireEvent(ureq, new SingleIdentityChosenEvent(chosenIdent));
            } else if (res.size() > 1) {
                tableEl.reset();
                userTableModel.setObjects(wrapIdentities(res));
            }
        }
    } else {
        if (validateForm(ureq)) {
            doSearch();
        }
    }
}

Output:
         if (StringHelper.isLong(searchValue)) {
-            doSelect(ureq);
+            doFireSelection(ureq, Collections.singletonList(searchValue));
         } else if (searchValue.length() >= 3) {


Input:
public static String directoryToString(File path) {
    if (!path.exists()) {
        return quote(path) + "String_Node_Str" + System.lineSeparator();
    }
    if (!path.isDirectory()) {
        throw new IllegalArgumentException("String_Node_Str" + path);
    }
    Collection<File> files = FileUtils.listFiles(path, new RegexFileFilter("String_Node_Str"), DirectoryFileFilter.DIRECTORY);
    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append(path);
    stringBuilder.append(System.lineSeparator());
    int padSize = longestPath(files, path);
    for (Iterator iterator = files.iterator(); iterator.hasNext(); ) {
        File file = (File) iterator.next();
        String relativePath = getRelativePath(file, path);
        if (iterator.hasNext()) {
            stringBuilder.append("String_Node_Str");
        } else {
            stringBuilder.append("String_Node_Str");
        }
        stringBuilder.append(StringUtils.rightPad(relativePath, padSize));
        stringBuilder.append(readableFileSize(file));
        stringBuilder.append(System.lineSeparator());
    }
    return stringBuilder.toString();
}

Output:
     if (!path.exists()) {
-        return quote(path) + "String_Node_Str" + System.lineSeparator();
+        return path + "String_Node_Str" + System.lineSeparator();
     }


Input:
private List doQueryCascadeParameterSelectionList(String paramName, IViewerReportDesignHandle design, String groupName, Object[] groupKeys, InputOptions options, ViewerAttributeBean attrBean) throws RemoteException, ReportServiceException {
    List selectionList = new ArrayList();
    Collection list = getReportService().getSelectionListForCascadingGroup(design, groupName, groupKeys, options);
    if (list != null && list.size() > 0) {
        ScalarParameterHandle parameterHandle = (ScalarParameterHandle) attrBean.findParameter(paramName);
        Iterator iList = list.iterator();
        int index = 0;
        while (iList != null && iList.hasNext()) {
            ParameterSelectionChoice item = (ParameterSelectionChoice) iList.next();
            if (item != null && item.getValue() != null) {
                SelectItemChoice selectItemChoice = new SelectItemChoice();
                Object value = item.getValue();
                String label = item.getLabel();
                if (label == null || label.length() <= 0) {
                    label = ParameterValidationUtil.getDisplayValue(null, parameterHandle.getPattern(), value, attrBean.getLocale());
                }
                selectItemChoice.setLabel(label);
                selectItemChoice.setValue(ParameterValidationUtil.getDisplayValue(value));
                selectionList.add(index++, selectItemChoice);
            }
        }
    }
    return selectionList;
}

Output:
                 }
-                selectItemChoice.setLabel(label);
-                selectItemChoice.setValue(ParameterValidationUtil.getDisplayValue(value));
-                selectionList.add(index++, selectItemChoice);
+                if (label != null) {
+                    selectItemChoice.setLabel(label);
+                    selectItemChoice.setValue(ParameterValidationUtil.getDisplayValue(value));
+                    selectionList.add(index++, selectItemChoice);
+                }
             }


Input:
public Animator createAnimator(final ViewGroup sceneRoot, TransitionValues startValues, TransitionValues endValues) {
    if (startValues == null || endValues == null) {
        return null;
    }
    if (sRectEvaluator == null) {
        sRectEvaluator = new RectEvaluator();
    }
    Map<String, Object> startParentVals = startValues.values;
    Map<String, Object> endParentVals = endValues.values;
    ViewGroup startParent = (ViewGroup) startParentVals.get(PROPNAME_PARENT);
    ViewGroup endParent = (ViewGroup) endParentVals.get(PROPNAME_PARENT);
    if (startParent == null || endParent == null) {
        return null;
    }
    final View view = endValues.view;
    if (parentMatches(startParent, endParent)) {
        Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS);
        Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS);
        final int startLeft = startBounds.left;
        final int endLeft = endBounds.left;
        final int startTop = startBounds.top;
        final int endTop = endBounds.top;
        final int startRight = startBounds.right;
        final int endRight = endBounds.right;
        final int startBottom = startBounds.bottom;
        final int endBottom = endBounds.bottom;
        final int startWidth = startRight - startLeft;
        final int startHeight = startBottom - startTop;
        final int endWidth = endRight - endLeft;
        final int endHeight = endBottom - endTop;
        Rect startClip = (Rect) startValues.values.get(PROPNAME_CLIP);
        Rect endClip = (Rect) endValues.values.get(PROPNAME_CLIP);
        int numChanges = 0;
        if ((startWidth != 0 && startHeight != 0) || (endWidth != 0 && endHeight != 0)) {
            if (startLeft != endLeft || startTop != endTop)
                ++numChanges;
            if (startRight != endRight || startBottom != endBottom)
                ++numChanges;
        }
        if ((startClip != null && !startClip.equals(endClip)) || (startClip == null && endClip != null)) {
            ++numChanges;
        }
        if (numChanges > 0) {
            Animator anim;
            if (!mResizeClip || (startClip == null && endClip == null)) {
                ViewUtils.setLeftTopRightBottom(view, startLeft, startTop, startRight, startBottom);
                if (numChanges == 2) {
                    if (startWidth == endWidth && startHeight == endHeight) {
                        anim = AnimatorUtils.ofPointF(view, POSITION_PROPERTY, getPathMotion(), startLeft, startTop, endLeft, endTop);
                    } else {
                        ViewBounds viewBounds = new ViewBounds(view);
                        Animator topLeftAnimator = AnimatorUtils.ofPointF(viewBounds, TOP_LEFT_PROPERTY, getPathMotion(), startLeft, startTop, endLeft, endTop);
                        Animator bottomRightAnimator = AnimatorUtils.ofPointF(viewBounds, BOTTOM_RIGHT_PROPERTY, getPathMotion(), startRight, startBottom, endRight, endBottom);
                        AnimatorSet set = new AnimatorSet();
                        set.playTogether(topLeftAnimator, bottomRightAnimator);
                        set.addListener(viewBounds);
                        anim = set;
                    }
                } else if (startLeft != endLeft || startTop != endTop) {
                    anim = AnimatorUtils.ofPointF(view, TOP_LEFT_ONLY_PROPERTY, getPathMotion(), startLeft, startTop, endLeft, endTop);
                } else {
                    anim = AnimatorUtils.ofPointF(view, BOTTOM_RIGHT_ONLY_PROPERTY, getPathMotion(), startRight, startBottom, endRight, endBottom);
                }
            } else {
                int maxWidth = Math.max(startWidth, endWidth);
                int maxHeight = Math.max(startHeight, endHeight);
                ViewUtils.setLeftTopRightBottom(view, startLeft, startTop, startLeft + maxWidth, startTop + maxHeight);
                Animator positionAnimator = null;
                if (startLeft != endLeft || startTop != endTop) {
                    positionAnimator = AnimatorUtils.ofPointF(view, POSITION_PROPERTY, getPathMotion(), startLeft, startTop, endLeft, endTop);
                }
                final Rect finalClip = endClip;
                if (startClip == null) {
                    startClip = new Rect(0, 0, startWidth, startHeight);
                }
                if (endClip == null) {
                    endClip = new Rect(0, 0, endWidth, endHeight);
                }
                ObjectAnimator clipAnimator = null;
                if (!startClip.equals(endClip)) {
                    ViewUtils.setClipBounds(view, startClip);
                    clipAnimator = ObjectAnimator.ofObject(view, "String_Node_Str", sRectEvaluator, startClip, endClip);
                    clipAnimator.addListener(new AnimatorListenerAdapter() {
                        private boolean mIsCanceled;
                        public void onAnimationCancel(Animator animation) {
                            mIsCanceled = true;
                        }
                        public void onAnimationEnd(Animator animation) {
                            if (!mIsCanceled) {
                                ViewUtils.setClipBounds(view, finalClip);
                                ViewUtils.setLeftTopRightBottom(view, endLeft, endTop, endRight, endBottom);
                            }
                        }
                    });
                }
                anim = TransitionUtils.mergeAnimators(positionAnimator, clipAnimator);
            }
            if (view.getParent() instanceof ViewGroup) {
                final ViewGroup parent = (ViewGroup) view.getParent();
                ViewGroupUtils.suppressLayout(parent, true);
                TransitionListener transitionListener = new TransitionListenerAdapter() {
                    boolean mCanceled = false;
                    public void onTransitionCancel(Transition transition) {
                        ViewGroupUtils.suppressLayout(parent, false);
                        mCanceled = true;
                    }
                    public void onTransitionEnd(Transition transition) {
                        if (!mCanceled) {
                            ViewGroupUtils.suppressLayout(parent, false);
                        }
                    }
                    public void onTransitionPause(Transition transition) {
                        ViewGroupUtils.suppressLayout(parent, false);
                    }
                    public void onTransitionResume(Transition transition) {
                        ViewGroupUtils.suppressLayout(parent, true);
                    }
                };
                addListener(transitionListener);
            }
            return anim;
        }
    } else {
        int startX = (Integer) startValues.values.get(PROPNAME_WINDOW_X);
        int startY = (Integer) startValues.values.get(PROPNAME_WINDOW_Y);
        int endX = (Integer) endValues.values.get(PROPNAME_WINDOW_X);
        int endY = (Integer) endValues.values.get(PROPNAME_WINDOW_Y);
        if (startX != endX || startY != endY) {
            sceneRoot.getLocationInWindow(tempLocation);
            Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
            Canvas canvas = new Canvas(bitmap);
            view.draw(canvas);
            final BitmapDrawable drawable = new BitmapDrawable(sceneRoot.getContext().getResources(), bitmap);
            Animator anim;
            anim = AnimatorUtils.ofPointF(drawable, DRAWABLE_ORIGIN_PROPERTY, getPathMotion(), startX - tempLocation[0], startY - tempLocation[1], endX - tempLocation[0], endY - tempLocation[1]);
            if (anim != null) {
                final float transitionAlpha = ViewUtils.getTransitionAlpha(view);
                ViewUtils.setTransitionAlpha(view, 0);
                ViewOverlayUtils.addOverlay(sceneRoot, drawable);
                anim.addListener(new AnimatorListenerAdapter() {
                    public void onAnimationEnd(Animator animation) {
                        ViewOverlayUtils.removeOverlay(sceneRoot, drawable);
                        ViewUtils.setTransitionAlpha(view, transitionAlpha);
                    }
                });
            }
            return anim;
        }
    }
    return null;
}

Output:
                     ViewUtils.setClipBounds(view, startClip);
-                    clipAnimator = ObjectAnimator.ofObject(view, "String_Node_Str", sRectEvaluator, startClip, endClip);
+                    clipAnimator = ObjectAnimator.ofObject(view, ChangeClipBounds.VIEW_CLIP_BOUNDS, sRectEvaluator, startClip, endClip);
                     clipAnimator.addListener(new AnimatorListenerAdapter() {


Input:
public void testExtendingGroovyInterfaceWithJava() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testExtendingGroovyInterfaceWithJava() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
 }


Input:
public void doDownload() {
    if (_wasShutdown)
        return;
    readHeader();
    if (_state == ERROR)
        return;
    SettingsManager set = SettingsManager.instance();
    _downloadDir = set.getSaveDirectory();
    String incompleteDir = set.getIncompleteDirectory();
    File myFile = new File(incompleteDir, _filename);
    String pathname = myFile.getAbsolutePath();
    File myTest = new File(_downloadDir, _filename);
    String path = myTest.getAbsolutePath();
    File f;
    String p;
    try {
        File shared = new File(_downloadDir);
        String shared_path = shared.getCanonicalPath();
        f = new File(myTest.getParent());
        p = f.getCanonicalPath();
        if (!p.equals(shared_path)) {
            _state = ERROR;
            return;
        }
    } catch (Exception e) {
        _state = ERROR;
        return;
    }
    if ((myTest.exists()) && (!_resume)) {
        if (!_callback.overwriteFile(_filename)) {
            _stateString = "String_Node_Str";
            _state = ERROR;
            return;
        }
    }
    try {
        _fos = new FileOutputStream(pathname, _resume);
    } catch (FileNotFoundException e) {
        _state = ERROR;
        return;
    } catch (Exception e) {
        _state = ERROR;
        return;
    }
    int c = -1;
    byte[] buf = new byte[1024];
    while (true) {
        if (_amountRead == _sizeOfFile) {
            _state = COMPLETE;
            break;
        }
        try {
            c = _br.read(buf);
        } catch (Exception e) {
            _state = ERROR;
            return;
        }
        if (c == -1) {
            break;
        }
        try {
            _fos.write(buf, 0, c);
        } catch (Exception e) {
            _state = ERROR;
            break;
        }
        _amountRead += c;
    }
    try {
        _br.close();
        _fos.close();
    } catch (IOException e) {
        _state = ERROR;
        return;
    }
    if (_amountRead == _sizeOfFile) {
        String pname = _downloadDir + _filename;
        boolean ok = myFile.renameTo(new File(pname));
        if (!ok) {
            _state = ERROR;
            _stateString = "String_Node_Str";
            return;
        }
        _state = COMPLETE;
        FileManager.getFileManager().addFileIfShared(pname);
    } else {
        _state = ERROR;
        _stateString = "String_Node_Str";
    }
}

Output:
     }
-    if ((myTest.exists()) && (!_resume)) {
+    if (myTest.exists()) {
         if (!_callback.overwriteFile(_filename)) {


Input:
public void setMainTCB(TestCaseBrowser mainTCB) {
    if (m_mainTCB != null) {
        m_mainTCB.setViewTitle(Messages.TestCaseBrowser);
    }
    mainTCB.setViewTitle(Messages.TestCaseBrowserMainPrefix + Messages.TestCaseBrowser);
    m_mainTCB = mainTCB;
}

Output:
 public void setMainTCB(TestCaseBrowser mainTCB) {
-    if (m_mainTCB != null) {
-        m_mainTCB.setViewTitle(Messages.TestCaseBrowser);
-    }
-    mainTCB.setViewTitle(Messages.TestCaseBrowserMainPrefix + Messages.TestCaseBrowser);
+    TestCaseBrowser oldMainTCB = m_mainTCB;
+    TestCaseBrowser newMainTCB = mainTCB;
     m_mainTCB = mainTCB;