Input:
protected void prepareHandlers(final Context context) {
    addHandler(Attributes.View.OnClick, new EventProcessor<V>(context) {
        public void setOnEventListener(final V view, final ParserContext parserContext, final JsonElement attributeValue) {
            view.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    fireEvent(view, parserContext, EventType.OnClick, attributeValue);
                }
            });
        }
    });
    addHandler(Attributes.View.Background, new DrawableResourceProcessor<V>(context) {
        public void setDrawable(V view, Drawable drawable) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                view.setBackgroundDrawable(drawable);
            } else {
                view.setBackground(drawable);
            }
        }
    });
    addHandler(Attributes.View.Height, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
            layoutParams.height = ParseHelper.parseDimension(attributeValue, context);
            view.setLayoutParams(layoutParams);
        }
    });
    addHandler(Attributes.View.Width, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
            layoutParams.width = ParseHelper.parseDimension(attributeValue, context);
            view.setLayoutParams(layoutParams);
        }
    });
    addHandler(Attributes.View.Weight, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            LinearLayout.LayoutParams layoutParams;
            if (view.getLayoutParams() instanceof LinearLayout.LayoutParams) {
                layoutParams = (LinearLayout.LayoutParams) view.getLayoutParams();
                layoutParams.weight = ParseHelper.parseFloat(attributeValue);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error(attributeKey + "String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.LayoutGravity, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
            if (layoutParams instanceof LinearLayout.LayoutParams) {
                LinearLayout.LayoutParams linearLayoutParams = (LinearLayout.LayoutParams) layoutParams;
                linearLayoutParams.gravity = ParseHelper.parseGravity(attributeValue);
                view.setLayoutParams(layoutParams);
            } else if (layoutParams instanceof FrameLayout.LayoutParams) {
                FrameLayout.LayoutParams linearLayoutParams = (FrameLayout.LayoutParams) layoutParams;
                linearLayoutParams.gravity = ParseHelper.parseGravity(attributeValue);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error(attributeKey + "String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.Padding, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(dimension, dimension, dimension, dimension);
        }
    });
    addHandler(Attributes.View.PaddingLeft, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(dimension, view.getPaddingTop(), view.getPaddingRight(), view.getPaddingBottom());
        }
    });
    addHandler(Attributes.View.PaddingTop, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(view.getPaddingLeft(), dimension, view.getPaddingRight(), view.getPaddingBottom());
        }
    });
    addHandler(Attributes.View.PaddingRight, new StringAttributeProcessor<V>() {

        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(view.getPaddingLeft(), view.getPaddingTop(), dimension, view.getPaddingBottom());
        }
    });
    addHandler(Attributes.View.PaddingBottom, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(view.getPaddingLeft(), view.getPaddingTop(), view.getPaddingRight(), dimension);
        }
    });
    addHandler(Attributes.View.Margin, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(dimension, dimension, dimension, dimension);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginLeft, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(dimension, layoutParams.topMargin, layoutParams.rightMargin, layoutParams.bottomMargin);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginTop, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(layoutParams.leftMargin, dimension, layoutParams.rightMargin, layoutParams.bottomMargin);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginRight, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(layoutParams.leftMargin, layoutParams.topMargin, dimension, layoutParams.bottomMargin);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginBottom, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(layoutParams.leftMargin, layoutParams.topMargin, layoutParams.rightMargin, dimension);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MinHeight, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            view.setMinimumHeight(dimension);
        }
    });
    addHandler(Attributes.View.MinWidth, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            view.setMinimumWidth(dimension);
        }
    });
    addHandler(Attributes.View.Elevation, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                view.setElevation(dimension);
            }
        }
    });
    addHandler(Attributes.View.Alpha, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setAlpha(ParseHelper.parseFloat(attributeValue));
        }
    });
    addHandler(Attributes.View.Visibility, new JsonDataProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, JsonElement attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setVisibility(ParseHelper.parseVisibility(attributeValue));
        }
    });
    addHandler(Attributes.View.Invisibility, new JsonDataProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, JsonElement attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setVisibility(ParseHelper.parseInvisibility(attributeValue));
        }
    });
    addHandler(Attributes.View.Id, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setId(IdGenerator.getInstance().getUnique(attributeValue));
        }
    });
    addHandler(Attributes.View.ContentDescription, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setContentDescription(attributeValue);
        }
    });
    addHandler(Attributes.View.Clickable, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            boolean clickable = ParseHelper.parseBoolean(attributeValue);
            view.setClickable(clickable);
        }
    });
    addHandler(Attributes.View.Tag, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setTag(attributeValue);
        }
    });
    addHandler(Attributes.View.Border, new JsonDataProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, JsonElement attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            Drawable border = Utils.getBorderDrawble(attributeValue, context);
            if (border == null) {
                return;
            }
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                view.setBackgroundDrawable(border);
            } else {
                view.setBackground(border);
            }
        }
    });
    addHandler(Attributes.View.Enabled, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            boolean enabled = ParseHelper.parseBoolean(attributeValue);
            view.setEnabled(enabled);
        }
    });
    addHandler(Attributes.View.Style, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            Styles styles = parserContext.getStyles();
            LayoutHandler handler = parserContext.getLayoutBuilder().getHandler(Utils.getPropertyAsString(layout, ProteusConstants.TYPE));
            if (styles == null) {
                return;
            }
            String[] styleSet = attributeValue.split(ProteusConstants.STYLE_DELIMITER);
            for (String styleName : styleSet) {
                if (styles.contains(styleName)) {
                    process(styles.getStyle(styleName), layout, proteusView, (handler != null ? handler : ViewParser.this), parserContext.getLayoutBuilder(), parserContext, parent, index);
                }
            }
        }
        private void process(Map<String, JsonElement> style, JsonObject layout, ProteusView proteusView, LayoutHandler handler, LayoutBuilder builder, ParserContext parserContext, ProteusView parent, int index) {
            for (Map.Entry<String, JsonElement> attribute : style.entrySet()) {
                if (layout.has(attribute.getKey())) {
                    continue;
                }
                builder.handleAttribute(handler, parserContext, attribute.getKey(), attribute.getValue(), layout, proteusView, parent, index);
            }
        }
    });
    addHandler(Attributes.View.TransitionName, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                view.setTransitionName(attributeValue);
            }
        }
    });
    addHandler(Attributes.View.RequiresFadingEdge, new StringAttributeProcessor<V>() {
        private final String NONE = "String_Node_Str";
        private final String BOTH = "String_Node_Str";
        private final String VERTICAL = "String_Node_Str";
        private final String HORIZONTAL = "String_Node_Str";
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            switch(attributeValue) {
                case NONE:
                    view.setVerticalFadingEdgeEnabled(false);
                    view.setHorizontalFadingEdgeEnabled(false);
                    break;
                case BOTH:
                    view.setVerticalFadingEdgeEnabled(true);
                    view.setHorizontalFadingEdgeEnabled(true);
                    break;
                case VERTICAL:
                    view.setVerticalFadingEdgeEnabled(true);
                    view.setHorizontalFadingEdgeEnabled(false);
                    break;
                case HORIZONTAL:
                    view.setVerticalFadingEdgeEnabled(false);
                    view.setHorizontalFadingEdgeEnabled(true);
                    break;
                default:
                    view.setVerticalFadingEdgeEnabled(false);
                    view.setHorizontalFadingEdgeEnabled(false);
                    break;
            }
        }
    });
    addHandler(Attributes.View.FadingEdgeLength, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setFadingEdgeLength(ParseHelper.parseInt(attributeValue));
        }
    });
    final HashMap<String, Integer> relativeLayoutParams = new HashMap<>();
    relativeLayoutParams.put(Attributes.View.Above.getName(), RelativeLayout.ABOVE);
    relativeLayoutParams.put(Attributes.View.AlignBaseline.getName(), RelativeLayout.ALIGN_BASELINE);
    relativeLayoutParams.put(Attributes.View.AlignBottom.getName(), RelativeLayout.ALIGN_BOTTOM);
    relativeLayoutParams.put(Attributes.View.AlignEnd.getName(), RelativeLayout.ALIGN_END);
    relativeLayoutParams.put(Attributes.View.AlignLeft.getName(), RelativeLayout.ALIGN_LEFT);
    relativeLayoutParams.put(Attributes.View.AlignParentBottom.getName(), RelativeLayout.ALIGN_PARENT_BOTTOM);
    relativeLayoutParams.put(Attributes.View.AlignParentEnd.getName(), RelativeLayout.ALIGN_PARENT_END);
    relativeLayoutParams.put(Attributes.View.AlignParentLeft.getName(), RelativeLayout.ALIGN_PARENT_LEFT);
    relativeLayoutParams.put(Attributes.View.AlignParentRight.getName(), RelativeLayout.ALIGN_PARENT_RIGHT);
    relativeLayoutParams.put(Attributes.View.AlignParentStart.getName(), RelativeLayout.ALIGN_PARENT_START);
    relativeLayoutParams.put(Attributes.View.AlignParentTop.getName(), RelativeLayout.ALIGN_PARENT_TOP);
    relativeLayoutParams.put(Attributes.View.AlignRight.getName(), RelativeLayout.ALIGN_RIGHT);
    relativeLayoutParams.put(Attributes.View.AlignStart.getName(), RelativeLayout.ALIGN_START);
    relativeLayoutParams.put(Attributes.View.AlignTop.getName(), RelativeLayout.ALIGN_TOP);
    relativeLayoutParams.put(Attributes.View.Below.getName(), RelativeLayout.BELOW);
    relativeLayoutParams.put(Attributes.View.CenterHorizontal.getName(), RelativeLayout.CENTER_HORIZONTAL);
    relativeLayoutParams.put(Attributes.View.CenterInParent.getName(), RelativeLayout.CENTER_IN_PARENT);
    relativeLayoutParams.put(Attributes.View.CenterVertical.getName(), RelativeLayout.CENTER_VERTICAL);
    relativeLayoutParams.put(Attributes.View.ToEndOf.getName(), RelativeLayout.END_OF);
    relativeLayoutParams.put(Attributes.View.ToLeftOf.getName(), RelativeLayout.LEFT_OF);
    relativeLayoutParams.put(Attributes.View.ToRightOf.getName(), RelativeLayout.RIGHT_OF);
    relativeLayoutParams.put(Attributes.View.ToStartOf.getName(), RelativeLayout.START_OF);
    StringAttributeProcessor<V> relativeLayoutProcessor = new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int id = IdGenerator.getInstance().getUnique(attributeValue);
            Integer rule = relativeLayoutParams.get(attributeKey);
            ParseHelper.addRelativeLayoutRule(view, rule, id);
        }
    };
    StringAttributeProcessor<V> relativeLayoutBooleanProcessor = new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int trueOrFalse = ParseHelper.parseRelativeLayoutBoolean(attributeValue);
            ParseHelper.addRelativeLayoutRule(view, relativeLayoutParams.get(attributeKey), trueOrFalse);
        }
    };
    addHandler(Attributes.View.Above, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignBaseline, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignBottom, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignEnd, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignLeft, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignRight, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignStart, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignTop, relativeLayoutProcessor);
    addHandler(Attributes.View.Below, relativeLayoutProcessor);
    addHandler(Attributes.View.ToEndOf, relativeLayoutProcessor);
    addHandler(Attributes.View.ToLeftOf, relativeLayoutProcessor);
    addHandler(Attributes.View.ToRightOf, relativeLayoutProcessor);
    addHandler(Attributes.View.ToStartOf, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignParentBottom, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentEnd, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentLeft, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentRight, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentStart, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentTop, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.CenterHorizontal, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.CenterInParent, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.CenterVertical, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.Animation, new TweenAnimationResourceProcessor<V>(context) {
        public void setAnimation(V view, Animation animation) {
            view.setAnimation(animation);
        }
    });
}

Output:
     });
-    addHandler(Attributes.View.PaddingRight, new StringAttributeProcessor<V>() {
+    addHandler(Attributes.View.PaddingRight, new DimensionAttributeProcessor<V>() {


Input:
public void contextInitialized(ServletContextEvent sce) {
    ConfigurableApplicationContext context = ApplicationContextManager.getApplicationContext();
    DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getBeanFactory();
    ConnectorInstanceDAO connectorInstanceDAO = (ConnectorInstanceDAO) context.getBean("String_Node_Str");
    SyncopeConfigurationDAO syncopeConfigurationDAO = (SyncopeConfigurationDAO) context.getBean("String_Node_Str");
    SyncopeConfiguration syncopeConfiguration = syncopeConfigurationDAO.find("String_Node_Str");
    List<ConnectorInstance> instances = connectorInstanceDAO.findAll();
    Set<PropertyTO> properties = null;
    for (ConnectorInstance instance : instances) {
        try {
            properties = (Set<PropertyTO>) ConnectorInstanceDataBinder.buildFromXML(instance.getXmlConfiguration());
            ConnectorInfoManager manager = ConnectorInstanceController.getConnectorManager(syncopeConfiguration.getConfValue());
            ConnectorFacade connector = ConnectorInstanceController.getConnectorFacade(manager, instance.getBundleName(), instance.getVersion(), instance.getConnectorName(), properties);
            if (log.isInfoEnabled()) {
                log.info("String_Node_Str" + connector);
            }
            beanFactory.registerSingleton(instance.getId().toString(), connector);
            if (log.isInfoEnabled()) {
                log.info("String_Node_Str" + instance.getId().toString());
            }
        } catch (Throwable t) {
            log.error("String_Node_Str", t);
        }
    }
}

Output:
     SyncopeConfigurationDAO syncopeConfigurationDAO = (SyncopeConfigurationDAO) context.getBean("String_Node_Str");
-    SyncopeConfiguration syncopeConfiguration = syncopeConfigurationDAO.find("String_Node_Str");
+    SyncopeConfiguration syncopeConfiguration = null;
+    try {
+        syncopeConfiguration = syncopeConfigurationDAO.find("String_Node_Str");
+    } catch (MissingConfKeyException e) {
+        log.error("String_Node_Str", e);
+    }
     List<ConnectorInstance> instances = connectorInstanceDAO.findAll();


Input:
public void write(RowMutations mutation, String columnFamily) {
    try {
        addColumnFamilyToTable(table.getName(), columnFamily);
        write(mutation);
    } catch (IOException e) {
        LOGGER.warn("String_Node_Str" + columnFamily, e);
    }
}

Output:
         write(mutation);
-    } catch (IOException e) {
+    } catch (final IOException e) {
         LOGGER.warn("String_Node_Str" + columnFamily, e);


Input:
private void handleHyperlinkAction(IArea area, ContainerPosition curPos) {
    IContent content = area.getContent();
    if (null != content) {
        int areaX = curPos.x + area.getX();
        int areaY = curPos.y + area.getY();
        IHyperlinkAction hlAction = content.getHyperlinkAction();
        if (null != hlAction)
            try {
                switch(hlAction.getType()) {
                    case IHyperlinkAction.ACTION_BOOKMARK:
                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(areaX), layoutPointY2PDF(areaY + area.getHeight()), layoutPointX2PDF(areaX + area.getWidth()), layoutPointY2PDF(areaY), createPdfAction(hlAction.getHyperlink(), hlAction.getBookmark(), hlAction.getTargetWindow(), IHyperlinkAction.ACTION_BOOKMARK)));
                        break;
                    case IHyperlinkAction.ACTION_HYPERLINK:
                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(areaX), layoutPointY2PDF(areaY + area.getHeight()), layoutPointX2PDF(areaX + area.getWidth()), layoutPointY2PDF(areaY), createPdfAction(hlAction.getHyperlink(), null, hlAction.getTargetWindow(), IHyperlinkAction.ACTION_HYPERLINK)));
                        break;
                    case IHyperlinkAction.ACTION_DRILLTHROUGH:
                        Action act = new Action(hlAction);
                        IHTMLActionHandler actionHandler = new HTMLActionHandler();
                        String link = actionHandler.getURL(act, context);
                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(areaX), layoutPointY2PDF(areaY + area.getHeight()), layoutPointX2PDF(areaX + area.getWidth()), layoutPointY2PDF(areaY), createPdfAction(link.toString(), null, hlAction.getTargetWindow(), IHyperlinkAction.ACTION_DRILLTHROUGH)));
                        break;
                }
            } catch (Exception e) {
                logger.log(Level.WARNING, e.getMessage(), e);
            }
    }
}

Output:
                         Action act = new Action(hlAction);
-                        IHTMLActionHandler actionHandler = new HTMLActionHandler();
+                        IHTMLActionHandler actionHandler = null;
+                        Object ac = services.getOption(RenderOptionBase.ACTION_HANDLER);
+                        if (ac != null && ac instanceof IHTMLActionHandler) {
+                            actionHandler = (IHTMLActionHandler) ac;
+                        }
                         String link = actionHandler.getURL(act, context);


Input:
private synchronized void kickIdlePlayer(Player player) {
    if (player.isOnline()) {
        log.info("String_Node_Str" + player.getName());
        player.kickPlayer(playerKickMessage);
        if ((broadcastKickMessage != null) && (!broadcastKickMessage.isEmpty())) {
            plugin.getServer().broadcastMessage(ChatColor.YELLOW + player.getName() + "String_Node_Str" + broadcastKickMessage);
        }
    }
}

Output:
     if (player.isOnline()) {
-        log.info("String_Node_Str" + player.getName());
+        log.info("String_Node_Str" + player.getName() + "String_Node_Str");
         player.kickPlayer(playerKickMessage);


Input:
public Data get(Object k) {
    final NodeEngine nodeEngine = getNodeEngine();
    Data key = nodeEngine.toData(k);
    return getInternal(key);
}

Output:
 public Data get(Object k) {
-    final NodeEngine nodeEngine = getNodeEngine();
-    Data key = nodeEngine.toData(k);
+    Data key = getService().toData(k);
     return getInternal(key);


Input:
private void readFromTransport() {
    try {
        try {
            byteRead = (byte) _input.read();
        } catch (Exception e) {
            if (!isHalted) {
                clearInputStream();
                if (_adapter != null && !_adapter.isEnabled()) {
                    disconnect("String_Node_Str", new SdlException("String_Node_Str", e, SdlExceptionCause.BLUETOOTH_DISABLED));
                } else {
                    disconnect("String_Node_Str", e);
                }
            }
            return;
        }
        stateProgress = psm.handleByte(byteRead);
        if (!stateProgress) {
            psm.reset();
            if (byteRead == -1) {
                if (!isHalted) {
                    DebugTool.logError("String_Node_Str");
                    disconnect("String_Node_Str", null);
                }
            }
        }
        if (psm.getState() == SdlPsm.FINISHED_STATE) {
            handleReceivedPacket((SdlPacket) psm.getFormedPacket());
            psm.reset();
        }
    } catch (Exception excp) {
        if (!isHalted) {
            clearInputStream();
            String errString = "String_Node_Str" + excp.toString();
            DebugTool.logError(errString, excp);
            disconnect(errString, excp);
        }
        return;
    }
}

Output:
         try {
-            byteRead = (byte) _input.read();
+            bytesRead = _input.read(buffer);
         } catch (Exception e) {


Input:
public Feature newInstance() throws IllegalStateException {
    if (isAbstract) {
        throw new IllegalStateException(Errors.format(Errors.Keys.AbstractType_1, getName()));
    }
    return isSparse ? new SparseFeature(this) : new DenseFeature(this);
}

Output:
     if (isAbstract) {
-        throw new IllegalStateException(Errors.format(Errors.Keys.AbstractType_1, getName()));
+        throw new FeatureInstantiationException(Errors.format(Errors.Keys.AbstractType_1, getName()));
     }


Input:
private int buildWithClasspath(ExecutionContext context, ProjectFilesystem filesystem, BuildTarget invokingRule, ImmutableList<String> options, ImmutableSortedSet<Path> javaSourceFilePaths, Path pathToSrcsList, JavaCompiler compiler, Optional<Path> usedClassesFile, StandardJavaFileManager fileManager, Iterable<? extends JavaFileObject> compilationUnits) {
    try {
        filesystem.writeLinesToPath(FluentIterable.from(javaSourceFilePaths).transform(Functions.toStringFunction()).transform(ARGFILES_ESCAPER), pathToSrcsList);
    } catch (IOException e) {
        context.logError(e, "String_Node_Str", pathToSrcsList);
        return 1;
    }
    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
    List<String> classNamesForAnnotationProcessing = ImmutableList.of();
    Writer compilerOutputWriter = new PrintWriter(context.getStdErr());
    ClassUsageTracker classTracker = new ClassUsageTracker();
    final StandardJavaFileManager maybeWrappedFileManager = usedClassesFile.isPresent() ? classTracker.wrapFileManager(fileManager) : fileManager;
    JavaCompiler.CompilationTask compilationTask = compiler.getTask(compilerOutputWriter, maybeWrappedFileManager, diagnostics, options, classNamesForAnnotationProcessing, compilationUnits);
    boolean isSuccess = false;
    BuckTracing.setCurrentThreadTracingInterfaceFromJsr199Javac(new BuckTracingEventBusBridge(context.getBuckEventBus(), invokingRule));
    try {
        try (TranslatingJavacPhaseTracer tracer = TranslatingJavacPhaseTracer.setupTracing(invokingRule, context.getClassLoaderCache(), context.getBuckEventBus(), compilationTask);
            ProcessorBundle bundle = prepareProcessors(context.getBuckEventBus(), compiler.getClass().getClassLoader(), invokingRule, options)) {
            compilationTask.setProcessors(bundle.processors);
            isSuccess = compilationTask.call();
        } catch (IOException e) {
            LOG.warn(e, "String_Node_Str");
        }
    } finally {
        BuckTracing.clearCurrentThreadTracingInterfaceFromJsr199Javac();
    }
    for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
        LOG.debug("String_Node_Str", DiagnosticPrettyPrinter.format(diagnostic));
    }
    if (isSuccess) {
        if (usedClassesFile.isPresent()) {
            ClassUsageFile.writeFromTrackerData(filesystem, filesystem.resolve(usedClassesFile.get()), classTracker, context.getObjectMapper());
        }
        return 0;
    } else {
        if (context.getVerbosity().shouldPrintStandardInformation()) {
            int numErrors = 0;
            int numWarnings = 0;
            for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
                Diagnostic.Kind kind = diagnostic.getKind();
                if (kind == Diagnostic.Kind.ERROR) {
                    ++numErrors;
                    handleMissingSymbolError(invokingRule, diagnostic, context, filesystem);
                } else if (kind == Diagnostic.Kind.WARNING || kind == Diagnostic.Kind.MANDATORY_WARNING) {
                    ++numWarnings;
                }
                context.getStdErr().println(DiagnosticPrettyPrinter.format(diagnostic));
            }
            if (numErrors > 0 || numWarnings > 0) {
                context.getStdErr().printf("String_Node_Str", numErrors, numWarnings);
            }
        }
        return 1;
    }
}

Output:
         try (TranslatingJavacPhaseTracer tracer = TranslatingJavacPhaseTracer.setupTracing(invokingRule, context.getClassLoaderCache(), context.getBuckEventBus(), compilationTask);
-            ProcessorBundle bundle = prepareProcessors(context.getBuckEventBus(), compiler.getClass().getClassLoader(), invokingRule, options)) {
+            ProcessorBundle bundle = prepareProcessors(context.getBuckEventBus(), compiler.getClass().getClassLoader(), context.getClassLoaderCache(), safeAnnotationProcessors, invokingRule, options)) {
             compilationTask.setProcessors(bundle.processors);


Input:
public void setACLExpression(Expression expr) throws SemanticException {
    if (this.columnHintHandle != null)
        columnHintHandle.setExpressionProperty(ColumnHint.ACL_EXPRESSION_MEMBER, expr);
    else
        columnHint.setExpressionProperty(ColumnHint.ACL_EXPRESSION_MEMBER, expr);
}

Output:
     else
-        columnHint.setExpressionProperty(ColumnHint.ACL_EXPRESSION_MEMBER, expr);
+        columnHint.setProperty(ColumnHint.ACL_EXPRESSION_MEMBER, expr);
 }


Input:
void handleRemoveProperty() {
    Parameter selectedProperty = getSelectedProperty();
    assert (selectedProperty != null);
    parameterMap.remove(selectedProperty.getName());
    this.propertiesViewer.refresh();
    if (this.wsProfileDetailsWizardPage != null) {
        wsProfileDetailsWizardPage.urlPreviewText.setText(wsProfileDetailsWizardPage.updateUrlPreview().toString());
    } else {
        propertyPage.urlPreviewText.setText(wsProfileDetailsWizardPage.updateUrlPreview().toString());
    }
}

Output:
     } else {
-        propertyPage.urlPreviewText.setText(wsProfileDetailsWizardPage.updateUrlPreview().toString());
+        propertyPage.setParameterMap(this.parameterMap);
+        propertyPage.getExtraProperties().remove(Parameter.PREFIX + selectedProperty.getName());
+        propertyPage.urlPreviewText.setText(propertyPage.updateUrlPreview().toString());
     }


Input:
private Set commitDanglingTransactions() throws IOException {
    Set committedGtrids = new HashSet();
    Map danglingRecords = TransactionManagerServices.getJournal().collectDanglingRecords();
    if (log.isDebugEnabled())
        log.debug("String_Node_Str" + danglingRecords.size() + "String_Node_Str");
    Iterator it = danglingRecords.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry entry = (Map.Entry) it.next();
        Uid gtrid = (Uid) entry.getKey();
        TransactionLogRecord tlog = (TransactionLogRecord) entry.getValue();
        Set uniqueNames = tlog.getUniqueNames();
        Set danglingTransactions = getDanglingTransactionsInRecoveredXids(uniqueNames, tlog.getGtrid());
        if (log.isDebugEnabled())
            log.debug("String_Node_Str" + gtrid);
        commit(danglingTransactions);
        if (log.isDebugEnabled())
            log.debug("String_Node_Str" + gtrid);
        committedGtrids.add(gtrid);
        Set participatingUniqueNames = filterParticipatingUniqueNamesInRecoveredXids(uniqueNames);
        if (log.isDebugEnabled())
            log.debug("String_Node_Str" + buildUniqueNamesString(participatingUniqueNames) + "String_Node_Str");
        TransactionManagerServices.getJournal().log(Status.STATUS_COMMITTED, tlog.getGtrid(), participatingUniqueNames);
    }
    if (log.isDebugEnabled())
        log.debug("String_Node_Str" + committedGtrids.size() + "String_Node_Str");
    return committedGtrids;
}

Output:
         Set participatingUniqueNames = filterParticipatingUniqueNamesInRecoveredXids(uniqueNames);
-        if (log.isDebugEnabled())
-            log.debug("String_Node_Str" + buildUniqueNamesString(participatingUniqueNames) + "String_Node_Str");
-        TransactionManagerServices.getJournal().log(Status.STATUS_COMMITTED, tlog.getGtrid(), participatingUniqueNames);
+        if (participatingUniqueNames.size() > 0) {
+            if (log.isDebugEnabled())
+                log.debug("String_Node_Str" + gtrid + "String_Node_Str" + buildUniqueNamesString(participatingUniqueNames) + "String_Node_Str");
+            TransactionManagerServices.getJournal().log(Status.STATUS_COMMITTED, tlog.getGtrid(), participatingUniqueNames);
+        } else {
+            if (log.isDebugEnabled())
+                log.debug("String_Node_Str" + gtrid + "String_Node_Str");
+            committedGtrids.remove(gtrid);
+        }
     }


Input:
protected void _constrainObject(ConstraintType constraintType, Object source, List sinkList) throws IllegalActionException {
    if (constraintType == null)
        constraintType = ConstraintType.SOURCE_GE_SINK;
    for (Object sink : sinkList) {
        switch(constraintType) {
            case NONE:
                break;
            case EQUALS:
                setSameAs(source, sink);
                break;
            case SINK_GE_SOURCE:
            case SOURCE_GE_SINK:
                setAtLeast(source, sink);
                break;
        }
    }
}

Output:
         constraintType = ConstraintType.SOURCE_GE_SINK;
-    for (Object sink : sinkList) {
+    for (Object source : sourceList) {
         switch(constraintType) {


Input:
protected void populateItem(final ListItem item) {
    String mandatoryCondition = schemaTO.getMandatoryCondition();
    boolean required = false;
    if (mandatoryCondition.equalsIgnoreCase("String_Node_Str"))
        required = true;
    if (schemaTO.getType().getClassName().equals("String_Node_Str")) {
        panel = new AjaxTextFieldPanel("String_Node_Str", schemaTO.getName(), new Model() {
            public Serializable getObject() {
                return (String) item.getModelObject();
            }
            public void setObject(Serializable object) {
                item.setModelObject((String) object);
            }
        }, required);
    } else if (schemaTO.getType().getClassName().equals("String_Node_Str")) {
        panel = new AjaxCheckBoxPanel("String_Node_Str", schemaTO.getName(), new Model() {
            public Serializable getObject() {
                return "String_Node_Str";
            }
            public void setObject(Serializable object) {
                Boolean val = (Boolean) object;
                item.setModelObject(val.toString());
            }
        }, required);
    } else if (schemaTO.getType().getClassName().equals("String_Node_Str")) {
        panel = new DateFieldPanel("String_Node_Str", schemaTO.getName(), new Model() {
            public Serializable getObject() {
                DateFormat formatter = new SimpleDateFormat(schemaTO.getConversionPattern());
                Date date = new Date();
                try {
                    String dateValue = (String) item.getModelObject();
                    formatter = new SimpleDateFormat(schemaTO.getConversionPattern());
                    if (!dateValue.equals("String_Node_Str"))
                        date = formatter.parse(dateValue);
                    else
                        date = null;
                } catch (ParseException ex) {
                    Logger.getLogger(UserModalPage.class.getName()).log(Level.SEVERE, null, ex);
                }
                return date;
            }
            public void setObject(Serializable object) {
                Date date = (Date) object;
                Format formatter = new SimpleDateFormat(schemaTO.getConversionPattern());
                String val = formatter.format(date);
                item.setModelObject(val);
            }
        }, schemaTO.getConversionPattern(), required);
    }
    item.add(panel);
}

Output:
             }
-        }, schemaTO.getConversionPattern(), required);
+        }, schemaTO.getConversionPattern(), required, schemaTO.isReadonly(), form);
     }


Input:
public void writeImage(InputStream stream, String filePath) throws IOException {
    String inputData = IOUtils.toString(stream, "String_Node_Str");
    String[] imageData = inputData.split("String_Node_Str");
    String[] encodedData = imageData[1].split("String_Node_Str");
    String[] mimeData = imageData[0].split("String_Node_Str");
    String fileExtension = mimeData[1].split("String_Node_Str")[1];
    BufferedImage image = ImageIO.read(new ByteArrayInputStream(Base64.getDecoder().decode(encodedData[1])));
    ImageIO.write(image, fileExtension, Files.newOutputStream(Paths.get(Application.BASE_PATH + filePath)));
}

Output:
     BufferedImage image = ImageIO.read(new ByteArrayInputStream(Base64.getDecoder().decode(encodedData[1])));
-    ImageIO.write(image, fileExtension, Files.newOutputStream(Paths.get(Application.BASE_PATH + filePath)));
+    Path path = Paths.get(getPath(relativePath));
+    Path parentDir = path.getParent();
+    if (!Files.exists(parentDir)) {
+        Files.createDirectories(parentDir);
+    }
+    ImageIO.write(image, fileExtension, Files.newOutputStream(path));
 }


Input:
public void testAttributionDefaultAutowire() throws FileNotFoundException, IOException {
    attributionPropertyTester("String_Node_Str", 4);
}

Output:
 public void testAttributionDefaultAutowire() throws FileNotFoundException, IOException {
-    attributionPropertyTester("String_Node_Str", 4);
+    Configuration configuration = configurationLoader("String_Node_Str");
+    commonPropertyTester(configuration, 4);
 }


Input:
public void performRequest(ReportRequest request) {
    if (ReportRequest.OPEN_EDITOR.equals(request.getType()) && (request.getSelectionModelList().size() == 1)) {
        if (request.getSelectionModelList().get(0) instanceof MasterPageHandle) {
            handleOpenMasterPage(request);
            return;
        }
        if (request.getSelectionModelList().get(0) instanceof ScriptObjectNode) {
            handleOpenScriptPage(request);
            return;
        }
    }
}

Output:
         if (request.getSelectionModelList().get(0) instanceof ScriptObjectNode) {
-            handleOpenScriptPage(request);
+            ScriptObjectNode node = (ScriptObjectNode) request.getSelectionModelList().get(0);
+            if (node.getParent() instanceof PropertyHandle) {
+                PropertyHandle proHandle = (PropertyHandle) node.getParent();
+                if (proHandle.getElementHandle().getModuleHandle().equals(getModel())) {
+                    handleOpenScriptPage(request);
+                }
+            }
             return;


Input:
public org.hl7.fhir.dstu2.model.OperationDefinition convertOperationDefinition(org.hl7.fhir.dstu3.model.OperationDefinition src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.OperationDefinition tgt = new org.hl7.fhir.dstu2.model.OperationDefinition();
    copyDomainResource(src, tgt);
    tgt.setUrl(src.getUrl());
    tgt.setVersion(src.getVersion());
    tgt.setName(src.getName());
    tgt.setStatus(convertConformanceResourceStatus(src.getStatus()));
    tgt.setKind(convertOperationKind(src.getKind()));
    tgt.setExperimental(src.getExperimental());
    tgt.setDate(src.getDate());
    tgt.setPublisher(src.getPublisher());
    for (org.hl7.fhir.dstu3.model.OperationDefinition.OperationDefinitionContactComponent t : src.getContact()) tgt.addContact(convertOperationDefinitionContactComponent(t));
    tgt.setDescription(src.getDescription());
    tgt.setRequirements(src.getRequirements());
    tgt.setIdempotent(src.getIdempotent());
    tgt.setCode(src.getCode());
    tgt.setNotes(src.getComment());
    tgt.setBase(convertReference(src.getBase()));
    tgt.setSystem(src.getSystem());
    for (org.hl7.fhir.dstu3.model.CodeType t : src.getType()) tgt.addType(t.getValue());
    tgt.setInstance(src.getInstance());
    for (org.hl7.fhir.dstu3.model.OperationDefinition.OperationDefinitionParameterComponent t : src.getParameter()) tgt.addParameter(convertOperationDefinitionParameterComponent(t));
    return tgt;
}

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


Input:
private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.writeObject(SERIALIZED_FORM_VERSION);
    stream.writeObject(Long.valueOf(creationTime));
    stream.writeObject(Long.valueOf(lastAccessedTime));
    stream.writeObject(Integer.valueOf(maxInactiveInterval));
    stream.writeObject(Boolean.valueOf(isNew));
    stream.writeObject(Boolean.valueOf(isValid));
    stream.writeObject(Long.valueOf(thisAccessedTime));
    boolean serialPrincipal = false;
    if (principal instanceof java.io.Serializable) {
        serialPrincipal = true;
        stream.writeObject(principal);
    }
    stream.writeObject(id);
    if (debug >= 2)
        log("String_Node_Str" + id);
    if (serialPrincipal && authType != null) {
        stream.writeObject(authType);
    }
    String[] keys = keys();
    ArrayList<String> saveNames = new ArrayList<String>();
    ArrayList<Object> saveValues = new ArrayList<Object>();
    for (int i = 0; i < keys.length; i++) {
        Object value = attributes.get(keys[i]);
        if (value == null) {
            continue;
        } else if (isSerializable(value)) {
            saveNames.add(keys[i]);
            saveValues.add(value);
        } else {
            removeAttribute(keys[i], true, true);
        }
    }
    int n = saveNames.size();
    stream.writeObject(Integer.valueOf(n));
    for (int i = 0; i < n; i++) {
        stream.writeObject(saveNames.get(i));
        Object val = saveValues.get(i);
        Boolean serSuccess = checkedSerializableObjects.getIfPresent(val);
        try {
            if (serSuccess == null) {
                ManagerBase mgr = (ManagerBase) getManager();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                try (ObjectOutputStream oos = mgr.createObjectOutputStream(baos)) {
                    checkedSerializableObjects.put(val, false);
                    oos.writeObject(val);
                    oos.flush();
                    stream.writeObject(SEPARATE_BUFFER_SERIALIZATION);
                    stream.writeObject(baos.toByteArray());
                }
                checkedSerializableObjects.put(val, true);
            } else if (serSuccess == true) {
                stream.writeObject(val);
            } else {
                stream.writeObject(NOT_SERIALIZED);
            }
            if (debug >= 2)
                log("String_Node_Str" + saveNames.get(i) + "String_Node_Str" + saveValues.get(i) + "String_Node_Str");
        } catch (IOException e) {
            if ((e instanceof NotSerializableException || e.getCause() instanceof NotSerializableException) && serSuccess != true) {
                String msg = MessageFormat.format(rb.getString(CANNOT_SERIALIZE_SESSION_EXCEPTION), new Object[] { saveNames.get(i), id });
                log(msg, Level.WARNING);
                stream.writeObject(NOT_SERIALIZED);
                if (debug >= 2)
                    log("String_Node_Str" + saveNames.get(i) + "String_Node_Str");
            } else {
                throw e;
            }
        }
    }
    stream.writeObject(sipAppSessionId);
    stream.writeObject(beKey);
}

Output:
         } catch (IOException e) {
-            if ((e instanceof NotSerializableException || e.getCause() instanceof NotSerializableException) && serSuccess != true) {
+            if ((e instanceof NotSerializableException || e.getCause() instanceof NotSerializableException) && (serSuccess == null || serSuccess == false)) {
                 String msg = MessageFormat.format(rb.getString(CANNOT_SERIALIZE_SESSION_EXCEPTION), new Object[] { saveNames.get(i), id });


Input:
private void setCaptionMode(int captionMode) {
    if (this.captionMode == captionMode) {
        return;
    }
    this.captionMode = captionMode;
    resetCueBuilders();
    if (captionMode == CC_MODE_ROLL_UP || captionMode == CC_MODE_UNKNOWN) {
        cues = null;
    }
}

Output:
     resetCueBuilders();
-    if (captionMode == CC_MODE_ROLL_UP || captionMode == CC_MODE_UNKNOWN) {
+    if (oldCaptionMode == CC_MODE_PAINT_ON || captionMode == CC_MODE_ROLL_UP || captionMode == CC_MODE_UNKNOWN) {
         cues = null;


Input:
private String generateNewQueryFromDQRuler(IElementParameter dqRulerParam) {
    ITDQRuleService rulerService = null;
    try {
        rulerService = (ITDQRuleService) GlobalServiceRegister.getDefault().getService(ITDQRuleService.class);
    } catch (RuntimeException e) {
    }
    if (rulerService != null) {
        IElementParameter typeParam = node.getElementParameter("String_Node_Str");
        IElementParameter dbParam = node.getElementParameter(EParameterName.DBNAME.getName());
        IElementParameter schemaParam = node.getElementParameter(EParameterName.SCHEMA_DB.getName());
        IElementParameter tableParam = node.getElementParameterFromField(EParameterFieldType.DBTABLE);
        IElementParameter whereClause = node.getElementParameter("String_Node_Str");
        List<IMetadataTable> metadataList = null;
        IMetadataTable metadataTable = null;
        if (node instanceof Node) {
            metadataList = ((Node) node).getMetadataList();
            if (metadataList != null && !metadataList.isEmpty()) {
                metadataTable = metadataList.get(0);
            }
        }
        return rulerService.getQueryByRule(dqRulerParam, typeParam, dbParam, schemaParam, tableParam, metadataTable, node.getElementName().contains("String_Node_Str"), whereClause);
    }
    return "String_Node_Str";
}

Output:
         }
-        return rulerService.getQueryByRule(dqRulerParam, typeParam, dbParam, schemaParam, tableParam, metadataTable, node.getElementName().contains("String_Node_Str"), whereClause);
+        return rulerService.getQueryByRule(dqRulerParam, typeParam, dbName, schemaName, tableName, metadataTable, node.getElementName().contains("String_Node_Str"), whereStr);
     }


Input:
protected void createViewer() {
    super.createTable();
    GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1);
    table.setLayoutData(gd);
    gd.heightHint = 80;
    Composite stepUpDownComposite = toolkit.createComposite(mainComposite, SWT.NONE);
    stepUpDownComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true, 1, 1));
    GridLayout layout = new GridLayout(8, false);
    layout.marginTop = 0;
    layout.marginBottom = 0;
    layout.marginHeight = 0;
    stepUpDownComposite.setLayout(layout);
    addButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    addButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    addButton.setToolTipText("String_Node_Str");
    if (isXpath()) {
        addButton.setImage(ImageCache.getCreatedImage(EImage.ADD_NEWXPATH.getPath()));
    } else {
        addButton.setImage(ImageCache.getCreatedImage(EImage.ADD_OBJ.getPath()));
    }
    addButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
        }
        public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
            List<Line> list = (List<Line>) getViewer().getInput();
            Line line = new Line(columns.toArray(new ComplexTableViewerColumn[columns.size()]), getInitValues());
            list.add(line);
            viewer.setSelection(null);
            viewer.refresh();
            viewer.getTable().select(viewer.getTable().getItemCount() - 1);
            markDirty();
        }
    });
    if (isAddMulti()) {
        Button selNewPathButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
        selNewPathButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
        selNewPathButton.setToolTipText("String_Node_Str");
        selNewPathButton.setImage(ImageCache.getCreatedImage(EImage.SELECT_NEWXPATH.getPath()));
        selNewPathButton.addSelectionListener(new SelectionListener() {
            public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
            }
            public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
                xpathDialog = getNewXpathDlgInstance();
                xpathDialog.setConceptName(conceptName);
                xpathDialog.setBlockOnOpen(true);
                xpathDialog.open();
                if (xpathDialog.getReturnCode() == Window.OK) {
                    datamodelName = xpathDialog.getDataModelName();
                    String[] xpaths = xpathDialog.getXpath().split("String_Node_Str");
                    for (String xpath : xpaths) {
                        List<Line> list = (List<Line>) getViewer().getInput();
                        Line line = new Line(columns.toArray(new ComplexTableViewerColumn[columns.size()]), getLineValues(xpath, 0));
                        list.add(line);
                    }
                    viewer.setSelection(null);
                    viewer.refresh();
                    viewer.getTable().select(viewer.getTable().getItemCount() - 1);
                    markDirty();
                }
            }
        });
    }
    deleteButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    deleteButton.setToolTipText("String_Node_Str");
    deleteButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    deleteButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
        }
        public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
            List<Line> input = (List<Line>) viewer.getInput();
            TableItem[] items = viewer.getTable().getSelection();
            for (int i = 0; i < items.length; i++) {
                input.remove(items[i].getData());
            }
            viewer.setInput(input);
            markDirty();
        }
    });
    deleteButton.setImage(ImageCache.getCreatedImage(EImage.DELETE_OBJ.getPath()));
    Button deleteAllButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    deleteAllButton.setToolTipText("String_Node_Str");
    deleteAllButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    deleteAllButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
        }
        public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
            List<Line> items = (List<Line>) viewer.getInput();
            items.clear();
            viewer.refresh();
            markDirty();
        }
    });
    deleteAllButton.setImage(ImageCache.getCreatedImage(EImage.PROGRESS_REMALL.getPath()));
    upButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    upButton.setToolTipText("String_Node_Str");
    upButton.setImage(ImageCache.getCreatedImage(EImage.PREV_NAV.getPath()));
    upButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    upButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
        }
        public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
            int index = viewer.getTable().getSelectionIndex();
            if (index > 0 && index < viewer.getTable().getItemCount()) {
                if (mainPage != null) {
                    mainPage.setComitting(true);
                }
                List<Line> items = (List<Line>) viewer.getInput();
                Line line = items.get(index);
                items.remove(index);
                items.add(index - 1, line);
                viewer.refresh();
                if (mainPage != null) {
                    mainPage.setComitting(false);
                }
                markDirty();
            }
        }
    });
    downButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    downButton.setToolTipText("String_Node_Str");
    downButton.setImage(ImageCache.getCreatedImage(EImage.NEXT_NAV.getPath()));
    downButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    downButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
        }
        public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
            int index = viewer.getTable().getSelectionIndex();
            if (index >= 0 && index < viewer.getTable().getItemCount() - 1) {
                if (mainPage != null) {
                    mainPage.setComitting(true);
                }
                List<Line> items = (List<Line>) viewer.getInput();
                Line line = items.get(index);
                items.remove(index);
                items.add(index + 1, line);
                viewer.refresh();
                if (mainPage != null) {
                    mainPage.setComitting(false);
                }
                markDirty();
            }
        }
    });
    copyButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    copyButton.setToolTipText("String_Node_Str");
    copyButton.setImage(ImageCache.getCreatedImage(EImage.COPY.getPath()));
    copyButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    copyButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            int[] indexs = viewer.getTable().getSelectionIndices();
            List<Line> copyLines = new ArrayList<Line>();
            for (int index : indexs) {
                if (index >= 0 && index <= viewer.getTable().getItemCount() - 1) {
                    List<Line> items = (List<Line>) viewer.getInput();
                    Line line = items.get(index);
                    Line copyLine = line.clone();
                    copyLines.add(copyLine);
                }
            }
            if (indexs.length > 0) {
                HashSet<Button> btns = pastBtns.get(String.valueOf(columns.size()));
                if (btns != null)
                    for (Button btn : btns) {
                        if (btn != null)
                            btn.setEnabled(true);
                    }
                WorkbenchClipboard.getWorkbenchClipboard().setLines(String.valueOf(columns.size()), copyLines);
            }
        }
    });
    pastButton = toolkit.createButton(stepUpDownComposite, "String_Node_Str", SWT.PUSH | SWT.CENTER);
    pastButton.setToolTipText("String_Node_Str");
    pastButton.setImage(ImageCache.getCreatedImage(EImage.PASTE.getPath()));
    pastButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 1));
    pastButton.setEnabled(false);
    pastButton.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
        }
        public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
            if (mainPage != null) {
                mainPage.setComitting(true);
            }
            boolean dirty = false;
            List<Line> items = (List<Line>) viewer.getInput();
            List<Line> cacheLine = WorkbenchClipboard.getWorkbenchClipboard().getLines(String.valueOf(columns.size()));
            List<Line> coloneLine = new ArrayList<Line>();
            for (Line l : cacheLine) {
                coloneLine.add(l.clone());
            }
            if (cacheLine.size() > 0) {
                items.addAll(coloneLine);
                dirty = true;
            }
            viewer.refresh();
            if (mainPage != null) {
                mainPage.setComitting(false);
            }
            if (dirty)
                markDirty();
        }
    });
    HashSet<Button> btns = pastBtns.get(String.valueOf(columns.size()));
    if (btns == null) {
        btns = new HashSet<Button>();
        pastBtns.put(String.valueOf(columns.size()), btns);
    }
    btns.add(pastButton);
    CellEditor[] editors = new CellEditor[columns.size()];
    for (int i = 0; i < columns.size(); i++) {
        if (columns.get(i).isText()) {
            editors[i] = new TextCellEditor(table);
        } else if (columns.get(i).isCombo()) {
            editors[i] = new ComboBoxCellEditor(table, ((ComplexTableViewerColumn) columns.get(i)).getComboValues(), SWT.READ_ONLY);
        } else if (columns.get(i).isXPATH()) {
            editors[i] = new XpathCellEditor(table);
        } else if (columns.get(i).isMultiMessage()) {
            editors[i] = new MultiMessageEditor(table);
            multiMsg.setColumn(table.getColumn(i));
        } else if (columns.get(i).isValidationRule()) {
            editors[i] = new ValidationRuleEditor(table);
            validationRule.setColumn(table.getColumn(i));
        }
    }
    viewer.setCellEditors(editors);
    viewer.setContentProvider(new IStructuredContentProvider() {
        public void dispose() {
        }
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }
        public Object[] getElements(Object inputElement) {
            ArrayList<Line> lines = (ArrayList<Line>) inputElement;
            return lines.toArray(new Line[lines.size()]);
        }
    });
    viewer.setLabelProvider(new ITableLabelProvider() {
        public boolean isLabelProperty(Object element, String property) {
            return false;
        }
        public void dispose() {
        }
        public void addListener(ILabelProviderListener listener) {
        }
        public void removeListener(ILabelProviderListener listener) {
        }
        public String getColumnText(Object element, int columnIndex) {
            Line line = (Line) element;
            if (columnIndex >= 0 && columnIndex < columns.size()) {
                for (KeyValue keyvalue : line.keyValues) {
                    if (keyvalue.key.equals(columns.get(columnIndex).getName())) {
                        String val = keyvalue.value;
                        if (columns.get(columnIndex).isNillable()) {
                            if (columns.get(columnIndex).getNillValue().equals(val))
                                val = columns.get(columnIndex).getNillDisplay();
                        }
                        return val;
                    }
                }
            }
            return "String_Node_Str";
        }
        public Image getColumnImage(Object element, int columnIndex) {
            return null;
        }
    });
    ArrayList<String> columnNames = new ArrayList<String>();
    for (ComplexTableViewerColumn column : columns) {
        columnNames.add(column.getName());
    }
    viewer.setColumnProperties(columnNames.toArray(new String[columnNames.size()]));
    viewer.setCellModifier(new ICellModifier() {
        public boolean canModify(Object element, String property) {
            return editable;
        }
        public void modify(Object element, String property, Object value) {
            if (value instanceof Integer) {
                if (Integer.valueOf(value.toString()) == -1)
                    return;
            }
            TableItem item = (TableItem) element;
            Line line = (Line) item.getData();
            int columnIndex = Arrays.asList(viewer.getColumnProperties()).indexOf(property);
            if (columnIndex >= 0 && columnIndex < viewer.getColumnProperties().length) {
                if (isAColumnWithCombo(columnIndex)) {
                    String[] attrs = columns.get(columnIndex).getComboValues();
                    value = attrs[Integer.parseInt(value.toString())];
                }
                KeyValue kv = line.keyValues.get(columnIndex);
                boolean noChange = kv.value.equals(value.toString());
                kv.value = value.toString();
                viewer.refresh();
                if (!noChange) {
                    markDirty();
                }
            }
        }
        public Object getValue(Object element, String property) {
            int columnIndex = Arrays.asList(viewer.getColumnProperties()).indexOf(property);
            Line line = (Line) element;
            if (isAColumnWithCombo(columnIndex)) {
                String value = line.keyValues.get(columnIndex).value;
                String[] attrs = columns.get(columnIndex).getComboValues();
                return Arrays.asList(attrs).indexOf(value);
            }
            for (KeyValue keyvalue : line.keyValues) {
                if (property.equals(keyvalue.key)) {
                    if (keyvalue.value.equals("String_Node_Str")) {
                        return columns.get(columnIndex).getNillDisplay();
                    }
                    return keyvalue.value;
                }
            }
            return null;
        }
        private boolean isAColumnWithCombo(int columnIdx) {
            return columns.get(columnIdx).isCombo();
        }
    });
    viewer.getTable().addKeyListener(new KeyListener() {
        public void keyPressed(KeyEvent e) {
        }
        public void keyReleased(KeyEvent e) {
            if ((e.stateMask == 0) && (e.character == SWT.DEL) && (viewer.getSelection() != null)) {
                Line line = (Line) ((IStructuredSelection) viewer.getSelection()).getFirstElement();
                List<Line> items = (List<Line>) viewer.getInput();
                items.remove(line);
                viewer.refresh();
                markDirty();
            }
        }
    });
    viewer.getTable().addDisposeListener(new DisposeListener() {
        public void widgetDisposed(DisposeEvent e) {
            HashSet<Button> btns = pastBtns.get(String.valueOf(columns.size()));
            btns.remove(pastButton);
        }
    });
}

Output:
         } else if (columns.get(i).isValidationRule()) {
-            editors[i] = new ValidationRuleEditor(table);
+            editors[i] = createValidationRuleEditor();
             validationRule.setColumn(table.getColumn(i));


Input:
public void sendRosterRemove(String user) throws IOException {
    Roster r = getRoster();
    RosterEntry re = r.getEntry(user);
    try {
        r.removeEntry(re);
    } catch (XMPPException e) {
        e.printStackTrace();
    }
}

Output:
     RosterEntry re = r.getEntry(user);
-    try {
-        r.removeEntry(re);
-    } catch (XMPPException e) {
-        e.printStackTrace();
-    }
+    r.removeEntry(re);
 }


Input:
public AcceptorEventHandler start(int port, final AssetTree asset) throws IOException {
    eg.start();
    AcceptorEventHandler eah = new AcceptorEventHandler(port, () -> new EngineWireHandler(WireType.wire, asset), VanillaSessionDetails::new);
    eg.addHandler(eah);
    this.eah = eah;
    return eah;
}

Output:
     eg.start();
-    AcceptorEventHandler eah = new AcceptorEventHandler(port, () -> new EngineWireHandler(WireType.wire, asset), VanillaSessionDetails::new);
+    AcceptorEventHandler eah = new AcceptorEventHandler(port, () -> new EngineWireHandler(WireType.wire, asset, isClosed), VanillaSessionDetails::new);
     eg.addHandler(eah);


Input:
public AGLEventListener createGLEventListener(ECommandType type, GLCaleydoCanvas glCanvas, final String sLabel, final IViewFrustum viewFrustum) {
    GeneralManager.get().getLogger().log(new Status(Status.INFO, GeneralManager.PLUGIN_ID, "String_Node_Str" + type + "String_Node_Str" + sLabel + "String_Node_Str"));
    AGLEventListener glEventListener = null;
    switch(type) {
        case CREATE_GL_HEAT_MAP_3D:
            glEventListener = new GLHeatMap(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_PROPAGATION_HEAT_MAP_3D:
            glEventListener = new GLPropagationHeatMap(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_TEXTURE_HEAT_MAP_3D:
            glEventListener = new GLHierarchicalHeatMap(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_PATHWAY_3D:
            glEventListener = new GLPathway(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_PARALLEL_COORDINATES:
            glEventListener = new GLParallelCoordinates(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_GLYPH:
            glEventListener = new GLGlyph(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_GLYPH_SLIDER:
            glEventListener = new GLGlyphSliderView(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_CELL:
            glEventListener = new GLCell(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_BUCKET_3D:
            glEventListener = new GLRemoteRendering(glCanvas, sLabel, viewFrustum, ARemoteViewLayoutRenderStyle.LayoutMode.BUCKET);
            break;
        case CREATE_GL_JUKEBOX_3D:
            glEventListener = new GLRemoteRendering(glCanvas, sLabel, viewFrustum, ARemoteViewLayoutRenderStyle.LayoutMode.JUKEBOX);
            break;
        case CREATE_GL_REMOTE_GLYPH:
            glEventListener = new GLRemoteGlyph(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_RADIAL_HIERARCHY:
            glEventListener = new GLRadialHierarchy(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_HYPERBOLIC:
            glEventListener = new GLHyperbolic(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_HISTOGRAM:
            glEventListener = new GLHistogram(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_DENDROGRAM_HORIZONTAL:
            glEventListener = new GLDendrogramHorizontal(glCanvas, sLabel, viewFrustum);
            break;
        case CREATE_GL_DENDROGRAM_VERTICAL:
            glEventListener = new GLDendrogramVertical(glCanvas, sLabel, viewFrustum);
            break;
        default:
            throw new RuntimeException("String_Node_Str" + type.toString() + "String_Node_Str");
    }
    registerGLEventListenerByGLCanvas(glCanvas, glEventListener);
    return glEventListener;
}

Output:
         case CREATE_GL_DENDROGRAM_HORIZONTAL:
-            glEventListener = new GLDendrogramHorizontal(glCanvas, sLabel, viewFrustum);
+            glEventListener = new GLDendrogram(glCanvas, sLabel, viewFrustum, true);
             break;


Input:
public BufferedImage read(byte[] bytes) throws IOException {
    if (bytes == null) {
        throw new IOException("String_Node_Str" + "String_Node_Str");
    }
    InputStream is = new ByteArrayInputStream(bytes);
    BufferedImage img = ImageIO.read(is);
    closeQuietly(is);
    return img;
}

Output:
     InputStream is = new ByteArrayInputStream(bytes);
-    BufferedImage img = ImageIO.read(is);
-    closeQuietly(is);
-    return img;
+    try {
+        BufferedImage img = Sanselan.getBufferedImage(bytes);
+        return img;
+    } catch (ImageReadException e) {
+        throw new IOException("String_Node_Str", e);
+    } finally {
+        closeQuietly(is);
+    }
 }


Input:
public synchronized void deleteEntry(CatalogItemDtoAbstract<?, ?> entry) {
    if (dto.entries != null)
        dto.entries.remove(entry);
    if (cacheById != null) {
        cacheById.remove(entry.getId());
        cacheByRegisteredTypeName.remove(entry.getRegisteredTypeName());
    }
    if (mgmt != null) {
        mgmt.getRebindManager().getChangeListener().onUnmanaged(entry);
    }
}

Output:
 public synchronized void deleteEntry(CatalogItemDtoAbstract<?, ?> entry) {
-    if (dto.entries != null)
-        dto.entries.remove(entry);
+    dto.removeEntry(entry);
     if (cacheById != null) {


Input:
public boolean converged(final int iteration, final RealPointValuePair previous, final RealPointValuePair current) {
    final double p = previous.getValue();
    final double c = current.getValue();
    final double difference = FastMath.abs(p - c);
    final double size = FastMath.max(FastMath.abs(p), FastMath.abs(c));
    return (difference <= size * getRelativeThreshold() || difference <= getAbsoluteThreshold());
}

Output:
     final double size = FastMath.max(FastMath.abs(p), FastMath.abs(c));
-    return (difference <= size * getRelativeThreshold() || difference <= getAbsoluteThreshold());
+    return difference <= size * getRelativeThreshold() || difference <= getAbsoluteThreshold();
 }


Input:
private void updateStatusLines() {
    if (!mStatus.showStatusLines()) {
        mStatus1.setVisibility(View.INVISIBLE);
        mStatus2.setVisibility(View.INVISIBLE);
    } else if (mCharging != null && mNextAlarm == null) {
        mStatus1.setVisibility(View.VISIBLE);
        mStatus2.setVisibility(View.INVISIBLE);
        mStatus1.setText(mCharging);
        mStatus1.setCompoundDrawablesWithIntrinsicBounds(mChargingIcon, null, null, null);
    } else if (mNextAlarm != null && mCharging == null) {
        mStatus1.setVisibility(View.VISIBLE);
        mStatus2.setVisibility(View.INVISIBLE);
        mStatus1.setText(mNextAlarm);
        mStatus1.setCompoundDrawablesWithIntrinsicBounds(mAlarmIcon, null, null, null);
    } else if (mCharging != null && mNextAlarm != null) {
        mStatus1.setVisibility(View.VISIBLE);
        mStatus2.setVisibility(View.VISIBLE);
        mStatus1.setText(mCharging);
        mStatus1.setCompoundDrawablesWithIntrinsicBounds(mChargingIcon, null, null, null);
        mStatus2.setText(mNextAlarm);
        mStatus2.setCompoundDrawablesWithIntrinsicBounds(mAlarmIcon, null, null, null);
    }
}

Output:
 private void updateStatusLines() {
-    if (!mStatus.showStatusLines()) {
+    if (!mStatus.showStatusLines() || (mCharging == null && mNextAlarm == null)) {
         mStatus1.setVisibility(View.INVISIBLE);


Input:
public JobCancelResult cancelJob() throws IOException {
    synchronized (this.jobSubmitClient) {
        return this.jobSubmitClient.cancelJob(this.jobGraph.getJobID());
    }
}

Output:
 public JobCancelResult cancelJob() throws IOException {
-    synchronized (this.jobSubmitClient) {
-        return this.jobSubmitClient.cancelJob(this.jobGraph.getJobID());
-    }
+    return this.jobSubmitClient.cancelJob(this.jobGraph.getJobID());
 }


Input:
private Monitor findGroupMonitor(String id, Collection<Monitor> monitors, boolean active) {
    for (Monitor monitor : monitors) {
        if (monitor.getId().equals(id)) {
            return monitor;
        } else {
            if (monitor.getAliasToActiveMonitorsMap() != null && active) {
                return findGroupMonitor(id, monitor.getAliasToActiveMonitorsMap().values(), active);
            } else if (monitor.getAliasToInActiveMonitorsMap() != null && !active) {
                return findGroupMonitor(id, monitor.getAliasToInActiveMonitorsMap().values(), active);
            }
        }
    }
    return null;
}

Output:
         } else {
-            if (monitor.getAliasToActiveMonitorsMap() != null && active) {
-                return findGroupMonitor(id, monitor.getAliasToActiveMonitorsMap().values(), active);
-            } else if (monitor.getAliasToInActiveMonitorsMap() != null && !active) {
-                return findGroupMonitor(id, monitor.getAliasToInActiveMonitorsMap().values(), active);
+            if (monitor.getAliasToActiveMonitorsMap() != null) {
+                return findGroupMonitor(id, monitor.getAliasToActiveMonitorsMap().values());
             }


Input:
protected boolean getFurther(int target) {
    return false;
}

Output:
 protected boolean getFurther(int target) {
-    return false;
+    return true;
 }


Input:
public void run() {
    try {
        DataProvider oldDataProvider = creatComparisonLevel.reloadCurrentLevelElement();
        WorkbenchUtils.impactExistingAnalyses(oldDataProvider);
    } catch (ReloadCompareException e) {
        log.error(e, e);
        returnCode.setReturnCode(e.getMessage(), false);
    } catch (PartInitException e) {
        log.error(e, e);
        returnCode.setReturnCode(e.getMessage(), false);
    }
}

Output:
     try {
-        DataProvider oldDataProvider = creatComparisonLevel.reloadCurrentLevelElement();
+        Connection oldDataProvider = creatComparisonLevel.reloadCurrentLevelElement();
+        Property property = PropertyHelper.getProperty(oldDataProvider);
+        if (property != null) {
+            Item newItem = property.getItem();
+            if (newItem != null) {
+                CWMPlugin.getDefault().updateConnetionAliasByName(oldDataProvider, oldDataProvider.getLabel());
+            }
+        }
         WorkbenchUtils.impactExistingAnalyses(oldDataProvider);


Input:
protected void prepareInternal(AbstractSession session) {
    if (isCursorOutputProcedure()) {
        int nFirstOutParameterIndex = -1;
        boolean hasFoundOutCursor = false;
        for (int index = 0; index < parameters.size(); index++) {
            Integer parameterType = (Integer) parameterTypes.elementAt(index);
            if (parameterType == DatasourceCall.OUT_CURSOR) {
                if (hasFoundOutCursor) {
                    throw ValidationException.multipleCursorsNotSupported(toString());
                } else {
                    hasFoundOutCursor = true;
                }
            } else if (parameterType == DatasourceCall.OUT) {
                if (nFirstOutParameterIndex == -1) {
                    nFirstOutParameterIndex = index;
                }
            } else if (parameterType == null) {
                throw ValidationException.wrongUsageOfSetCustomArgumentTypeMethod(toString());
            }
        }
        if (!hasFoundOutCursor && (nFirstOutParameterIndex >= 0)) {
            parameterTypes.setElementAt(DatasourceCall.OUT_CURSOR, nFirstOutParameterIndex);
        }
    }
    for (int i = 0; i < getParameters().size(); i++) {
        Object parameter = getParameters().elementAt(i);
        Integer parameterType = (Integer) getParameterTypes().elementAt(i);
        if (parameterType == MODIFY) {
            DatabaseField field = (DatabaseField) parameter;
            if ((field.getType() == null) || session.getPlatform().shouldUseCustomModifyForCall(field)) {
                getParameterTypes().setElementAt(CUSTOM_MODIFY, i);
            }
        } else if (parameterType == INOUT) {
            setShouldBuildOutputRow(true);
            setIsCallableStatementRequired(true);
            DatabaseField outField = (DatabaseField) ((Object[]) parameter)[1];
            if (outField.getType() == null) {
                DatabaseField typeOutField = getFieldWithTypeFromDescriptor(outField);
                if (typeOutField != null) {
                    outField = (DatabaseField) typeOutField.clone();
                }
            }
            if (outField.getType() != null) {
                OutputParameterForCallableStatement outParameter = new OutputParameterForCallableStatement(outField, session);
                ((Object[]) parameter)[1] = outParameter;
            }
        } else if ((parameterType == OUT) || (parameterType == OUT_CURSOR)) {
            boolean isCursor = parameterType == OUT_CURSOR;
            if (!isCursor) {
                setShouldBuildOutputRow(true);
            }
            setIsCallableStatementRequired(true);
            DatabaseField outField = (DatabaseField) parameter;
            if (outField.getType() == null) {
                DatabaseField typeOutField = getFieldWithTypeFromDescriptor(outField);
                if (typeOutField != null) {
                    outField = (DatabaseField) typeOutField.clone();
                }
            }
            OutputParameterForCallableStatement outParameter = new OutputParameterForCallableStatement(outField, session, isCursor);
            getParameters().setElementAt(outParameter, i);
            getParameterTypes().setElementAt(LITERAL, i);
        }
    }
    if (this.returnsResultSet == FalseUndefinedTrue.Undefined) {
        setReturnsResultSet(!isCallableStatementRequired());
    }
}

Output:
 protected void prepareInternal(AbstractSession session) {
-    if (isCursorOutputProcedure()) {
-        int nFirstOutParameterIndex = -1;
-        boolean hasFoundOutCursor = false;
-        for (int index = 0; index < parameters.size(); index++) {
-            Integer parameterType = (Integer) parameterTypes.elementAt(index);
-            if (parameterType == DatasourceCall.OUT_CURSOR) {
-                if (hasFoundOutCursor) {
-                    throw ValidationException.multipleCursorsNotSupported(toString());
-                } else {
-                    hasFoundOutCursor = true;
-                }
-            } else if (parameterType == DatasourceCall.OUT) {
-                if (nFirstOutParameterIndex == -1) {
-                    nFirstOutParameterIndex = index;
-                }
-            } else if (parameterType == null) {
-                throw ValidationException.wrongUsageOfSetCustomArgumentTypeMethod(toString());
-            }
-        }
-        if (!hasFoundOutCursor && (nFirstOutParameterIndex >= 0)) {
-            parameterTypes.setElementAt(DatasourceCall.OUT_CURSOR, nFirstOutParameterIndex);
-        }
-    }
-    for (int i = 0; i < getParameters().size(); i++) {
-        Object parameter = getParameters().elementAt(i);
-        Integer parameterType = (Integer) getParameterTypes().elementAt(i);
-        if (parameterType == MODIFY) {
-            DatabaseField field = (DatabaseField) parameter;
-            if ((field.getType() == null) || session.getPlatform().shouldUseCustomModifyForCall(field)) {
-                getParameterTypes().setElementAt(CUSTOM_MODIFY, i);
-            }
-        } else if (parameterType == INOUT) {
-            setShouldBuildOutputRow(true);
-            setIsCallableStatementRequired(true);
-            DatabaseField outField = (DatabaseField) ((Object[]) parameter)[1];
-            if (outField.getType() == null) {
-                DatabaseField typeOutField = getFieldWithTypeFromDescriptor(outField);
-                if (typeOutField != null) {
-                    outField = (DatabaseField) typeOutField.clone();
-                }
-            }
-            if (outField.getType() != null) {
-                OutputParameterForCallableStatement outParameter = new OutputParameterForCallableStatement(outField, session);
-                ((Object[]) parameter)[1] = outParameter;
-            }
-        } else if ((parameterType == OUT) || (parameterType == OUT_CURSOR)) {
-            boolean isCursor = parameterType == OUT_CURSOR;
-            if (!isCursor) {
-                setShouldBuildOutputRow(true);
-            }
-            setIsCallableStatementRequired(true);
-            DatabaseField outField = (DatabaseField) parameter;
-            if (outField.getType() == null) {
-                DatabaseField typeOutField = getFieldWithTypeFromDescriptor(outField);
-                if (typeOutField != null) {
-                    outField = (DatabaseField) typeOutField.clone();
-                }
-            }
-            OutputParameterForCallableStatement outParameter = new OutputParameterForCallableStatement(outField, session, isCursor);
-            getParameters().setElementAt(outParameter, i);
-            getParameterTypes().setElementAt(LITERAL, i);
-        }
-    }
-    if (this.returnsResultSet == FalseUndefinedTrue.Undefined) {
-        setReturnsResultSet(!isCallableStatementRequired());
-    }
+    prepareInternalParameters(session);
 }


Input:
public Token subtractR(Token leftArg) throws IllegalActionException {
    LongToken tmp = (LongToken) this.convert(leftArg);
    long result = _value - tmp.getValue();
    return new LongToken(result);
}

Output:
     LongToken tmp = (LongToken) this.convert(leftArg);
-    long result = _value - tmp.getValue();
+    long result = tmp.getValue() - _value;
     return new LongToken(result);


Input:
public void testNullSchemaInvalidEncodingMediaTypeValidator() {
    mediaType.setSchema(null);
    EncodingImpl encoding = new EncodingImpl();
    encoding.setContentType("String_Node_Str");
    Map<String, Encoding> encodingMap = new HashMap<String, Encoding>();
    encodingMap.put("String_Node_Str", encoding);
    mediaType.setEncoding(encodingMap);
    validator.validate(validationHelper, null, mediaType);
    Assert.assertEquals(1, validationHelper.getEventsSize());
}

Output:
     mediaType.setEncoding(encodingMap);
-    validator.validate(validationHelper, null, mediaType);
+    validator.validate(validationHelper, context, mediaType);
     Assert.assertEquals(1, validationHelper.getEventsSize());


Input:
public void removeServerForClient(ClientDTO clientJupiterAlg) {
    int editingSessionId = clientJupiterAlg.getEditingSessionId();
    int siteId = clientJupiterAlg.getSiteId();
    if (editingSessions.containsKey(editingSessionId)) {
        synchronized (editingSessions) {
            editingSessions.get(editingSessionId).remove(Integer.valueOf(siteId));
        }
    }
    if (correspondents.containsKey(siteId)) {
        synchronized (correspondents) {
            correspondents.remove(siteId);
        }
    }
}

Output:
         synchronized (editingSessions) {
-            editingSessions.get(editingSessionId).remove(Integer.valueOf(siteId));
+            List<Integer> serverIds = editingSessions.get(editingSessionId);
+            int idx = serverIds.indexOf(siteId);
+            if (idx > -1) {
+                serverIds.remove(idx);
+            }
+            if (serverIds.size() == 0) {
+                editingSessions.remove(editingSessionId);
+            }
         }


Input:
public void testToString$sameAsBase() throws Exception {
    System.out.println(sut.toString(vf.createURI(BASE)));
}

Output:
 public void testToString$sameAsBase() throws Exception {
-    System.out.println(sut.toString(vf.createURI(BASE)));
+    System.out.println("String_Node_Str" + sut.toString(vf.createURI(BASE)));
 }


Input:
public IResultMetaData getResultMetaData() throws BirtException {
    return null;
}

Output:
 public IResultMetaData getResultMetaData() throws BirtException {
-    return null;
+    return new ResultMetaData(new ResultClass(new ArrayList()));
 }


Input:
public List<AssociationRef> getCustomReferencesFrom(NodeRef node) {
    List<AssociationRef> retrievedAssocs = nodeService.getTargetAssocs(node, RegexQNamePattern.MATCH_ALL);
    return retrievedAssocs;
}

Output:
 public List<AssociationRef> getCustomReferencesFrom(NodeRef node) {
-    List<AssociationRef> retrievedAssocs = nodeService.getTargetAssocs(node, RegexQNamePattern.MATCH_ALL);
-    return retrievedAssocs;
+    return nodeService.getTargetAssocs(node, RegexQNamePattern.MATCH_ALL);
 }


Input:
public void prepareExperimentSeries(ExperimentSeriesRun experimentSeriesRun, Collection<ParameterValue<?>> preparationPVList) {
    if (experimentSeriesRun == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    this.currentExperimentSeriesRun = experimentSeriesRun;
    meController.prepareExperimentSeries(preparationPVList);
    List<ParameterDefinition> observationParameterList = new ArrayList<ParameterDefinition>();
    collectObservationParameters(meDefinition.getRoot(), observationParameterList);
    meController.setObservationParameters(observationParameterList);
}

Output:
     List<ParameterDefinition> observationParameterList = new ArrayList<ParameterDefinition>();
-    collectObservationParameters(meDefinition.getRoot(), observationParameterList);
+    ScenarioDefinitionUtil.collectObservationParameters(meDefinition.getRoot(), observationParameterList);
     meController.setObservationParameters(observationParameterList);


Input:
public <T> CursorResultSet<T> executeQueryWithResultSet(String database, String query, Map<String, Object> bindVars, Class<T> clazz, Boolean calcCount, Integer batchSize) throws ArangoException {
    CursorEntity<T> entity = executeQuery(database, query, bindVars, clazz, calcCount, batchSize, false);
    CursorResultSet<T> rs = new CursorResultSet<T>(database, this, entity, clazz);
    return rs;
}

Output:
     CursorEntity<T> entity = executeQuery(database, query, bindVars, clazz, calcCount, batchSize, false);
-    CursorResultSet<T> rs = new CursorResultSet<T>(database, this, entity, clazz);
-    return rs;
+    return new CursorResultSet<T>(database, this, entity, clazz);
 }


Input:
public void updatePowerStatus() {
    boolean wasPowered = powered;
    powered = worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord);
    if (powered != wasPowered) {
        markDirty();
    }
}

Output:
     if (powered != wasPowered) {
-        markDirty();
+        markDirtyAndMarkForUpdate();
     }


Input:
protected String getContextIdForAccessOutcome(Response response) {
    return AuditRequestContext.getProperty(CONTEXT_ID);
}

Output:
 protected String getContextIdForAccessOutcome(Response response) {
-    return AuditRequestContext.getProperty(CONTEXT_ID);
+    return null;
 }


Input:
public boolean useSchema() {
    boolean useSchema = false;
    if (compType == null) {
        isLoaded = false;
        try {
            load();
        } catch (BusinessException e) {
            ExceptionHandler.process(e);
        }
    }
    PARAMETERType pType;
    EList parameters = compType.getPARAMETERS().getPARAMETER();
    for (Object parameter : parameters) {
        pType = (PARAMETERType) parameter;
        if ("String_Node_Str".equals(pType.getNAME()) && "String_Node_Str".equals(pType.getFIELD()) && !pType.isREADONLY()) {
            useSchema = true;
            break;
        }
    }
    return useSchema;
}

Output:
         pType = (PARAMETERType) parameter;
-        if ("String_Node_Str".equals(pType.getNAME()) && "String_Node_Str".equals(pType.getFIELD()) && !pType.isREADONLY()) {
+        if ("String_Node_Str".equals(pType.getFIELD()) && !pType.isREADONLY() && (pType.getCONTEXT() == null || "String_Node_Str".equals(pType.getCONTEXT()))) {
             useSchema = true;


Input:
public boolean reset() {
    if (this.isUsedMapDBMode()) {
        if (needReconnect((AbstractDB<?>) distinctMap)) {
            distinctMap = initValueForDBMap(StandardDBName.computeProcess.name());
        }
        distinctMap.clear();
        if (needReconnect((AbstractDB<?>) duplicateObjects)) {
            duplicateObjects = initValueForSet(StandardDBName.computeProcessSet.name());
        }
        duplicateObjects.clear();
        drillDownValueCount = 0l;
    } else {
        distinctMap = initValueForDBMap(StandardDBName.computeProcess.name());
        duplicateObjects = initValueForSet(StandardDBName.computeProcessSet.name());
        distinctMap.clear();
        duplicateObjects.clear();
    }
    return super.reset();
}

Output:
     } else {
-        distinctMap = initValueForDBMap(StandardDBName.computeProcess.name());
-        duplicateObjects = initValueForSet(StandardDBName.computeProcessSet.name());
+        distinctMap = new HashMap<>();
+        duplicateObjects = new HashSet<>();
         distinctMap.clear();


Input:
public IType getElementType() {
    if (this.elementType != null) {
        return this.elementType;
    }
    int len = this.valueCount;
    if (len == 0) {
        this.elementType = Types.ANY;
        return this.requiredType = new ArrayType(Types.ANY);
    }
    IType t = this.values[0].getType();
    for (int i = 1; i < len; i++) {
        IType t1 = this.values[i].getType();
        t = Types.combine(t, t1);
        if (t == null) {
            t = Types.ANY;
            break;
        }
    }
    return this.elementType = t;
}

Output:
     if (len == 0) {
-        this.elementType = Types.ANY;
-        return this.requiredType = new ArrayType(Types.ANY);
+        return this.elementType = Types.ANY;
     }


Input:
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    Exception exception = null;
    try {
        super.channelClosed(ctx, e);
    } catch (Exception ex) {
        exception = ex;
    }
    if (log.isDebugEnabled()) {
        log.debug(String.format(currentThread() + "String_Node_Str", e.getChannel()));
    }
    if (ctx.getAttachment() instanceof Callable<?>) {
        ((Callable) ctx.getAttachment()).call();
        ctx.setAttachment(null);
        return;
    }
    connectionsPool.removeAllConnections(ctx.getChannel());
    if (!isClose.get() && ctx.getAttachment() instanceof NettyResponseFuture<?>) {
        NettyResponseFuture<?> future = (NettyResponseFuture<?>) ctx.getAttachment();
        if (Boolean.class.isAssignableFrom(e.getValue().getClass()) && !Boolean.class.cast(e.getValue())) {
            if (remotelyClosed(ctx.getChannel(), future)) {
                return;
            }
        }
        if (future != null && !future.isDone() && !future.isCancelled()) {
            if (config.getMaxTotalConnections() != -1) {
                maxConnections.decrementAndGet();
            }
            try {
                future.getAsyncHandler().onThrowable(exception != null ? exception : new IOException("String_Node_Str"));
            } catch (Throwable t) {
                log.error(String.format(currentThread() + "String_Node_Str"), t);
            }
        }
    }
}

Output:
     }
-    if (ctx.getAttachment() instanceof Callable<?>) {
-        ((Callable) ctx.getAttachment()).call();
+    if (ctx.getAttachment() instanceof AsyncCallable) {
+        ((AsyncCallable) ctx.getAttachment()).call();
         ctx.setAttachment(null);


Input:
public Message receiveSMSForCode(String code) throws SmesXException {
    if (code == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    SmesXSMSReceive receiveSMS = null;
    do {
        receiveSMS = new SmesXSMSReceive();
        receiveSMS.setMarkAsRead(false);
        receiveSMS.setType(UNREAD);
        SmesXResponse response = execute(receiveSMS);
        SmesXOperation operation = response.getOperation();
        if (operation instanceof SmesXSMSReceive) {
            receiveSMS = (SmesXSMSReceive) operation;
            if (receiveSMS.containSMS()) {
                SmesXSMS sms = receiveSMS.getSMS();
                Message message = smsToMessage(sms);
                if (code.equals(message.getCode())) {
                    return message;
                }
                if (receiveSMS.hasMore()) {
                    receiveSMS.setAfterID(sms.getId());
                }
            }
        }
    } while (receiveSMS.hasMore());
    return null;
}

Output:
 public Message receiveSMSForCode(String code) throws SmesXException {
-    if (code == null) {
-        throw new IllegalArgumentException("String_Node_Str");
-    }
-    SmesXSMSReceive receiveSMS = null;
-    do {
-        receiveSMS = new SmesXSMSReceive();
-        receiveSMS.setMarkAsRead(false);
-        receiveSMS.setType(UNREAD);
-        SmesXResponse response = execute(receiveSMS);
-        SmesXOperation operation = response.getOperation();
-        if (operation instanceof SmesXSMSReceive) {
-            receiveSMS = (SmesXSMSReceive) operation;
-            if (receiveSMS.containSMS()) {
-                SmesXSMS sms = receiveSMS.getSMS();
-                Message message = smsToMessage(sms);
-                if (code.equals(message.getCode())) {
-                    return message;
-                }
-                if (receiveSMS.hasMore()) {
-                    receiveSMS.setAfterID(sms.getId());
-                }
-            }
-        }
-    } while (receiveSMS.hasMore());
-    return null;
+    return smsToMessage(receiveRawSMSForCode(code));
 }