Input:
public void handleInputEvent(InputEvent event) {
    KEY keyPressed = getPressedKeyBinding();
    if (keyPressed == KEY.SUCK) {
        RayTraceResult mouseOver = Minecraft.getMinecraft().objectMouseOver;
        if (mouseOver != null && mouseOver.entityHit != null) {
            VampirismMod.dispatcher.sendToServer(new InputEventPacket(InputEventPacket.SUCKBLOOD, "String_Node_Str" + mouseOver.entityHit.getEntityId()));
        }
    } else if (keyPressed == KEY.ACTION) {
        EntityPlayer player = Minecraft.getMinecraft().thePlayer;
        if (FactionPlayerHandler.get(player).getCurrentFaction() != null) {
            player.openGui(VampirismMod.instance, ModGuiHandler.ID_ACTION, player.worldObj, player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ());
        }
    } else if (keyPressed == KEY.SKILL) {
        EntityPlayer player = Minecraft.getMinecraft().thePlayer;
        if (FactionPlayerHandler.get(player).getCurrentFaction() != null) {
            player.openGui(VampirismMod.instance, ModGuiHandler.ID_SKILL, player.worldObj, player.getPosition().getX(), player.getPosition().getY(), player.getPosition().getZ());
        }
    } else if (keyPressed == KEY.VISION) {
        VampirismMod.dispatcher.sendToServer(new InputEventPacket(InputEventPacket.VAMPIRE_VISION_TOGGLE, "String_Node_Str"));
    } else if (keyPressed == KEY.BLOOD_POTION) {
        VampirismMod.dispatcher.sendToServer(new InputEventPacket(InputEventPacket.OPEN_BLOOD_POTION, "String_Node_Str"));
    }
}

Output:
         RayTraceResult mouseOver = Minecraft.getMinecraft().objectMouseOver;
-        if (mouseOver != null && mouseOver.entityHit != null) {
+        if (mouseOver != null && mouseOver.entityHit != null && !Minecraft.getMinecraft().thePlayer.isSpectator()) {
             VampirismMod.dispatcher.sendToServer(new InputEventPacket(InputEventPacket.SUCKBLOOD, "String_Node_Str" + mouseOver.entityHit.getEntityId()));


Input:
protected void setStep(int step) {
    if (step == STEP_INITIAL)
        initTurn();
    if (stepObject == null) {
        stepObject = new IntegerState("String_Node_Str");
        stepObject.addObserver(this);
    }
    stepObject.set(step);
    prepareStep();
}

Output:
     if (stepObject == null) {
-        stepObject = new IntegerState("String_Node_Str");
+        stepObject = new IntegerState("String_Node_Str", -1);
         stepObject.addObserver(this);


Input:
private void initComponents() {
    GridBagConstraints constraints = new GridBagConstraints();
    setLayout(new GridBagLayout());
    JPanel teamMetadata = new JPanel();
    teamMetadata.setOpaque(false);
    teamMetadata.setLayout(new GridBagLayout());
    teamMetadata.setBorder(BorderFactory.createTitledBorder(Messages.getString("String_Node_Str")));
    GridBagConstraints teamConstraint = new GridBagConstraints();
    teamConstraint.fill = GridBagConstraints.BOTH;
    teamConstraint.gridx = 0;
    teamConstraint.gridy = 0;
    teamConstraint.insets = new Insets(5, 0, 5, 5);
    teamMetadata.add(new JLabel(Messages.getString("String_Node_Str")), teamConstraint);
    teamConstraint.weightx = 1.0;
    teamConstraint.gridx = 1;
    teamMetadata.add(mPlayerName, teamConstraint);
    teamConstraint.gridx = 0;
    teamConstraint.gridy = 1;
    teamConstraint.weightx = 0.0;
    teamMetadata.add(new JLabel(Messages.getString("String_Node_Str")), teamConstraint);
    teamConstraint.gridx = 1;
    teamConstraint.weightx = 1.0;
    teamMetadata.add(mTeamLabel, teamConstraint);
    constraints.anchor = GridBagConstraints.BASELINE;
    constraints.fill = GridBagConstraints.BOTH;
    constraints.gridy = 0;
    constraints.weightx = 1.0;
    constraints.weighty = 0.5;
    constraints.gridwidth = 2;
    constraints.insets = new Insets(10, 10, 10, 10);
    add(teamMetadata, constraints);
    constraints.gridy = 2;
    constraints.weighty = 1.0;
    constraints.weightx = 1.0;
    add(mJailPanel, constraints);
}

Output:
     setLayout(new GridBagLayout());
-    JPanel teamMetadata = new JPanel();
-    teamMetadata.setOpaque(false);
-    teamMetadata.setLayout(new GridBagLayout());
-    teamMetadata.setBorder(BorderFactory.createTitledBorder(Messages.getString("String_Node_Str")));
+    JPanel teamMetaData = new JPanel();
+    teamMetaData.setOpaque(false);
+    teamMetaData.setLayout(new GridBagLayout());
+    teamMetaData.setBorder(BorderFactory.createTitledBorder(Messages.getString("String_Node_Str")));
     GridBagConstraints teamConstraint = new GridBagConstraints();


Input:
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    mDb = db;
    for (int version = oldVersion; version < newVersion; ++version) {
        switch(version) {
            case 1:
                {
                    db.execSQL("String_Node_Str" + KeyRings.TABLE_NAME + "String_Node_Str");
                    db.execSQL("String_Node_Str" + Keys.TABLE_NAME + "String_Node_Str");
                    db.execSQL("String_Node_Str" + UserIds.TABLE_NAME + "String_Node_Str");
                    db.execSQL("String_Node_Str" + KeyRings.TABLE_NAME + "String_Node_Str" + KeyRings._ID + "String_Node_Str" + KeyRings._ID_type + "String_Node_Str" + KeyRings.MASTER_KEY_ID + "String_Node_Str" + KeyRings.MASTER_KEY_ID_type + "String_Node_Str" + KeyRings.TYPE + "String_Node_Str" + KeyRings.TYPE_type + "String_Node_Str" + KeyRings.WHO_ID + "String_Node_Str" + KeyRings.WHO_ID_type + "String_Node_Str" + KeyRings.KEY_RING_DATA + "String_Node_Str" + KeyRings.KEY_RING_DATA_type + "String_Node_Str");
                    db.execSQL("String_Node_Str" + Keys.TABLE_NAME + "String_Node_Str" + Keys._ID + "String_Node_Str" + Keys._ID_type + "String_Node_Str" + Keys.KEY_ID + "String_Node_Str" + Keys.KEY_ID_type + "String_Node_Str" + Keys.TYPE + "String_Node_Str" + Keys.TYPE_type + "String_Node_Str" + Keys.IS_MASTER_KEY + "String_Node_Str" + Keys.IS_MASTER_KEY_type + "String_Node_Str" + Keys.ALGORITHM + "String_Node_Str" + Keys.ALGORITHM_type + "String_Node_Str" + Keys.KEY_SIZE + "String_Node_Str" + Keys.KEY_SIZE_type + "String_Node_Str" + Keys.CAN_SIGN + "String_Node_Str" + Keys.CAN_SIGN_type + "String_Node_Str" + Keys.CAN_ENCRYPT + "String_Node_Str" + Keys.CAN_ENCRYPT_type + "String_Node_Str" + Keys.IS_REVOKED + "String_Node_Str" + Keys.IS_REVOKED_type + "String_Node_Str" + Keys.CREATION + "String_Node_Str" + Keys.CREATION_type + "String_Node_Str" + Keys.EXPIRY + "String_Node_Str" + Keys.EXPIRY_type + "String_Node_Str" + Keys.KEY_RING_ID + "String_Node_Str" + Keys.KEY_RING_ID_type + "String_Node_Str" + Keys.KEY_DATA + "String_Node_Str" + Keys.KEY_DATA_type + Keys.RANK + "String_Node_Str" + Keys.RANK_type + "String_Node_Str");
                    db.execSQL("String_Node_Str" + UserIds.TABLE_NAME + "String_Node_Str" + UserIds._ID + "String_Node_Str" + UserIds._ID_type + "String_Node_Str" + UserIds.KEY_ID + "String_Node_Str" + UserIds.KEY_ID_type + "String_Node_Str" + UserIds.USER_ID + "String_Node_Str" + UserIds.USER_ID_type + "String_Node_Str" + UserIds.RANK + "String_Node_Str" + UserIds.RANK_type + "String_Node_Str");
                    Cursor cursor = db.query(PublicKeys.TABLE_NAME, new String[] { PublicKeys.KEY_DATA }, null, null, null, null, null);
                    if (cursor != null && cursor.moveToFirst()) {
                        do {
                            byte[] data = cursor.getBlob(cursor.getColumnIndex(PublicKeys.KEY_DATA));
                            try {
                                PGPPublicKeyRing keyRing = new PGPPublicKeyRing(data);
                                saveKeyRing(keyRing);
                                Log.e("String_Node_Str", "String_Node_Str" + keyRing);
                            } catch (IOException e) {
                                Log.e("String_Node_Str", "String_Node_Str" + e);
                            } catch (GeneralException e) {
                                Log.e("String_Node_Str", "String_Node_Str" + e);
                            }
                        } while (cursor.moveToNext());
                    }
                    cursor.close();
                    cursor = db.query(SecretKeys.TABLE_NAME, new String[] { SecretKeys.KEY_DATA }, null, null, null, null, null);
                    if (cursor != null && cursor.moveToFirst()) {
                        do {
                            byte[] data = cursor.getBlob(cursor.getColumnIndex(SecretKeys.KEY_DATA));
                            try {
                                PGPSecretKeyRing keyRing = new PGPSecretKeyRing(data);
                                saveKeyRing(keyRing);
                                Log.e("String_Node_Str", "String_Node_Str" + keyRing);
                            } catch (IOException e) {
                                Log.e("String_Node_Str", "String_Node_Str" + e);
                            } catch (PGPException e) {
                                Log.e("String_Node_Str", "String_Node_Str" + e);
                            } catch (GeneralException e) {
                                Log.e("String_Node_Str", "String_Node_Str" + e);
                            }
                        } while (cursor.moveToNext());
                    }
                    if (cursor != null) {
                        cursor.close();
                    }
                    break;
                }
            default:
                {
                    break;
                }
        }
    }
    mDb = null;
}

Output:
                     }
-                    cursor.close();
+                    if (cursor != null) {
+                        cursor.close();
+                    }
                     cursor = db.query(SecretKeys.TABLE_NAME, new String[] { SecretKeys.KEY_DATA }, null, null, null, null, null);


Input:
protected boolean build() {
    initRooms();
    int distance;
    int retry = 0;
    do {
        if (retry++ > 20) {
            return false;
        }
        roomEntrance = Random.element(rooms);
    } while (roomEntrance.width() < 4 || roomEntrance.height() < 4 || roomEntrance.top == 0 || roomEntrance.top >= 12);
    roomEntrance.type = Type.ENTRANCE;
    roomExit = roomEntrance;
    Room curRoom = null;
    Room lastRoom = roomEntrance;
    for (int i = 0; i <= 4; i++) {
        retry = 0;
        if (i < 4) {
            do {
                if (retry++ > 20) {
                    return false;
                }
                curRoom = Random.element(rooms);
                Graph.buildDistanceMap(rooms, curRoom);
                distance = lastRoom.distance();
            } while (curRoom.type != Type.NULL || distance != 2);
            curRoom.type = Type.STANDARD;
        } else {
            curRoom = roomEntrance;
        }
        Graph.buildDistanceMap(rooms, curRoom);
        List<Room> path = Graph.buildPath(rooms, lastRoom, curRoom);
        Graph.setPrice(path, lastRoom.distance);
        path = Graph.buildPath(rooms, lastRoom, curRoom);
        Room room = lastRoom;
        for (Room next : path) {
            room.connect(next);
            room = next;
        }
        if (i == 4) {
            ArrayList<Room> candidates = new ArrayList<Room>();
            for (Room r : lastRoom.neigbours) {
                if (r.type == Type.NULL && r.connected.size() == 0 && !r.neigbours.contains(roomEntrance)) {
                    candidates.add(r);
                }
            }
            if (candidates.size() > 0) {
                Room kingsRoom = Random.element(candidates);
                kingsRoom.connect(lastRoom);
                kingsRoom.type = Room.Type.RAT_KING;
            } else {
                return false;
            }
        }
        lastRoom = curRoom;
    }
    for (Room r : rooms) {
        if (r.type == Type.NULL && r.connected.size() > 0) {
            r.type = Type.TUNNEL;
        }
    }
    for (Room r : roomEntrance.neigbours) {
        if (r.bottom == roomEntrance.top && r.type != Type.NULL)
            return false;
    }
    paint();
    exit = roomEntrance.top * Level.WIDTH + (roomEntrance.left + roomEntrance.right) / 2;
    map[exit] = Terrain.LOCKED_EXIT;
    paintWater();
    paintGrass();
    return true;
}

Output:
                 distance = lastRoom.distance();
-            } while (curRoom.type != Type.NULL || distance != 2);
+            } while (curRoom.type != Type.NULL || distance != 2 || curRoom.neigbours.contains(roomEntrance));
             curRoom.type = Type.STANDARD;


Input:
protected String[] getGroupsNamesImpl(String worldName) {
    String inheritanceNode = "String_Node_Str";
    if (worldName != null && !worldName.isEmpty()) {
        inheritanceNode = "String_Node_Str" + worldName + "String_Node_Str" + inheritanceNode;
    }
    Object groups = this.node.get(inheritanceNode);
    if (groups instanceof String) {
        String[] groupsArray;
        String groupsString = ((String) groups);
        if (groupsString.contains("String_Node_Str")) {
            groupsArray = ((String) groups).split("String_Node_Str");
        } else {
            groupsArray = new String[] { groupsString };
        }
        this.node.set("String_Node_Str", Arrays.asList(groupsArray));
        this.save();
        return groupsArray;
    } else if (groups instanceof List) {
        return ((List<String>) groups).toArray(new String[0]);
    } else {
        return new String[0];
    }
}

Output:
 protected String[] getGroupsNamesImpl(String worldName) {
-    String inheritanceNode = "String_Node_Str";
-    if (worldName != null && !worldName.isEmpty()) {
-        inheritanceNode = "String_Node_Str" + worldName + "String_Node_Str" + inheritanceNode;
-    }
-    Object groups = this.node.get(inheritanceNode);
+    Object groups = this.node.get(FileEntity.formatPath(worldName, "String_Node_Str"));
     if (groups instanceof String) {


Input:
public void writeExpression(MethodWriter writer) {
    this.variable.value.writeExpression(writer);
    writer.visitInsn(Opcodes.DUP);
    this.variable.writeSet(writer);
}

Output:
     writer.visitInsn(Opcodes.DUP);
-    this.variable.writeSet(writer);
+    this.variable.writeSet(writer, null, null);
 }


Input:
public FirewallRuleResponse createFirewallRuleResponse(FirewallRule fwRule) {
    FirewallRuleResponse response = new FirewallRuleResponse();
    response.setId(fwRule.getId());
    response.setPrivatePort(fwRule.getPrivatePort());
    response.setProtocol(fwRule.getProtocol());
    response.setPublicPort(fwRule.getPublicPort());
    response.setPublicIpAddress(fwRule.getPublicIpAddress());
    if (fwRule.getPublicIpAddress() != null && fwRule.getPrivateIpAddress() != null) {
        UserVm vm = ApiDBUtils.findUserVmByPublicIpAndGuestIp(fwRule.getPublicIpAddress(), fwRule.getPrivateIpAddress());
        response.setVirtualMachineId(vm.getId());
        response.setVirtualMachineName(vm.getHostName());
        response.setVirtualMachineDisplayName(vm.getDisplayName());
    }
    response.setObjectName("String_Node_Str");
    return response;
}

Output:
         UserVm vm = ApiDBUtils.findUserVmByPublicIpAndGuestIp(fwRule.getPublicIpAddress(), fwRule.getPrivateIpAddress());
-        response.setVirtualMachineId(vm.getId());
-        response.setVirtualMachineName(vm.getHostName());
-        response.setVirtualMachineDisplayName(vm.getDisplayName());
+        if (vm != null) {
+            response.setVirtualMachineId(vm.getId());
+            response.setVirtualMachineName(vm.getHostName());
+            response.setVirtualMachineDisplayName(vm.getDisplayName());
+        }
     }


Input:
public String getProjectName() {
    if (projectName == null && property != null) {
        InternalEObject author = (InternalEObject) property.getAuthor();
        if (author != null) {
            Resource projResource = author.eResource();
            if (projResource != null) {
                URI projectUri = projResource.getURI();
                IPath projectPath = new Path(projectUri.toFileString());
                if (projectPath.toFile().exists()) {
                    Object projOBJ = EObjectHelper.retrieveEObject(projectPath, PropertiesPackage.eINSTANCE.getProject());
                    if (projOBJ != null) {
                        Project project = (Project) projOBJ;
                        this.projectName = project.getLabel();
                    }
                }
            }
        }
    }
    return this.projectName == null ? ReponsitoryContextBridge.PROJECT_DEFAULT_NAME : this.projectName;
}

Output:
                         Project project = (Project) projOBJ;
-                        this.projectName = project.getLabel();
+                        this.projectName = project.getTechnicalLabel();
                     }


Input:
protected JoinNode createOrUpdateNode(JoinNode baseNode, String basePath, String joinPath, String alias, String field, JoinType joinType, boolean fetch, boolean implicit, boolean fromSelect) {
    JoinNode currentNode = baseNode;
    StringBuilder currentPath = new StringBuilder(basePath);
    String[] pathElements = (joinPath + (!joinPath.isEmpty() && field != null ? "String_Node_Str" : "String_Node_Str") + (field == null ? "String_Node_Str" : field)).split("String_Node_Str");
    if (!fromSelect && !basePath.isEmpty()) {
        baseNode.setSelectOnly(false);
        if (basePath.contains("String_Node_Str")) {
            for (String pathElem : basePath.split("String_Node_Str")) {
                currentNode = currentNode.getNodes().get(pathElem);
                currentNode.setSelectOnly(false);
            }
            currentNode = baseNode;
        }
    }
    Class<?> currentClass;
    if (baseNode.getPropertyClass() == null) {
        currentClass = clazz;
    } else {
        currentClass = baseNode.getPropertyClass();
    }
    for (int j = 0; j < pathElements.length; j++) {
        String propertyName = pathElements[j];
        EntityType type = metamodel.entity(currentClass);
        Attribute attr = type.getAttribute(propertyName);
        if (attr == null) {
            throw new IllegalArgumentException("String_Node_Str" + propertyName + "String_Node_Str" + currentClass.getName());
        }
        boolean collectionValued = attr.isCollection();
        Class<?> resolvedFieldClass = ModelUtils.resolveFieldClass(attr);
        if (!ModelUtils.isJoinable(attr)) {
            LOG.fine(new StringBuilder("String_Node_Str").append(propertyName).append("String_Node_Str").append(currentClass.getName()).append("String_Node_Str").toString());
            break;
        }
        currentClass = resolvedFieldClass;
        JoinType modelAwareType;
        if ((attr.getPersistentAttributeType() == Attribute.PersistentAttributeType.MANY_TO_ONE || attr.getPersistentAttributeType() == Attribute.PersistentAttributeType.ONE_TO_ONE) && ((SingularAttribute) attr).isOptional() == false) {
            modelAwareType = JoinType.INNER;
        } else {
            modelAwareType = JoinType.LEFT;
        }
        if (j == pathElements.length - 1) {
            if (alias == null) {
                alias = propertyName;
            }
            if (joinType == null) {
                joinType = modelAwareType;
            }
            currentNode = getOrCreate(currentPath, currentNode, propertyName, resolvedFieldClass, alias, joinType, fetch, "String_Node_Str", implicit, attr.isCollection());
        } else {
            currentNode = getOrCreate(currentPath, currentNode, propertyName, resolvedFieldClass, propertyName, modelAwareType, fetch, "String_Node_Str", true, attr.isCollection());
        }
        if (fetch) {
            currentNode.setFetch(true);
        }
        if (!fromSelect) {
            currentNode.setSelectOnly(false);
        }
    }
    return currentNode;
}

Output:
         String propertyName = pathElements[j];
-        EntityType type = metamodel.entity(currentClass);
+        ManagedType type = metamodel.managedType(currentClass);
         Attribute attr = type.getAttribute(propertyName);


Input:
public void decode(Object input, WebuiRequestContext context) throws Exception {
    String val = (String) input;
    if ((val == null || val.length() == 0) && type_ == PASSWORD_TYPE)
        return;
    value_ = val;
    if (value_ != null && value_.length() == 0)
        value_ = null;
}

Output:
     String val = (String) input;
-    if ((val == null || val.length() == 0) && type_ == PASSWORD_TYPE)
+    if (val == null)
         return;


Input:
public static List<Map<String, Object>> getXMLMappingValue(Connection connection, List<IMetadataTable> metadataTables) {
    if (metadataTables == null || metadataTables.isEmpty()) {
        return new ArrayList<Map<String, Object>>();
    }
    if (connection instanceof XmlFileConnection) {
        IMetadataTable metadataTable = metadataTables.get(0);
        XmlFileConnection xmlConnection = (XmlFileConnection) connection;
        EList objectList = xmlConnection.getSchema();
        XmlXPathLoopDescriptor xmlDesc = (XmlXPathLoopDescriptor) objectList.get(0);
        if (metadataTable != null) {
            if (xmlDesc != null) {
                List<SchemaTarget> schemaTargets = xmlDesc.getSchemaTargets();
                List<Map<String, Object>> maps = new ArrayList<Map<String, Object>>();
                for (int i = 0; i < schemaTargets.size(); i++) {
                    Map<String, Object> map = new HashMap<String, Object>();
                    SchemaTarget sch = schemaTargets.get(i);
                    map.put("String_Node_Str", TalendQuoteUtils.addQuotes(sch.getRelativeXPathQuery()));
                    maps.add(map);
                }
                return maps;
            }
        }
    }
    if (connection instanceof MDMConnection) {
        IMetadataTable metadataTable = metadataTables.get(0);
        MDMConnection xmlConnection = (MDMConnection) connection;
        EList objectList = xmlConnection.getSchemas();
        if (metadataTable != null) {
            for (Concept concept : (List<Concept>) objectList) {
                if (concept != null && concept.getLabel() != null && concept.getLabel().equals(metadataTable.getLabel())) {
                    List<ConceptTarget> conceptTargets = concept.getConceptTargets();
                    List<Map<String, Object>> maps = new ArrayList<Map<String, Object>>();
                    for (IMetadataColumn col : metadataTable.getListColumns()) {
                        Map<String, Object> map = new HashMap<String, Object>();
                        map.put("String_Node_Str", null);
                        for (int i = 0; i < conceptTargets.size(); i++) {
                            ConceptTarget cpt = conceptTargets.get(i);
                            if (col.getLabel().equals(cpt.getTargetName())) {
                                map.put("String_Node_Str", TalendQuoteUtils.addQuotes(cpt.getRelativeLoopExpression()));
                            }
                        }
                        maps.add(map);
                    }
                    return maps;
                }
            }
        }
    }
    if (connection instanceof HL7Connection) {
        HL7Connection hl7Connection = (HL7Connection) connection;
        Set objectList = ConnectionHelper.getTables(hl7Connection);
        List<Map<String, Object>> maps = new ArrayList<Map<String, Object>>();
        for (IMetadataTable tableOfNode : metadataTables) {
            Map<String, Object> map = new HashMap<String, Object>();
            for (MetadataTable table : (Set<MetadataTable>) objectList) {
                if (table != null && (table.getLabel() == null || table.getLabel().equals(tableOfNode.getLabel()))) {
                    String xpathValue = "String_Node_Str";
                    for (MetadataColumn col : table.getColumns()) {
                        String original = col.getOriginalField();
                        if (original != null && !"String_Node_Str".equals(original)) {
                            if (original.indexOf(TalendQuoteUtils.LBRACKET) != -1) {
                                original = original.substring(0, original.indexOf(TalendQuoteUtils.LBRACKET));
                            }
                            original = TalendQuoteUtils.addQuotes(original);
                            xpathValue += original;
                        }
                        if (table.getColumns().indexOf(col) < table.getColumns().size() - 1) {
                            xpathValue += "String_Node_Str";
                        }
                    }
                    map.put("String_Node_Str", xpathValue);
                    map.put("String_Node_Str", tableOfNode.getTableName());
                    maps.add(map);
                }
            }
        }
        return maps;
    }
    return null;
}

Output:
                 List<Map<String, Object>> maps = new ArrayList<Map<String, Object>>();
-                for (int i = 0; i < schemaTargets.size(); i++) {
+                for (IMetadataColumn col : metadataTable.getListColumns()) {
                     Map<String, Object> map = new HashMap<String, Object>();


Input:
private void populateRelationFromJoinTable(EnhanceEntity e, Client client, EntityMetadata entityMetadata, PersistenceDelegator delegator, Relation relation) {
    Object entity = e.getEntity();
    JoinTableMetadata jtMetadata = relation.getJoinTableMetadata();
    String joinTableName = jtMetadata.getJoinTableName();
    Set<String> joinColumns = jtMetadata.getJoinColumns();
    Set<String> inverseJoinColumns = jtMetadata.getInverseJoinColumns();
    String joinColumnName = (String) joinColumns.toArray()[0];
    String inverseJoinColumnName = (String) inverseJoinColumns.toArray()[0];
    EntityMetadata relMetadata = delegator.getMetadata(relation.getTargetEntity());
    Client pClient = delegator.getClient(entityMetadata);
    List<?> foreignKeys = pClient.getColumnsById(joinTableName, joinColumnName, inverseJoinColumnName, e.getEntityId());
    List childrenEntities = new ArrayList();
    for (Object foreignKey : foreignKeys) {
        EntityMetadata childMetadata = delegator.getMetadata(relation.getTargetEntity());
        Client childClient = delegator.getClient(childMetadata);
        Object child = delegator.find(relation.getTargetEntity(), foreignKey);
        onBiDirection(delegator, e, pClient, relation, getBiDirectionalField(entity.getClass(), relation.getTargetEntity()), joinColumnName, entityMetadata, child, childMetadata, childClient);
        childrenEntities.add(child);
    }
    Field childField = relation.getProperty();
    try {
        PropertyAccessorHelper.set(entity, childField, PropertyAccessorHelper.isCollection(childField.getType()) ? getFieldInstance(childrenEntities, childField) : childrenEntities.get(0));
    } catch (PropertyAccessException ex) {
        throw new EntityReaderException(ex);
    }
}

Output:
         Object child = delegator.find(relation.getTargetEntity(), foreignKey);
-        onBiDirection(delegator, e, pClient, relation, getBiDirectionalField(entity.getClass(), relation.getTargetEntity()), joinColumnName, entityMetadata, child, childMetadata, childClient);
-        childrenEntities.add(child);
+        Object obj = child instanceof EnhanceEntity && child != null ? ((EnhanceEntity) child).getEntity() : child;
+        onBiDirection(delegator, e, pClient, relation, getBiDirectionalField(entity.getClass(), relation.getTargetEntity()), joinColumnName, entityMetadata, obj, childMetadata, childClient);
+        childrenEntities.add(obj);
     }


Input:
public String toString() {
    return "String_Node_Str" + isRenderedRemote() + "String_Node_Str" + recordVA.size() + "String_Node_Str" + dimensionVA.size() + "String_Node_Str" + recordVAType + "String_Node_Str" + getRemoteRenderingGLCanvas();
}

Output:
 public String toString() {
-    return "String_Node_Str" + isRenderedRemote() + "String_Node_Str" + recordVA.size() + "String_Node_Str" + dimensionVA.size() + "String_Node_Str" + recordVAType + "String_Node_Str" + getRemoteRenderingGLCanvas();
+    return "String_Node_Str" + isRenderedRemote() + "String_Node_Str" + recordVA.size() + "String_Node_Str" + dimensionVA.size() + "String_Node_Str" + recordVAType + "String_Node_Str" + getRemoteRenderingGLView();
 }


Input:
private void findCurrentUserPermissions(Integer userId) {
    List<Permission> selectedPermissionsList = (List<Permission>) permissionService.findPermissionByUser(getClientId(), userId);
    if (null != selectedPermissionsList) {
        preSelectedPermissions = new String[selectedPermissionsList.size()];
        preSelectedPermissionNames = new String[selectedPermissionsList.size()];
    }
    int i;
    if (isEmpty(selectedPermissionsList.size())) {
        for (i = 0; i < selectedPermissionsList.size(); i++) {
            String permissionId;
            permissionId = selectedPermissionsList.get(i).getPermissionId().toString();
            preSelectedPermissions[i] = permissionId;
            String permissionName = selectedPermissionsList.get(i).getDescription();
            preSelectedPermissionNames[i] = permissionName;
        }
    }
}

Output:
     List<Permission> selectedPermissionsList = (List<Permission>) permissionService.findPermissionByUser(getClientId(), userId);
-    if (null != selectedPermissionsList) {
-        preSelectedPermissions = new String[selectedPermissionsList.size()];
-        preSelectedPermissionNames = new String[selectedPermissionsList.size()];
-    }
+    preSelectedPermissions = new String[selectedPermissionsList.size()];
     int i;


Input:
private void placeComponents() {
    FillLayout flMain = new FillLayout();
    flMain.marginHeight = 0;
    flMain.marginWidth = 0;
    GridLayout glContent = new GridLayout();
    glContent.verticalSpacing = 5;
    glContent.horizontalSpacing = 5;
    glContent.marginHeight = 4;
    glContent.marginWidth = 4;
    glContent.numColumns = 6;
    this.setLayout(flMain);
    cmpContent = new Composite(this, SWT.NONE);
    cmpContent.setLayout(glContent);
    bEnabled = laCurrent.isVisible();
    boolean bEnableUI = bEnabled;
    if (bEnableVisibility) {
        cbVisible = new Button(cmpContent, SWT.CHECK);
        GridData gdCBVisible = new GridData(GridData.FILL_HORIZONTAL);
        gdCBVisible.horizontalSpan = 6;
        cbVisible.setLayoutData(gdCBVisible);
        cbVisible.setText(Messages.getString("String_Node_Str"));
        cbVisible.setSelection(laCurrent.isVisible());
        cbVisible.addSelectionListener(this);
        if (bEnabled) {
            bEnableUI = cbVisible.getSelection();
        }
    }
    if (bEnableStyles) {
        lblStyle = new Label(cmpContent, SWT.NONE);
        GridData gdLStyle = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
        lblStyle.setLayoutData(gdLStyle);
        lblStyle.setText(Messages.getString("String_Node_Str"));
        lblStyle.setEnabled(bEnableUI);
        cmbStyle = new LineStyleChooserComposite(cmpContent, SWT.DROP_DOWN | SWT.READ_ONLY, getSWTLineStyle(laCurrent.getStyle()), getLineStyleItems());
        GridData gdCBStyle = new GridData(GridData.FILL_HORIZONTAL);
        gdCBStyle.horizontalSpan = 5;
        cmbStyle.setLayoutData(gdCBStyle);
        cmbStyle.addListener(LineStyleChooserComposite.SELECTION_EVENT, this);
        cmbStyle.setEnabled(bEnableUI);
    }
    if (bEnableWidths) {
        lblWidth = new Label(cmpContent, SWT.NONE);
        GridData gdLWidth = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
        lblWidth.setLayoutData(gdLWidth);
        lblWidth.setText(Messages.getString("String_Node_Str"));
        lblWidth.setEnabled(bEnableUI);
        cmbWidth = new LineWidthChooserComposite(cmpContent, SWT.DROP_DOWN | SWT.READ_ONLY, laCurrent.getThickness());
        GridData gdCBWidth = new GridData(GridData.FILL_HORIZONTAL);
        gdCBWidth.horizontalSpan = 5;
        cmbWidth.setLayoutData(gdCBWidth);
        cmbWidth.addListener(LineWidthChooserComposite.SELECTION_EVENT, this);
        cmbWidth.setEnabled(bEnableUI);
    }
    if (bEnableColor) {
        lblColor = new Label(cmpContent, SWT.NONE);
        GridData gdLColor = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
        lblColor.setLayoutData(gdLColor);
        lblColor.setText(Messages.getString("String_Node_Str"));
        lblColor.setEnabled(bEnableUI);
        cmbColor = new FillChooserComposite(cmpContent, SWT.DROP_DOWN | SWT.READ_ONLY, wizardContext, this.laCurrent.getColor(), false, false);
        GridData gdCBColor = new GridData(GridData.FILL_HORIZONTAL);
        gdCBColor.horizontalSpan = 5;
        cmbColor.setLayoutData(gdCBColor);
        cmbColor.addListener(this);
        cmbColor.setEnabled(bEnableUI);
    }
}

Output:
         lblColor.setEnabled(bEnableUI);
-        cmbColor = new FillChooserComposite(cmpContent, SWT.DROP_DOWN | SWT.READ_ONLY, wizardContext, this.laCurrent.getColor(), false, false);
+        int iFillOption = FillChooserComposite.DISABLE_PATTERN_FILL | FillChooserComposite.ENABLE_TRANSPARENT | FillChooserComposite.ENABLE_TRANSPARENT_SLIDER;
+        cmbColor = new FillChooserComposite(cmpContent, SWT.DROP_DOWN | SWT.READ_ONLY, iFillOption, wizardContext, this.laCurrent.getColor());
         GridData gdCBColor = new GridData(GridData.FILL_HORIZONTAL);


Input:
public void clear() {
    ensureNotLocked();
    takeLock();
    try {
        mapRecords.clear();
    } finally {
        releaseLock();
    }
}

Output:
 public void clear() {
-    ensureNotLocked();
-    takeLock();
+    takeWriteLock();
     try {


Input:
public final void renderEachAxis() throws ChartException {
    final double dStaggeredLabelOffset = sc.computeStaggeredAxisLabelOffset(xs, la, iOrientation);
    if (!lia.isSetVisible()) {
        throw new ChartException(ChartEnginePlugin.ID, ChartException.RENDERING, "String_Node_Str", Messages.getResourceBundle(getRunTimeContext().getULocale()));
    }
    tre.setLabel(la);
    tre.setTextPosition(iLabelLocation);
    tre.setLocation(lo);
    lre.setLineAttributes(lia);
    lre.setStart(LocationImpl.create(0, 0));
    lre.setEnd(LocationImpl.create(0, 0));
    double dXStart = 0;
    double dXEnd = 0;
    double dZStart = 0;
    double dZEnd = 0;
    if (iDimension == IConstants.THREE_D) {
        AllAxes aax = pwa.getAxes();
        dXEnd = aax.getPrimaryBase().getScale().getEnd();
        dZEnd = aax.getAncillaryBase().getScale().getEnd();
        dXStart = aax.getPrimaryBase().getScale().getStart();
        dZStart = aax.getAncillaryBase().getScale().getStart();
        daEndPoints3D = sc.getEndPoints();
        da3D = sc.getTickCordinates();
        lo3d = Location3DImpl.create(0, 0, 0);
        t3dre = (Text3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Text3DRenderEvent.class);
        t3dre.setLabel(la);
        t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
        t3dre.setTextPosition(iLabelLocation);
        t3dre.setLocation3D(lo3d);
        l3dre = (Line3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Line3DRenderEvent.class);
        l3dre.setLineAttributes(lia);
        l3dre.setStart3D(Location3DImpl.create(0, 0, 0));
        l3dre.setEnd3D(Location3DImpl.create(0, 0, 0));
    }
    if (iOrientation == IConstants.VERTICAL) {
        final ComputationContext context = new ComputationContext(true);
        context.y3d = 0;
        context.dX = dLocation;
        double dZ = 0;
        if (bRendering3D) {
            Location3D l3d = ax.getAxisCoordinate3D();
            context.dX = l3d.getX();
            dZ = l3d.getZ();
        }
        if (iv != null && iv.getType() == IntersectionValue.MAX && iDimension == IConstants.TWO_5_D) {
            trae.setTransform(TransformationEvent.TRANSLATE);
            trae.setTranslation(dSeriesThickness, -dSeriesThickness);
            ipr.applyTransformation(trae);
        }
        context.dTick1 = ((iMajorTickStyle & IConstants.TICK_LEFT) == IConstants.TICK_LEFT) ? (context.dX - IConstants.TICK_SIZE) : context.dX;
        context.dTick2 = ((iMajorTickStyle & IConstants.TICK_RIGHT) == IConstants.TICK_RIGHT) ? context.dX + IConstants.TICK_SIZE : context.dX;
        if ((iWhatToDraw & IConstants.AXIS) == IConstants.AXIS && lia.isVisible()) {
            if (bRenderOrthogonal3DAxis) {
                final double dStart = daEndPoints3D[0];
                final double dEnd = daEndPoints3D[1];
                l3dre.setLineAttributes(lia);
                l3dre.setStart3D(context.dX, dStart, dZ);
                l3dre.setEnd3D(context.dX, dEnd, dZ);
                dc.addLine(l3dre);
                l3dre.setStart3D(context.dX, dStart, dZEnd);
                l3dre.setEnd3D(context.dX, dEnd, dZEnd);
                dc.addLine(l3dre);
                l3dre.setStart3D(dXEnd, dStart, dZ);
                l3dre.setEnd3D(dXEnd, dEnd, dZ);
                dc.addLine(l3dre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        ArrayList cachedTriggers = null;
                        Location3D[] loaHotspot = new Location3D[4];
                        Polygon3DRenderEvent pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        loaHotspot[0] = Location3DImpl.create(context.dX - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZ + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[1] = Location3DImpl.create(context.dX + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZ - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[2] = Location3DImpl.create(context.dX + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZ - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[3] = Location3DImpl.create(context.dX - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZ + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            cachedTriggers = new ArrayList();
                            for (int t = 0; t < elTriggers.size(); t++) {
                                tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                processTrigger(tg, StructureSource.createAxis(axModel));
                                cachedTriggers.add(tg);
                                iev.addTrigger(TriggerImpl.copyInstance(tg));
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                        pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dXStart - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[1] = Location3DImpl.create(dXStart + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[2] = Location3DImpl.create(dXStart + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[3] = Location3DImpl.create(dXStart - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            if (cachedTriggers == null) {
                                cachedTriggers = new ArrayList();
                                for (int t = 0; t < elTriggers.size(); t++) {
                                    tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                    processTrigger(tg, StructureSource.createAxis(axModel));
                                    cachedTriggers.add(tg);
                                    iev.addTrigger(TriggerImpl.copyInstance(tg));
                                }
                            } else {
                                for (int t = 0; t < cachedTriggers.size(); t++) {
                                    iev.addTrigger(TriggerImpl.copyInstance((Trigger) cachedTriggers.get(t)));
                                }
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                        pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dXEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZStart + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[1] = Location3DImpl.create(dXEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZStart - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[2] = Location3DImpl.create(dXEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZStart - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[3] = Location3DImpl.create(dXEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZStart + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            if (cachedTriggers == null) {
                                for (int t = 0; t < elTriggers.size(); t++) {
                                    tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                    processTrigger(tg, StructureSource.createAxis(axModel));
                                    iev.addTrigger(tg);
                                }
                            } else {
                                for (int t = 0; t < cachedTriggers.size(); t++) {
                                    iev.addTrigger((Trigger) cachedTriggers.get(t));
                                }
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                    }
                }
            } else {
                double dStart = daEndPoints[0] + insCA.getBottom(), dEnd = daEndPoints[1] - insCA.getTop();
                if (sc.getDirection() == IConstants.FORWARD) {
                    dStart = daEndPoints[1] + insCA.getBottom();
                    dEnd = daEndPoints[0] - insCA.getTop();
                }
                if (iv != null && iv.getType() == IntersectionValue.VALUE && iDimension == IConstants.TWO_5_D) {
                    final Location[] loa = new Location[4];
                    loa[0] = LocationImpl.create(context.dX, dStart);
                    loa[1] = LocationImpl.create(context.dX + dSeriesThickness, dStart - dSeriesThickness);
                    loa[2] = LocationImpl.create(context.dX + dSeriesThickness, dEnd - dSeriesThickness);
                    loa[3] = LocationImpl.create(context.dX, dEnd);
                    final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                    pre.setPoints(loa);
                    pre.setBackground(ColorDefinitionImpl.create(255, 255, 255, 127));
                    pre.setOutline(lia);
                    ipr.fillPolygon(pre);
                }
                lre.setLineAttributes(lia);
                lre.getStart().set(context.dX, dStart);
                lre.getEnd().set(context.dX, dEnd);
                ipr.drawLine(lre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                        for (int t = 0; t < elTriggers.size(); t++) {
                            tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                            processTrigger(tg, StructureSource.createAxis(axModel));
                            iev.addTrigger(tg);
                        }
                        Location[] loaHotspot = new Location[4];
                        loaHotspot[0] = LocationImpl.create(context.dX - IConstants.LINE_EXPAND_SIZE, dStart);
                        loaHotspot[1] = LocationImpl.create(context.dX + IConstants.LINE_EXPAND_SIZE, dStart);
                        loaHotspot[2] = LocationImpl.create(context.dX + IConstants.LINE_EXPAND_SIZE, dEnd);
                        loaHotspot[3] = LocationImpl.create(context.dX - IConstants.LINE_EXPAND_SIZE, dEnd);
                        final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                        pre.setPoints(loaHotspot);
                        iev.setHotSpot(pre);
                        ipr.enableInteraction(iev);
                    }
                }
            }
        }
        renderVerticalAxisByType(context, dXEnd, dZEnd, dZ, dStaggeredLabelOffset);
        la = LabelImpl.copyInstance(ax.getTitle());
        if (la.isVisible() && bRenderAxisTitle) {
            ScriptHandler.callFunction(sh, ScriptHandler.BEFORE_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.BEFORE_DRAW_AXIS_TITLE, la);
            final String sRestoreValue = la.getCaption().getValue();
            la.getCaption().setValue(getRunTimeContext().externalizedMessage(sRestoreValue));
            BoundingBox bb = null;
            try {
                bb = Methods.computeBox(xs, ax.getTitlePosition(), la, 0, 0);
            } catch (IllegalArgumentException uiex) {
                throw new ChartException(ChartEnginePlugin.ID, ChartException.RENDERING, uiex);
            }
            if (ax.getTitle().isVisible() && la.isVisible()) {
                if (bRendering3D) {
                    Bounds cbo = renderer.getPlotBounds();
                    tre.setBlockBounds(BoundsImpl.create(cbo.getLeft() + (cbo.getWidth() / 3d - bb.getWidth()) / 2d, cbo.getTop() + 30, bb.getWidth(), bb.getHeight()));
                    tre.setLabel(la);
                    tre.setBlockAlignment(la.getCaption().getFont().getAlignment());
                    tre.setAction(TextRenderEvent.RENDER_TEXT_IN_BLOCK);
                    ipr.drawText(tre);
                    tre.setBlockBounds(BoundsImpl.create(cbo.getLeft() + cbo.getWidth() - bb.getWidth(), cbo.getTop() + 30 * 2, bb.getWidth(), bb.getHeight()));
                    ipr.drawText(tre);
                } else {
                    final Bounds bo = BoundsImpl.create(ax.getTitleCoordinate(), daEndPoints[1], bb.getWidth(), daEndPoints[0] - daEndPoints[1]);
                    tre.setBlockBounds(bo);
                    tre.setLabel(la);
                    if (ax.getModelAxis().getAssociatedAxes().size() != 0) {
                        tre.setBlockAlignment(ChartUtil.transposeAlignment(la.getCaption().getFont().getAlignment()));
                    } else {
                        tre.setBlockAlignment(la.getCaption().getFont().getAlignment());
                    }
                    tre.setAction(TextRenderEvent.RENDER_TEXT_IN_BLOCK);
                    if (ax.getTitle().isVisible()) {
                        ipr.drawText(tre);
                    }
                }
            }
            la.getCaption().setValue(sRestoreValue);
            ScriptHandler.callFunction(sh, ScriptHandler.AFTER_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.AFTER_DRAW_AXIS_TITLE, la);
        }
        la = LabelImpl.copyInstance(ax.getLabel());
        if (iv != null && iv.getType() == IntersectionValue.MAX && iDimension == IConstants.TWO_5_D) {
            trae.setTranslation(-dSeriesThickness, dSeriesThickness);
            ipr.applyTransformation(trae);
        }
    } else if (iOrientation == IConstants.HORIZONTAL) {
        final ComputationContext context = new ComputationContext(false);
        context.x3d = 0;
        context.z3d = 0;
        context.dY = dLocation;
        double dX = 0;
        double dZ = 0;
        if (bRendering3D) {
            Location3D l3d = ax.getAxisCoordinate3D();
            dX = l3d.getX();
            context.dY = l3d.getY();
            dZ = l3d.getZ();
        }
        context.dTick1 = ((iMajorTickStyle & IConstants.TICK_ABOVE) == IConstants.TICK_ABOVE) ? (bRendering3D ? context.dY + IConstants.TICK_SIZE : context.dY - IConstants.TICK_SIZE) : context.dY;
        context.dTick2 = ((iMajorTickStyle & IConstants.TICK_BELOW) == IConstants.TICK_BELOW) ? (bRendering3D ? context.dY - IConstants.TICK_SIZE : context.dY + IConstants.TICK_SIZE) : context.dY;
        if (iv != null && iDimension == IConstants.TWO_5_D && ((bTransposed && renderer.isRightToLeft() && iv.getType() == IntersectionValue.MIN) || (!renderer.isRightToLeft() && iv.getType() == IntersectionValue.MAX))) {
            trae.setTransform(TransformationEvent.TRANSLATE);
            trae.setTranslation(dSeriesThickness, -dSeriesThickness);
            ipr.applyTransformation(trae);
        }
        if ((iWhatToDraw & IConstants.AXIS) == IConstants.AXIS && lia.isVisible()) {
            if (bRenderBase3DAxis) {
                final double dStart = daEndPoints3D[0];
                final double dEnd = daEndPoints3D[1];
                l3dre.setLineAttributes(lia);
                l3dre.setStart3D(dStart, context.dY, dZ);
                l3dre.setEnd3D(dEnd, context.dY, dZ);
                dc.addLine(l3dre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final Polygon3DRenderEvent pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        Location3D[] loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dStart, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        loaHotspot[1] = Location3DImpl.create(dStart, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        loaHotspot[2] = Location3DImpl.create(dEnd, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        loaHotspot[3] = Location3DImpl.create(dEnd, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            for (int t = 0; t < elTriggers.size(); t++) {
                                tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                processTrigger(tg, StructureSource.createAxis(axModel));
                                iev.addTrigger(tg);
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                    }
                }
            } else if (bRenderAncillary3DAxis) {
                final double dStart = daEndPoints3D[0];
                final double dEnd = daEndPoints3D[1];
                l3dre.setLineAttributes(lia);
                l3dre.setStart3D(dX, context.dY, dStart);
                l3dre.setEnd3D(dX, context.dY, dEnd);
                dc.addLine(l3dre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final Polygon3DRenderEvent pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        Location3D[] loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dX, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart);
                        loaHotspot[1] = Location3DImpl.create(dX, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart);
                        loaHotspot[2] = Location3DImpl.create(dX, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd);
                        loaHotspot[3] = Location3DImpl.create(dX, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            for (int t = 0; t < elTriggers.size(); t++) {
                                tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                processTrigger(tg, StructureSource.createAxis(axModel));
                                iev.addTrigger(tg);
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                    }
                }
            } else {
                double dStart = daEndPoints[0] - insCA.getLeft(), dEnd = daEndPoints[1] + insCA.getRight();
                if (sc.getDirection() == IConstants.BACKWARD) {
                    dStart = daEndPoints[1] - insCA.getLeft();
                    dEnd = daEndPoints[0] + insCA.getRight();
                }
                if (iv != null && iv.getType() == IntersectionValue.VALUE && iDimension == IConstants.TWO_5_D) {
                    final Location[] loa = new Location[4];
                    loa[0] = LocationImpl.create(dStart, context.dY);
                    loa[1] = LocationImpl.create(dStart + dSeriesThickness, context.dY - dSeriesThickness);
                    loa[2] = LocationImpl.create(dEnd + dSeriesThickness, context.dY - dSeriesThickness);
                    loa[3] = LocationImpl.create(dEnd, context.dY);
                    final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                    pre.setPoints(loa);
                    pre.setBackground(ColorDefinitionImpl.create(255, 255, 255, 127));
                    pre.setOutline(lia);
                    ipr.fillPolygon(pre);
                }
                lre.setLineAttributes(lia);
                lre.getStart().set(dStart, context.dY);
                lre.getEnd().set(dEnd, context.dY);
                ipr.drawLine(lre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                        for (int t = 0; t < elTriggers.size(); t++) {
                            tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                            processTrigger(tg, StructureSource.createAxis(axModel));
                            iev.addTrigger(tg);
                        }
                        Location[] loaHotspot = new Location[4];
                        loaHotspot[0] = LocationImpl.create(dStart, context.dY - IConstants.LINE_EXPAND_SIZE);
                        loaHotspot[1] = LocationImpl.create(dEnd, context.dY - IConstants.LINE_EXPAND_SIZE);
                        loaHotspot[2] = LocationImpl.create(dEnd, context.dY + IConstants.LINE_EXPAND_SIZE);
                        loaHotspot[3] = LocationImpl.create(dStart, context.dY + IConstants.LINE_EXPAND_SIZE);
                        final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                        pre.setPoints(loaHotspot);
                        iev.setHotSpot(pre);
                        ipr.enableInteraction(iev);
                    }
                }
            }
        }
        renderHorizontalAxisByType(context, dXEnd, dZEnd, dZ, dStaggeredLabelOffset);
        la = LabelImpl.copyInstance(ax.getTitle());
        if (la.isVisible() && bRenderAxisTitle) {
            ScriptHandler.callFunction(sh, ScriptHandler.BEFORE_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.BEFORE_DRAW_AXIS_TITLE, la);
            final String sRestoreValue = la.getCaption().getValue();
            la.getCaption().setValue(getRunTimeContext().externalizedMessage(sRestoreValue));
            la.getCaption().getFont().setAlignment(renderer.switchTextAlignment(la.getCaption().getFont().getAlignment()));
            BoundingBox bb = null;
            try {
                bb = Methods.computeBox(xs, ax.getTitlePosition(), la, 0, 0);
            } catch (IllegalArgumentException uiex) {
                throw new ChartException(ChartEnginePlugin.ID, ChartException.RENDERING, uiex);
            }
            if (ax.getTitle().isVisible() && la.isVisible()) {
                if (bRendering3D) {
                    Bounds cbo = renderer.getPlotBounds();
                    if (axisType == IConstants.BASE_AXIS) {
                        tre.setBlockBounds(BoundsImpl.create(cbo.getLeft() + (cbo.getWidth() / 3d - bb.getWidth()), cbo.getTop() + cbo.getHeight() - Math.min(bb.getHeight(), bb.getWidth()) - 30, bb.getWidth(), bb.getHeight()));
                    } else {
                        tre.setBlockBounds(BoundsImpl.create(cbo.getLeft() + cbo.getWidth() * 2 / 3d + (cbo.getWidth() / 3d - bb.getWidth()) / 2d, cbo.getTop() + cbo.getHeight() - Math.min(bb.getHeight(), bb.getWidth()) - 30 * 2, bb.getWidth(), bb.getHeight()));
                    }
                    tre.setLabel(la);
                    tre.setBlockAlignment(la.getCaption().getFont().getAlignment());
                    tre.setAction(TextRenderEvent.RENDER_TEXT_IN_BLOCK);
                    ipr.drawText(tre);
                } else {
                    final Bounds bo = BoundsImpl.create(daEndPoints[0], ax.getTitleCoordinate(), daEndPoints[1] - daEndPoints[0], bb.getHeight());
                    tre.setBlockBounds(bo);
                    tre.setLabel(la);
                    if (ax.getModelAxis().getAssociatedAxes().size() != 0) {
                        tre.setBlockAlignment(la.getCaption().getFont().getAlignment());
                    } else {
                        tre.setBlockAlignment(ChartUtil.transposeAlignment(la.getCaption().getFont().getAlignment()));
                    }
                    tre.setAction(TextRenderEvent.RENDER_TEXT_IN_BLOCK);
                    ipr.drawText(tre);
                }
            }
            ScriptHandler.callFunction(sh, ScriptHandler.AFTER_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.AFTER_DRAW_AXIS_TITLE, la);
        }
        la = LabelImpl.copyInstance(ax.getLabel());
        if (iv != null && iDimension == IConstants.TWO_5_D && ((bTransposed && renderer.isRightToLeft() && iv.getType() == IntersectionValue.MIN) || (!renderer.isRightToLeft() && iv.getType() == IntersectionValue.MAX))) {
            trae.setTranslation(-dSeriesThickness, dSeriesThickness);
            ipr.applyTransformation(trae);
        }
    }
}

Output:
                     if (axisType == IConstants.BASE_AXIS) {
-                        tre.setBlockBounds(BoundsImpl.create(cbo.getLeft() + (cbo.getWidth() / 3d - bb.getWidth()), cbo.getTop() + cbo.getHeight() - Math.min(bb.getHeight(), bb.getWidth()) - 30, bb.getWidth(), bb.getHeight()));
+                        tre.setBlockBounds(BoundsImpl.create(cbo.getLeft() + (cbo.getWidth() / 3d - bb.getWidth()), cbo.getTop() + cbo.getHeight() - Math.min(bb.getHeight(), bb.getWidth()), bb.getWidth(), bb.getHeight()));
                     } else {


Input:
public void run() {
    boolean connected = true;
    LocalSocket clientSocket = new LocalSocket(socketToClient, this);
    if (!clientSocket.success) {
        printLogMessage("String_Node_Str");
        return;
    }
    String kickMessage = Packet01Login.processLogin(clientSocket.in, clientSocket.out, this, this, Globals.isAuth());
    if (kickMessage != null) {
        printLogMessage(kickMessage);
        PacketFFKick.kick(clientSocket.out, this, this, kickMessage);
        connected = false;
    }
    if (BanList.banned(clientInfo.getUsername())) {
        printLogMessage(clientInfo.getUsername() + "String_Node_Str");
        PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str");
        connected = false;
    }
    String hostname = ReconnectCache.get(clientInfo.getUsername());
    int portnum = ReconnectCache.getPort(hostname, defaultPort);
    hostname = ReconnectCache.getHost(hostname, "String_Node_Str");
    boolean firstConnection = true;
    while (connected && !killed()) {
        String redirectLocal = getRedirect();
        setRedirect(null);
        if (redirectLocal != null) {
            String[] split = redirectLocal.split("String_Node_Str");
            if (split.length != 2) {
                printLogMessage("String_Node_Str");
                connected = false;
            } else {
                hostname = split[0];
                try {
                    portnum = Integer.parseInt(split[1]);
                } catch (NumberFormatException nfe) {
                    printLogMessage("String_Node_Str");
                    connected = false;
                }
            }
        }
        printLogMessage("String_Node_Str" + hostname + "String_Node_Str" + portnum);
        Socket serverBasicSocket = LocalSocket.openSocket(hostname, portnum, this);
        if (serverBasicSocket == null) {
            printLogMessage("String_Node_Str");
            PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str");
            LocalSocket.closeSocket(clientSocket.socket, this);
            return;
        }
        LocalSocket serverSocket = new LocalSocket(serverBasicSocket, this);
        if (!serverSocket.success) {
            printLogMessage("String_Node_Str");
            PacketFFKick.kickAndClose(clientSocket, this, this, "String_Node_Str");
            return;
        }
        kickMessage = Packet01Login.serverLogin(serverSocket.in, serverSocket.out, this, this);
        if (kickMessage != null) {
            printLogMessage(kickMessage);
            PacketFFKick.kick(clientSocket.out, this, this, kickMessage);
            connected = false;
        }
        if (connected) {
            ReconnectCache.store(clientInfo.getUsername(), hostname, portnum);
            Packet01Login serverLoginPacket = new Packet01Login(serverSocket.in, this, this);
            if (serverLoginPacket.packetId == null || serverLoginPacket.read(serverSocket.in, this, this, true, null) == null) {
                printLogMessage("String_Node_Str");
                connected = false;
            } else {
                clientInfo.setPlayerEntityId(serverLoginPacket.getVersion());
                if (firstConnection) {
                    firstConnection = false;
                    Packet01Login clientLoginPacket = new Packet01Login(clientSocket.out, this, this);
                    if (!forward) {
                        clientLoginPacket.setVersion(Globals.getDefaultPlayerId());
                    } else {
                        clientLoginPacket.setVersion(serverLoginPacket.getVersion());
                    }
                    if (Globals.getDimension() == null) {
                        if (Globals.isVerbose()) {
                            printLogMessage("String_Node_Str" + serverLoginPacket.getDimension());
                        }
                        clientLoginPacket.setDimension(serverLoginPacket.getDimension());
                    } else {
                        if (Globals.isVerbose()) {
                            printLogMessage("String_Node_Str" + Globals.getDimension());
                        }
                        clientLoginPacket.setDimension(Globals.getDimension());
                    }
                    clientLoginPacket.setMapSeed(serverLoginPacket.getMapSeed());
                    clientLoginPacket.setUsername(serverLoginPacket.getUsername());
                    if (clientLoginPacket.packetId == null || clientLoginPacket.write(clientSocket.out, this, this, true) == null) {
                        printLogMessage("String_Node_Str");
                        connected = false;
                    }
                } else {
                    short holdingLocal = getHolding();
                    if (holdingLocal != 0) {
                        if (!Globals.isQuiet()) {
                            printLogMessage("String_Node_Str" + holding);
                        }
                        Packet10HoldingChange holdingChange = new Packet10HoldingChange(serverSocket.out, this, this);
                        holdingChange.setSlot(holding);
                        if (holdingChange.packetId == null || holdingChange.write(serverSocket.out, this, this, false) == null) {
                            printLogMessage("String_Node_Str");
                            connected = false;
                        }
                    }
                }
                if (connected) {
                    if (forward) {
                        serverToClient = new DataStreamBridge(serverSocket.in, clientSocket.out, this);
                        clientToServer = new DataStreamBridge(clientSocket.in, serverSocket.out, this);
                        connected = false;
                    } else {
                        serverToClient = new DataStreamDownLinkBridge(serverSocket.in, clientSocket.out, this);
                        clientToServer = new DataStreamUpLinkBridge(clientSocket.in, serverSocket.out, this);
                    }
                    boolean localEnabled;
                    synchronized (enabledSync) {
                        localEnabled = enabled;
                        if (enabled) {
                            serverToClient.start();
                            clientToServer.start();
                        }
                    }
                    if (localEnabled) {
                        while ((clientToServer.isAlive() || serverToClient.isAlive())) {
                            try {
                                clientToServer.join(500);
                                serverToClient.join(500);
                            } catch (InterruptedException ie) {
                                kill();
                            }
                            if (killed() || (!(clientToServer.isAlive() && serverToClient.isAlive()))) {
                                clientToServer.interrupt();
                                serverToClient.interrupt();
                            }
                        }
                        connected = getRedirect() != null;
                    }
                }
            }
        }
        printLogMessage("String_Node_Str");
        LocalSocket.closeSocket(serverSocket.socket, this);
        if (connected) {
            if (Globals.isVerbose()) {
                printLogMessage("String_Node_Str");
            }
            revive();
        }
    }
    if (!getKickMessageSent()) {
        PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str");
    }
    printLogMessage("String_Node_Str");
    LocalSocket.closeSocket(clientSocket.socket, this);
}

Output:
             } else {
-                clientInfo.setPlayerEntityId(serverLoginPacket.getVersion());
+                if (serverLoginPacket.packetId == 0x01) {
+                    clientInfo.setPlayerEntityId(serverLoginPacket.getVersion());
+                } else if (serverLoginPacket.packetId == (byte) 0xFF) {
+                    PacketFFKick.kickAndClose(clientSocket, this, this, ((UnitString) serverLoginPacket.fields[0]).getValue());
+                    return;
+                } else {
+                    PacketFFKick.kickAndClose(clientSocket, this, this, "String_Node_Str");
+                    return;
+                }
                 if (firstConnection) {


Input:
public void testViewIndex() throws CBLiteException {
    Map<String, Object> dict1 = new HashMap<String, Object>();
    dict1.put("String_Node_Str", "String_Node_Str");
    Map<String, Object> dict2 = new HashMap<String, Object>();
    dict2.put("String_Node_Str", "String_Node_Str");
    Map<String, Object> dict3 = new HashMap<String, Object>();
    dict3.put("String_Node_Str", "String_Node_Str");
    Map<String, Object> dictX = new HashMap<String, Object>();
    dictX.put("String_Node_Str", "String_Node_Str");
    CBLRevisionInternal rev1 = putDoc(database, dict1);
    CBLRevisionInternal rev2 = putDoc(database, dict2);
    CBLRevisionInternal rev3 = putDoc(database, dict3);
    putDoc(database, dictX);
    CBLView view = createView(database);
    Assert.assertEquals(1, view.getViewId());
    Assert.assertTrue(view.isStale());
    CBLStatus updated = view.updateIndex();
    Assert.assertEquals(CBLStatus.OK, updated.getCode());
    List<Map<String, Object>> dumpResult = view.dump();
    Log.v(TAG, "String_Node_Str" + dumpResult);
    Assert.assertEquals(3, dumpResult.size());
    Assert.assertEquals("String_Node_Str", dumpResult.get(0).get("String_Node_Str"));
    Assert.assertEquals(1, dumpResult.get(0).get("String_Node_Str"));
    Assert.assertEquals("String_Node_Str", dumpResult.get(2).get("String_Node_Str"));
    Assert.assertEquals(2, dumpResult.get(2).get("String_Node_Str"));
    Assert.assertEquals("String_Node_Str", dumpResult.get(1).get("String_Node_Str"));
    Assert.assertEquals(3, dumpResult.get(1).get("String_Node_Str"));
    Assert.assertFalse(view.isStale());
    updated = view.updateIndex();
    Assert.assertEquals(CBLStatus.NOT_MODIFIED, updated.getCode());
    CBLRevisionInternal threeUpdated = new CBLRevisionInternal(rev3.getDocId(), rev3.getRevId(), false, database);
    Map<String, Object> newdict3 = new HashMap<String, Object>();
    newdict3.put("String_Node_Str", "String_Node_Str");
    threeUpdated.setProperties(newdict3);
    CBLStatus status = new CBLStatus();
    rev3 = database.putRevision(threeUpdated, rev3.getRevId(), false, status);
    Assert.assertTrue(status.isSuccessful());
    Map<String, Object> dict4 = new HashMap<String, Object>();
    dict4.put("String_Node_Str", "String_Node_Str");
    CBLRevisionInternal rev4 = putDoc(database, dict4);
    CBLRevisionInternal twoDeleted = new CBLRevisionInternal(rev2.getDocId(), rev2.getRevId(), true, database);
    database.putRevision(twoDeleted, rev2.getRevId(), false, status);
    Assert.assertTrue(status.isSuccessful());
    Assert.assertTrue(view.isStale());
    updated = view.updateIndex();
    Assert.assertEquals(CBLStatus.OK, updated.getCode());
    dumpResult = view.dump();
    Log.v(TAG, "String_Node_Str" + dumpResult);
    Assert.assertEquals(3, dumpResult.size());
    Assert.assertEquals("String_Node_Str", dumpResult.get(2).get("String_Node_Str"));
    Assert.assertEquals(1, dumpResult.get(2).get("String_Node_Str"));
    Assert.assertEquals("String_Node_Str", dumpResult.get(0).get("String_Node_Str"));
    Assert.assertEquals(5, dumpResult.get(0).get("String_Node_Str"));
    Assert.assertEquals("String_Node_Str", dumpResult.get(1).get("String_Node_Str"));
    Assert.assertEquals(6, dumpResult.get(1).get("String_Node_Str"));
    List<CBLQueryRow> rows = view.queryWithOptions(null);
    Assert.assertEquals(3, rows.size());
    Assert.assertEquals("String_Node_Str", rows.get(2).getKey());
    Assert.assertEquals(rev1.getDocId(), rows.get(2).getDocumentId());
    Assert.assertEquals("String_Node_Str", rows.get(0).getKey());
    Assert.assertEquals(rev3.getDocId(), rows.get(0).getDocumentId());
    Assert.assertEquals("String_Node_Str", rows.get(1).getKey());
    Assert.assertEquals(rev4.getDocId(), rows.get(1).getDocumentId());
    view.removeIndex();
}

Output:
     Assert.assertFalse(view.isStale());
-    updated = view.updateIndex();
-    Assert.assertEquals(CBLStatus.NOT_MODIFIED, updated.getCode());
+    boolean gotNotModfiedException = false;
+    try {
+        updated = view.updateIndex();
+    } catch (CBLiteException e) {
+        if (e.getCBLStatus().getCode() == CBLStatus.NOT_MODIFIED) {
+            gotNotModfiedException = true;
+        }
+    }
+    Assert.assertTrue(gotNotModfiedException);
     CBLRevisionInternal threeUpdated = new CBLRevisionInternal(rev3.getDocId(), rev3.getRevId(), false, database);


Input:
private ElementDefinitionMatch getElementDefinition(StructureDefinition sd, String path, boolean allowTypedName) throws PathEngineException {
    for (ElementDefinition ed : sd.getSnapshot().getElement()) {
        if (ed.getPath().equals(path)) {
            if (ed.hasContentReference()) {
                return getElementDefinitionById(sd, ed.getContentReference());
            } else
                return new ElementDefinitionMatch(ed, null);
        }
        if (ed.getPath().endsWith("String_Node_Str") && path.startsWith(ed.getPath().substring(0, ed.getPath().length() - 3)) && path.length() == ed.getPath().length() - 3)
            return new ElementDefinitionMatch(ed, null);
        if (allowTypedName && ed.getPath().endsWith("String_Node_Str") && path.startsWith(ed.getPath().substring(0, ed.getPath().length() - 3)) && path.length() > ed.getPath().length() - 3) {
            String s = Utilities.uncapitalize(path.substring(ed.getPath().length() - 3));
            if (primitiveTypes.contains(s))
                return new ElementDefinitionMatch(ed, s);
            else
                return new ElementDefinitionMatch(ed, path.substring(ed.getPath().length() - 3));
        }
        if (ed.getPath().contains("String_Node_Str") && path.startsWith(ed.getPath() + "String_Node_Str") && (ed.getType().size() > 0) && !isAbstractType(ed.getType())) {
            if (ed.getType().size() > 1)
                throw new PathEngineException("String_Node_Str");
            StructureDefinition nsd = worker.fetchResource(StructureDefinition.class, "String_Node_Str" + ed.getType().get(0).getCode());
            if (nsd == null)
                throw new PathEngineException("String_Node_Str" + ed.getType().get(0).getCode());
            return getElementDefinition(sd, sd.getId() + path.substring(ed.getPath().length()), allowTypedName);
        }
        if (ed.hasContentReference() && path.startsWith(ed.getPath() + "String_Node_Str")) {
            ElementDefinitionMatch m = getElementDefinitionById(sd, ed.getContentReference());
            return getElementDefinition(sd, m.definition.getPath() + path.substring(ed.getPath().length()), allowTypedName);
        }
    }
    return null;
}

Output:
                 throw new PathEngineException("String_Node_Str" + ed.getType().get(0).getCode());
-            return getElementDefinition(sd, sd.getId() + path.substring(ed.getPath().length()), allowTypedName);
+            return getElementDefinition(nsd, nsd.getId() + path.substring(ed.getPath().length()), allowTypedName);
         }


Input:
public void addCLRFiles(final File folder) throws BindException {
    try (final LoggingScope ls = this.loggingScopeFactory.getNewLoggingScope("String_Node_Str")) {
        ConfigurationModule result = this.driverConfigModule;
        for (final File f : folder.listFiles()) {
            if (f.canRead() && f.exists() && f.isFile()) {
                result = result.set(DriverConfiguration.GLOBAL_FILES, f.getAbsolutePath());
            }
        }
        this.driverConfigModule = result.set(DriverConfiguration.DRIVER_MEMORY, this.driverMemory).set(DriverConfiguration.DRIVER_IDENTIFIER, this.driverId).set(DriverConfiguration.DRIVER_JOB_SUBMISSION_DIRECTORY, this.jobSubmissionDirectory);
        final Path globalLibFile = Paths.get(NativeInterop.GLOBAL_LIBRARIES_FILENAME);
        if (!Files.exists(globalLibFile)) {
            LOG.log(Level.FINE, "String_Node_Str", globalLibFile.toAbsolutePath());
        } else {
            String globalLibString = "String_Node_Str";
            try {
                globalLibString = new String(Files.readAllBytes(globalLibFile));
            } catch (final Exception e) {
                LOG.log(Level.WARNING, "String_Node_Str" + globalLibFile.toAbsolutePath());
            }
            for (final String s : globalLibString.split("String_Node_Str")) {
                final File f = new File(s);
                this.driverConfigModule = this.driverConfigModule.set(DriverConfiguration.GLOBAL_LIBRARIES, f.getPath());
            }
        }
        this.driverConfiguration = Configurations.merge(this.driverConfigModule.build(), getHTTPConfiguration(), getNameServerConfiguration());
    }
}

Output:
             try {
-                globalLibString = new String(Files.readAllBytes(globalLibFile));
+                globalLibString = new String(Files.readAllBytes(globalLibFile), StandardCharsets.UTF_8);
             } catch (final Exception e) {


Input:
public void debug(String line) {
    if (this.debug) {
        this.logger.info(this.prefix + "String_Node_Str" + line);
        toFile(Type.debug, line);
    }
}

Output:
 public void debug(String line) {
-    if (this.debug) {
+    if (isDebug()) {
         this.logger.info(this.prefix + "String_Node_Str" + line);


Input:
public static IResource getResourceHandleForLocation(Repository repository, String repoRelativePath, boolean isFolder) {
    final String workDir = repository.getWorkTree().getAbsolutePath();
    final IPath path = new Path(workDir + '/' + repoRelativePath);
    final File file = path.toFile();
    if (file.exists()) {
        if (isFolder) {
            return ResourceUtil.getContainerForLocation(path);
        }
        return ResourceUtil.getFileForLocation(path);
    }
    final IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    for (IProject project : root.getProjects()) {
        if (RepositoryProvider.getProvider(project, GitProvider.ID) != null) {
            final IPath projectLocation = project.getLocation();
            if (projectLocation != null && projectLocation.isPrefixOf(path)) {
                final IPath projectRelativePath = path.makeRelativeTo(projectLocation);
                if (isFolder) {
                    return project.getFolder(projectRelativePath);
                } else {
                    return project.getFile(projectRelativePath);
                }
            }
        }
    }
    return null;
}

Output:
         if (isFolder) {
-            return ResourceUtil.getContainerForLocation(path);
+            return ResourceUtil.getContainerForLocation(path, false);
         }


Input:
private static void parseXelMethod(PageDefinition pgdef, ProcessingInstruction pi, Map<String, String> params) throws Exception {
    final String prefix = params.remove("String_Node_Str");
    noELnorEmpty("String_Node_Str", prefix, pi);
    final String nm = params.remove("String_Node_Str");
    noELnorEmpty("String_Node_Str", nm, pi);
    final String clsnm = params.remove("String_Node_Str");
    noELnorEmpty("String_Node_Str", clsnm, pi);
    final String sig = params.remove("String_Node_Str");
    noELnorEmpty("String_Node_Str", sig, pi);
    final Method mtd;
    try {
        final ClassResolver clsresolver = pgdef.getImportedClassResolver();
        final Class cls = clsresolver.resolveClass(clsnm);
        mtd = Classes.getMethodBySignature(cls, sig, null, clsresolver);
    } catch (ClassNotFoundException ex) {
        throw new UiException(message("String_Node_Str" + clsnm, pi));
    } catch (Exception ex) {
        throw new UiException(message("String_Node_Str" + sig + "String_Node_Str" + clsnm, pi));
    }
    if ((mtd.getModifiers() & Modifier.STATIC) == 0)
        throw new UiException(message("String_Node_Str" + mtd, pi));
    pgdef.addXelMethod(prefix, nm, new MethodFunction(mtd));
}

Output:
     } catch (ClassNotFoundException ex) {
-        throw new UiException(message("String_Node_Str" + clsnm, pi));
+        throw new UiException(message("String_Node_Str" + ex.getMessage(), pi));
     } catch (Exception ex) {


Input:
public void load(GuaguaWritableAdapter<LongWritable> currentKey, GuaguaWritableAdapter<Tuple> currentValue, WorkerContext<NNParams, NNParams> workerContext) {
    this.initFieldList();
    super.count += 1;
    if ((super.count) % 100000 == 0) {
        LOG.info("String_Node_Str", super.count);
    }
    double baggingSampleRate = super.modelConfig.getBaggingSampleRate();
    if (!super.modelConfig.isFixInitialInput() && Double.compare(Math.random(), baggingSampleRate) >= 0) {
        return;
    }
    double[] inputs = new double[super.inputNodeCount];
    double[] ideal = new double[super.outputNodeCount];
    if (super.isDry) {
        addDataPairToDataSet(0, new BasicMLDataPair(new BasicMLData(inputs), new BasicMLData(ideal)));
        return;
    }
    long hashcode = 0;
    double significance = NNConstants.DEFAULT_SIGNIFICANCE_VALUE;
    int index = 0, inputsIndex = 0, outputIndex = 0;
    Tuple tuple = currentValue.getWritable();
    for (int i = 0; i < tuple.size(); i++) {
        Object element = null;
        try {
            element = tuple.get(i);
        } catch (ExecException e) {
            throw new GuaguaRuntimeException(e);
        }
        double doubleValue = 0d;
        if (element != null) {
            if (element instanceof Double) {
                doubleValue = (Double) element;
            } else {
                doubleValue = NumberFormatUtils.getDouble(element.toString().trim(), 0d);
            }
        }
        if (index == (super.inputNodeCount + super.outputNodeCount)) {
            if (element != null && element instanceof Double) {
                significance = (Double) element;
            } else {
                significance = NumberFormatUtils.getDouble(element.toString().trim(), NNConstants.DEFAULT_SIGNIFICANCE_VALUE);
                ;
            }
            break;
        } else {
            ColumnConfig columnConfig = super.columnConfigList.get(requiredFieldList.getFields().get(index).getIndex());
            if (columnConfig != null && columnConfig.isTarget()) {
                ideal[outputIndex++] = doubleValue;
            } else {
                inputs[inputsIndex++] = doubleValue;
                hashcode = hashcode * 31 + Double.valueOf(doubleValue).hashCode();
            }
        }
        index += 1;
    }
    long longBaggingSampleRate = Double.valueOf(baggingSampleRate * 100).longValue();
    if (super.modelConfig.isFixInitialInput() && hashcode % 100 >= longBaggingSampleRate) {
        return;
    }
    super.sampleCount += 1;
    MLDataPair pair = new BasicMLDataPair(new BasicMLData(inputs), new BasicMLData(ideal));
    pair.setSignificance(significance);
    addDataPairToDataSet(hashcode, pair);
}

Output:
         } else {
-            ColumnConfig columnConfig = super.columnConfigList.get(requiredFieldList.getFields().get(index).getIndex());
-            if (columnConfig != null && columnConfig.isTarget()) {
-                ideal[outputIndex++] = doubleValue;
+            int columnIndex = requiredFieldList.getFields().get(index).getIndex();
+            if (columnIndex >= super.columnConfigList.size()) {
+                if (element != null && element instanceof Double) {
+                    significance = (Double) element;
+                } else {
+                    significance = NumberFormatUtils.getDouble(element.toString().trim(), NNConstants.DEFAULT_SIGNIFICANCE_VALUE);
+                    ;
+                }
+                break;
             } else {


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    AdapterTags.READ_ITEM_TIMES.addAll(Read.longSet(this, READ_ITEMS));
    FragmentManager manager = getFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    m_FragmentNavigationDrawer = (FragmentNavigationDrawer) manager.findFragmentById(R.id.navigation_drawer);
    m_FragmentNavigationDrawer.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.drawer_layout));
    AsyncNavigationAdapter.update(this);
    for (int i = 0; FRAGMENT_TAGS.length > i; i++) {
        Fragment fragment = getFragment(manager, FRAGMENT_TAGS[i]);
        if (!fragment.isAdded()) {
            transaction.add(R.id.content_frame, fragment, FRAGMENT_TAGS[i]);
        }
        if (0 != i && !fragment.isHidden()) {
            transaction.hide(fragment);
        }
    }
    transaction.commit();
    m_currentFragment = FRAGMENT_TAGS[0];
}

Output:
     m_FragmentNavigationDrawer.setUp(R.id.navigation_drawer, (DrawerLayout) findViewById(R.id.drawer_layout));
-    AsyncNavigationAdapter.update(this);
+    AsyncNewTagAdapters.update(this);
     for (int i = 0; FRAGMENT_TAGS.length > i; i++) {


Input:
protected UserDetails createUserDetails(String username, UserDetails userFromUserQuery, List<GrantedAuthority> combinedAuthorities) {
    String returnUsername = userFromUserQuery.getUsername();
    if (!isUsernameBasedPrimaryKey()) {
        returnUsername = username;
    }
    return new User(returnUsername, userFromUserQuery.getPassword(), userFromUserQuery.isEnabled(), true, true, userFromUserQuery.isAccountNonLocked(), combinedAuthorities);
}

Output:
     }
-    return new User(returnUsername, userFromUserQuery.getPassword(), userFromUserQuery.isEnabled(), true, true, userFromUserQuery.isAccountNonLocked(), combinedAuthorities);
+    return new User(returnUsername, userFromUserQuery.getPassword(), userFromUserQuery.isEnabled(), true, true, true, combinedAuthorities);
 }


Input:
protected void delete(Id.Namespace namespaceId) throws IOException, ExploreException, SQLException {
    Location namespaceHome = namespacedLocationFactory.get(namespaceId);
    if (namespaceHome.exists() && !namespaceHome.delete(true)) {
        throw new IOException(String.format("String_Node_Str", namespaceHome, namespaceId.getId()));
    } else {
        LOG.warn(String.format("String_Node_Str", namespaceHome, namespaceId));
    }
    if (cConf.getBoolean(Constants.Explore.EXPLORE_ENABLED)) {
        exploreFacade.removeNamespace(namespaceId);
    }
}

Output:
     Location namespaceHome = namespacedLocationFactory.get(namespaceId);
-    if (namespaceHome.exists() && !namespaceHome.delete(true)) {
-        throw new IOException(String.format("String_Node_Str", namespaceHome, namespaceId.getId()));
+    if (namespaceHome.exists()) {
+        if (!namespaceHome.delete(true)) {
+            throw new IOException(String.format("String_Node_Str", namespaceHome, namespaceId.getId()));
+        }
     } else {


Input:
public static String generateConstantExpr(String input, int dataType) throws BirtException {
    if (input == null) {
        return null;
    }
    if (dataType == DataType.DECIMAL_TYPE) {
        return "String_Node_Str" + input + "String_Node_Str";
    }
    if (dataType == DataType.STRING_TYPE || dataType == DataType.DATE_TYPE || dataType == DataType.SQL_DATE_TYPE || dataType == DataType.SQL_TIME_TYPE) {
        return JavascriptEvalUtil.transformToJsExpression(input);
    }
    return input;
}

Output:
     }
-    if (dataType == DataType.STRING_TYPE || dataType == DataType.DATE_TYPE || dataType == DataType.SQL_DATE_TYPE || dataType == DataType.SQL_TIME_TYPE) {
+    if (dataType == DataType.STRING_TYPE || dataType == DataType.DATE_TYPE || dataType == DataType.SQL_DATE_TYPE || dataType == DataType.SQL_TIME_TYPE || dataType == DataType.JAVA_OBJECT_TYPE) {
         return JavascriptEvalUtil.transformToJsExpression(input);


Input:
public void checkTypes(MarkerList markers, IContext context) {
    if (this.action != null) {
        this.action.check(markers, context);
    }
    if (this.condition != null) {
        IValue condition1 = this.condition.withType(Types.BOOLEAN);
        if (condition1 == null) {
            Marker marker = markers.create(this.condition.getPosition(), "String_Node_Str");
            marker.addInfo("String_Node_Str" + this.condition.getType());
        } else {
            this.condition = condition1;
        }
        this.condition.checkTypes(markers, context);
    }
}

Output:
     if (this.action != null) {
-        this.action.check(markers, context);
+        this.action.checkTypes(markers, context);
     }


Input:
public boolean isAdvanced() {
    return true;
}

Output:
 public boolean isAdvanced() {
-    return true;
+    return false;
 }


Input:
public boolean applies(Ability abilityToModify, Ability source, Game game) {
    if (abilityToModify instanceof SpellAbility) {
        Card sourceCard = game.getCard(((SpellAbility) abilityToModify).getSourceId());
        if (sourceCard != null && sourceCard.getOwnerId().equals(source.getControllerId())) {
            Permanent permanent = game.getPermanent(source.getSourceId());
            if (permanent != null) {
                List<UUID> imprinted = permanent.getImprinted();
                if (imprinted.size() > 0) {
                    Card imprintedCard = game.getCard(imprinted.get(0));
                    if (imprintedCard != null && CardUtil.shareTypes(imprintedCard, sourceCard)) {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

Output:
 public boolean applies(Ability abilityToModify, Ability source, Game game) {
-    if (abilityToModify instanceof SpellAbility) {
-        Card sourceCard = game.getCard(((SpellAbility) abilityToModify).getSourceId());
+    if (abilityToModify instanceof SpellAbility || abilityToModify instanceof FlashbackAbility || abilityToModify instanceof RetraceAbility) {
+        Card sourceCard = game.getCard(abilityToModify.getSourceId());
         if (sourceCard != null && sourceCard.getOwnerId().equals(source.getControllerId())) {


Input:
public void reset() {
    playerPlayedPermanentTypes.clear();
    super.reset();
}

Output:
 public void reset() {
-    playerPlayedPermanentTypes.clear();
+    sourcePlayedPermanentTypes.clear();
     super.reset();


Input:
private boolean callValidate() {
    if (widget.isCallValidate()) {
        if (widget.isLongRunning()) {
            return new RunWithProgress(widget.getContent().getDisplayName()) {
                protected void toDo() throws Throwable {
                    componentProperties = componentService.validateProperty(getParameterName(), componentProperties);
                }
            }.run();
        } else {
            try {
                componentProperties = componentService.validateProperty(getParameterName(), componentProperties);
                return true;
            } catch (Throwable e) {
                ExceptionHandler.process(e);
            }
        }
    }
    return false;
}

Output:
             return new RunWithProgress(widget.getContent().getDisplayName()) {
-                protected void toDo() throws Throwable {
-                    componentProperties = componentService.validateProperty(getParameterName(), componentProperties);
-                }
-            }.run();
-        } else {
-            try {
+protected void doWork() throws Throwable {
                 componentProperties = componentService.validateProperty(getParameterName(), componentProperties);


Input:
public static void setup() throws Exception {
    CConfiguration cConf = createCConf();
    final Injector injector = AppFabricTestHelper.getInjector(cConf);
    appFabricServer = injector.getInstance(AppFabricServer.class);
    appFabricServer.startAndWait();
    authorizationEnforcementService = injector.getInstance(AuthorizationEnforcementService.class);
    authorizationEnforcementService.startAndWait();
    remoteSystemOperationsService = injector.getInstance(RemoteSystemOperationsService.class);
    remoteSystemOperationsService.startAndWait();
    authorizer = injector.getInstance(AuthorizerInstantiator.class).get();
    SecurityRequestContext.setUserId(ALICE.getName());
    secureStoreService = injector.getInstance(SecureStoreService.class);
    authorizer.grant(NamespaceId.DEFAULT, ALICE, Collections.singleton(Action.READ));
    Tasks.waitFor(true, new Callable<Boolean>() {
        public Boolean call() throws Exception {
            return injector.getInstance(NamespaceAdmin.class).exists(Id.Namespace.DEFAULT);
        }
    }, 5, TimeUnit.SECONDS);
    authorizer.revoke(NamespaceId.DEFAULT, ALICE, Collections.singleton(Action.READ));
}

Output:
     CConfiguration cConf = createCConf();
-    final Injector injector = AppFabricTestHelper.getInjector(cConf);
+    SConfiguration sConf = SConfiguration.create();
+    sConf.set(Constants.Security.Store.FILE_PASSWORD, "String_Node_Str");
+    final Injector injector = Guice.createInjector(new AppFabricTestModule(createCConf(), sConf));
+    injector.getInstance(TransactionManager.class).startAndWait();
+    injector.getInstance(DatasetOpExecutor.class).startAndWait();
+    injector.getInstance(DatasetService.class).startAndWait();
     appFabricServer = injector.getInstance(AppFabricServer.class);


Input:
private static void _writeInFile(File file, String data) {
    try {
        BufferedWriter writer = new BufferedWriter(new FileWriter(file));
        writer.write(data);
        writer.flush();
        writer.close();
    } catch (Exception e) {
        System.out.println("String_Node_Str");
    }
}

Output:
     try {
-        BufferedWriter writer = new BufferedWriter(new FileWriter(file));
+        FileWriter fWriter = new FileWriter(file);
+        BufferedWriter writer = new BufferedWriter(fWriter);
         writer.write(data);


Input:
public void testBaseStyle() {
    ((StyledElementDesign) element).setStyleClass("String_Node_Str");
    assertEquals("String_Node_Str", ((StyledElementDesign) element).getStyleClass());
}

Output:
 public void testBaseStyle() {
-    ((StyledElementDesign) element).setStyleClass("String_Node_Str");
-    assertEquals("String_Node_Str", ((StyledElementDesign) element).getStyleClass());
+    ((StyledElementDesign) element).setStyleName("String_Node_Str");
+    assertEquals("String_Node_Str", ((StyledElementDesign) element).getStyleName());
 }