This chapter describes the X-UP model policy and multiple services for collecting and amalgamating data from defined data sources in an X-UP model.

An X-UP model is developed through X-UP Builder. An X-UP model is composed of metadata and logic classes. Metadata has information on the inputs/outputs and a logic class while a logic class is used for the actual operation of a model. As a certain logic class is stably structured with same interfaces, users can develop multiple applications of equal quality without advanced knowledge.

Automation Model

An automation model expresses the logic for a service as a diagram using a GUI editor. Each expressed diagram is referred to as an invoke, and it obtains data from any data source. The data information for obtaining data is created using the editor and properties view in X-UP Builder. Java class code is automatically generated when an automation model is saved and automatically reflected in the class code when a model is modified in the GUI editor.

The following invokes are provided for automation models in X-UP Builder:

In addition, the following frequently-used functions are provided:

Furthermore, the following branch processing control functions are provided:

Common Invoke Properties

Click the invoke above X-UP Editor to view detailed information in the properties view. All common invoke properties used in an X-UP Builder automation model are shown below.

General

Click the [General] tab in the properties view to see the following screen:

Input Binding / Output Binding

The function of InputBinding/OutputBinding is to bind input/output parameter names and names of parameters determined in a model when executing Invoke diagrams.

 Ex> A parameter name "VAR_IN" can be replaced with "var01" within a model. The name will be changed to "VAR_IN" when calling the procedure. The name will return to "var01" after the procedure invocation.

The user can define a desired parameter name even if an in-out parameter name is fixed. A connection that is created with invoke cannot be deleted. To connect with another parameter, it can be changed through reconnection.

BeforeDataSource

The user can add a desired logic with Java code for just before a legacy connection is established by a data source that's used by the respective invoke.

AfterDataSource

The user can add a desired logic with Java code for just after a legacy connection is established by a data source that's used by the respective invoke.

Exception

The [Exception] tab is a step for performing an invoke's exception handling. The user can add a desired logic with Java code.

Parameter

Data type used in X-UP.
The parameter types are as follows:

• Variable

• DataSet

• File

• Header

Common Properties

The data types used in X-UP have the following basic common properties.

General

The name, alias, visibility, and description can be defined as common elements for all nodes.

InOut

Select a parameter type as a common element for all parameters.

Variable

The variable parameter generates the same type of parameter as an X-API variable.

Schema

Schema has the same properties as other parameters by default, and only the [Schema] tab is defined differently.

The following items can be set in the [Schema] tab under Variable:

• Type: Define the variable parameter type.

  • string / int / float / long / boolean / bigdecimal / date / time / datetime / blob

• Size: Define the variable parameter size.

DataSet

The dataset parameter generates the same type of parameter as an X-API dataset.

Schema

• Import/Export

  A schema defines information on dataset columns. Users can register column information and import/export a schema.

  • You can import information on dataset columns from the three locations presented by the below pictures by clicking the Import button.

  • You can export information on dataset columns in the form of a PlatformData-type XML file by clicking the Export button. The exported files will be stored in your local PC, and you can reuse them for various purposes.

• Copy to Clipboard

  As the name suggests, clicking the [Copy to Clipboard] button will copy a selected dataset schema to the clipboard.

• toLower

  Click the [toLower] button to change all column names to lowercase letters.

• toUpper

  Click the [toUpper] button to change all column names to uppercase letters.

• FirstRow

  The first row function can be utilized when a client must be in standby due to large amounts of data retrieved by invoke. If the defined RowCount is exceeded, you can send in advance a portion of data through com.tobesoft.xplatform.tx.HttpPartPlatformResponse before sending a response to the request through HttpResponse.

File

The file parameter defines file I/O.

Schema

Schema has the same properties as other parameters by default, and only the [Schema] tab is defined differently.

The following items can be set in the [Schema] tab under File:

• Content Type : Define a file's content type.

  Some of the types are shown in the following table:

Header

The header parameter manages HTTP header I/O information.

Schema

Schema has the same properties as other parameters by default, and only the [Schema] tab is defined differently.

The following items can be set in the [Schema] tab under Header:

• Http Header's key: Define the HTTP header key value.

  Some of the types are shown in the following table:

SAP RFC Invoke

SAP RFC Invoke is a component for generating SAP RFC information in a parameter format. When called, the information is retrieved in a variable or a dataset format.

To quickly create an SAP RFC invoke, click [SAP RFC] from the palette. Alternatively, you can click [SAP DataSource] from the X-UP DataSource view and drag and drop a specific function into the editor.

The SAP RFC Invoke dialog (for invoke creation) and the following property tabs are available for an SAP RFC invoke.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• BeforeDataSource

• AfterDataSource

• Exception

SAP RFC Invoke Dialog

The following dialog is displayed when creating an SAP RFC invoke.

InvokeInfo

InvokeInfo displays the information required to run an invoke.

Only the information is output if the in-out information for running an invoke is already fixed like other invokes.

The following information is output in InvokeInfo for SAP RFC invokes.

Select Invoke

A select invoke performs the select function of a database.

To quickly create a select invoke node in X-UP Builder, choose [Select] from the palette. Alternatively, you can click [Table] from the X-UP DataSource view and drag and drop a specific item into the editor.

The following property tabs are available for a select invoke.

• General: Define general information.

• InvokeInfo: Define required information for invoke execution.

• BeforeDataSource: Define pre data source call execution.

• AfterDataSource: Define post data source call execution.

• Exception: Exception handling.

InvokeInfo

All Invoke nodes have an InvokeInfo property tab. InvokeInfo contains information required to run an invoke. The data source name and SQL are entered into Select Invoke.

SQL Input

X-UP automatically generates SQL statements to retrieve data. The generated Select SQL statements retrieve all columns without a where condition. You can automatically modify generated SQL statements as required and retrieve any data. Binding variables in SQL are expressed with a "#" before and after a parameter name.

Parameter Code Assist

When an input parameter is linked to an invoke in the editor, you can use parameter assists in the SQL Edit window.

Data Type Mapping by DBMS

CDATA Support

If special characters are used in an SQL statement, the entire statement is wrapped in a CDATA element when 'Enable Surround CDATA' is selected.

Dynamic SQL Support

iBATIS provides dynamic SQL elements that can be used within mapping syntax to improve the reusability and flexibility of SQL.

Because X-UP supports iBATIS, existing dynamic SQL queries can be used in iBATIS without modification.

Please refer to Dynamic SQL for more information on a variety of dynamic SQL elements.

Event Handler

The event handler is provided in a select invoke and modify invoke, and additional desired logic can be defined in an event by the user.

To add an event handler, right click on the desired node, and then select [Add Event]. The event start and end nodes are added to the respective node when the desired event is selected.

The event handler for a select invoke are as follows:

• onBegin: Called just before an invoke is started.

• onEnd: Called just before returning a generated parameter set after starting an invoke.

Modify Invoke

A modify invoke performs SQL insert, update, and delete functions with an input parameter.

X-UP looks at a dataset's row type during a modify invoke and determines whether to insert, update, or delete the respective row. Although a dataset's row type can be forcibly set, it's generally automatically determined when a row is added, edited, or deleted in a dataset.

The criteria for performing a write in a row are follows:

• Reflect row values in a dataset directly to table records.

• Ignore table records that correspond to a row that does not exist in a dataset.

• Delete table records that correspond to a deleted row in a dataset.

If a particular row in a dataset is present in a table according to these standards, the row is updated. Otherwise, it's inserted. Records that correspond to rows deleted by calling removeRow() or clearData() in the dataset are targeted for deletion.

To quickly create a modify invoke node in X-UP Builder, select [Modify] from the palette. Alternatively, you can click [Table] from the X-UP DataSource view and drag and drop a specific item into the editor.

The following property tabs are available for a modify invoke.

• General

• InvokeInfo

• SqlTypeBinding

• Filtering

• BeforeDataSource

• AfterDataSource

• Exception

InvokeInfo

InvokeInfo contains information required to run a modify invoke.

• DataSource: Select a data source.

• Target DataSet: Select a dataset that is targeted for SQL execution.

• Modify SQL: Define SQL insert/update/delete. The SQL is written in the same manner as a select invoke.

SQL Input

Modify Invoke automatically generates SQL statements for insert, update, and delete.

• Insert: Create an insert query for all columns with respect to the DB schema.

• Update: Create an update query with a where condition for columns with a primary key set in the DB schema.

• Delete: Create a delete query with a where condition for columns with a primary key set in the DB schema.

CDATA Support

If special characters are used in an SQL statement, the entire statement is wrapped in a CDATA element when 'Enable Surround CDATA' is selected.

Dynamic SQL Support

iBATIS provides dynamic SQL elements that can be used within mapping syntax to improve the reusability and flexibility of SQL.

Because X-UP supports iBATIS, existing dynamic SQL queries can be used in iBATIS without grammar modification.

Please refer to Dynamic SQL for more information on a variety of dynamic SQL elements.

SqlTypeBinding

SqlTypeBinding binds a dataset's row type with an SQL syntax.

• Default: Auto-map a dataset’s row type with SQL

  • Normal type row → Execute insert SQL

  • Insert type row → Execute insert SQL

  • Update type row → Execute update SQL

  • Delete type row → Execute delete SQL

Filtering

Filtering is defined when an input parameter value satisfies a particular condition and is to be excluded from a modify action.

• Rule Name: Define a filtering rule name

• Parameter: Select an input parameter

• Comparator: Select a condition

• Value: Input a condition value

Event Handler

• onBegin: Called just before an invoke is started.

• onEnd: Called just before returning a generated parameter set after starting an invoke.

• onBeforeInsert: Called just before executing an insert statement if a row type in a dataset is DataSet.ROW_TYPE_INSERTED.

• onAfterInsert: Called just after executing an insert statement if a row type in a dataset is DataSet.ROW_TYPE_INSERTED.

• onBeforeUpdate: Called just before executing an update statement if a row type in a dataset is DataSet.ROW_TYPE_UPDATED.

• onAfterUpdate: Called just after executing an update statement if a row type in a dataset is DataSet.ROW_TYPE_UPDATED.

• onBeforeDelete: Called just before executing a delete statement if a row type in a dataset is DataSet.ROW_TYPE_DELETED.

• onAfterDelete: Called just after executing a delete statement if a row type in a dataset is DataSet.ROW_TYPE_DELETED.

Procedure Invoke

A procedure invoke calls a database's procedure and function. The invoke inputs datasource and entity information to run a test, and then automatically sets the input and output parameters based on the actual results of the database procedure and function calls.

To quickly create a procedure invoke in X-UP Builder, select [Procedure] from the palette. Alternatively, you can click [Procedure] or [Function] from the X-UP DataSource view and drag and drop a specific item into the editor.

The Procedure Invoke dialog (for invoke creation) and the following property tabs are available for a procedure invoke.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• BeforeDataSource

• AfterDataSource

• Exception

InvokeInfo

InvokeInfo displays the information required to run an invoke.

Only the information is output if the in-out information for running an invoke is already fixed like other invokes such as procedure and model invokes.

The following information is output in InvokeInfo for procedure invokes.

• DataSource: Selected data source. (The data source editor is opened when clicked.)

• Type: PROCEDURE or FUNCTION

• Catalog: Selected catalog.

• Schema: Selected schema.

• Entity: Selected entity.

Procedure Invoke Dialog

The following dialog is displayed when creating a procedure invoke.

• DataSource

  • DataSource: Select a data source. (You can create a new data source if none exists.)

• Select Procedure or Function:

  • Select a procedure or function.

  • Entity: Select the desired entity.

• Information:

  • The selected entity's in-out information is output.

  • However, the output information may differ from reality, and the execution results must be verified with a test.

• Void-type procedure or function:

  • This option can be selected if there are no execution results

  • In this case, the invoke is created without returning the resulting value.

• Enable auto commit mode:

  • Enable auto-commit mode.

• Test:

  • Output test results.

  • The test result is returned when a test value is entered.

OpenApi Invoke

OpenApi Invoke is designed to generate HTTP information in the form of a parameter. It fetches information on HTTP headers and HTML bodies as parameters.

You can create OpenApi Invoke easily in X-UP Builder by dragging the OpenApi item into the editor.

OpenApi Invoke comes with OpenApi Invoke Dialog as well as the following property tabs.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• BeforeDataSource

• AfterDataSource

• Exception

OpenApi Invoke Dialog

The following dialog is launched when you creates OpenApi Invoke.

• DataSource: Select data source (if there is no source available, you can create new one)

• Base Path: A defined URL for the selected data source

• Sub Path: Entered if there is an additional URL attached to a base path

• Input Parameter : Added if there is a URL parameter

  • Post : Check the box if you want to call the selected parameter in the "post" method

• Send only value : Send the value of the parameter during the invocation

Sub-path and Input Parameter

The entire URL used to scrape data from OpenApi represents the following composition.

<Data source HTTP URL> + <SubPath> + <Data source parameter> + <input parameter>

Normally, one site provides the same location for the OpenApi URL and base URL while sub-paths may differ according to services. The base URL is defined in the data source while the sub-paths are defined in each Invoke. Such as a license key, parameters are designed to be defined in a data source if they must be delivered for the invocation of OpenApi but are not input by clients. The parameters input by clients are defined in each Invoke.

Result

Data scraped from OpenApi will become a parameter named "BODY." Moreover, the HTTP header values obtained in response to the data collection will become parameters named "HEADER"+ index. (However, those values will be output as defined in HTTP Response Headers.)

InvokeInfo

Necessary pieces of information for executing an Invoke will be output.

Similarly to other types of Invoke, OpenApi Invoke will output only In-Out information to execute Invoke when the information is predetermined.

The following items are output by the InvokeInfo of OpenApi Invoke.

• DataSource: selected data sources (Clicking a data source will open the editor)

• Base Path: a base path url defined in a selected data source

• Sub Path: selected sub-paths

• Input Parameters: selected essential input parameters

• Send only value: defined send-only values

• http header attribute

• sub paths and input parameters

• url

X-UP Invoke

The X-UP invoke is a component for calling an X-UP model already created and deployed on another server.

The invoke calls a model on a remote X-UP Server, obtains data, and then creates a new parameter.

The following property tabs are available for an X-UP invoke.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• Exception

InvokeInfo

InvokeInfo displays the information required to run an invoke.

Only the information is output if the in-out information for running an invoke is already fixed like other invokes.

The following information is output in InvokeInfo for X-UP invokes.

• DataSource: Selected data source. (The data source editor is opened when clicked.)

• Target Domain: The selected server’s target domain.

• Target Model: Target model to be called in the target domain.

Model Invoke

The model invoke is a component for calling an X-UP model already created on another server.

To quickly create a model invoke in X-UP Builder, select [Model] from the palette. Alternatively, you can drag and drop a specific model from X-UP Explorer into the editor.

The X-UP Model List dialog is displayed when creating a model invoke from the palette, and the following property tabs are available.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• Exception

InvokeInfo

InvokeInfo displays the information required to run a model invoke.

• Name: Output the name of an invoked model.

The model editor is opened when the name is clicked.

If the invoked model's information was changed, it can be updated using the refresh function in the upper-right corner.

OData Invoke

OData invoke utilizes HTTP(S)-based OData to consume data. Data is consumed by the entity set and function import based on CSDL and then retrieved in a parameter format.

To quickly create an OData invoke in X-UP Builder, select [OData] from the palette. Alternatively, you can click [OData DataSource] from the X-UP DataSource view and drag and drop a specific service into the editor.

The OData Invoke dialog (for invoke creation) and the following property tabs are available for an OData invoke.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• BeforeDataSource

• AfterDataSource

• Exception

InvokingInfo

InvokingInfo displays the information required to run an invoke.

Only the information is output if the in-out information for running an invoke is already fixed like other invokes.

The following information is output in InvokeInfo for OData invokes.

• DataSource: Selected data source. (The data source editor is opened when clicked.)

• Service URI: URI excluding the selected service's host.

• Selected Operation List: Names of the selected operation's items.

OData Invoke Dialog

The following dialog is displayed when creating an OData invoke.

• DataSource: Select an OData data source. (You can create a new data source if none exists.)

• Service URI: Invoking service among services on a server providing OData.

• Service List: The selected service's metadata information in a service URI.

• Operations: Target for execution among executable entity sets or function imports.

• Properties: Option values for when an operation is to be executed.

HTTP Method

When an invoke is executed, it's bound with a RESTful HTTP method. The following HTTP methods are supported.

1. GET: Retrieve data. The invoke is bound with the GET HTTP method. Additional settings are available when retrieving data.

• Get Method Option

  • Multi-Value: Retrieve multiple data.

  • Single Value: Retrieve a single datum.

• System Query

  • Provides the default option settings stated in the OData specifications when data is retrieved.

  • The following settings values are provided: $filter, $select, $orderby, $top, $count, $search, $levels

2. POST: Adds data.

3. PUT: Modifies data.

4. DELETE: Deletes data.

Batch Request Support

OData can make REST-type single requests and BATCH-type multiple requests.

A single operation is executed for X-UP, and data is transmitted in REST form only for the GET HTTP method. Otherwise, it is treated as a BATCH form.

In/Out Parameter Information

A selected operation’s I/O information can be displayed. The information is bound to an HTTP method, and it's in an output form if the GET method is selected and in an input form if POST, PUT, or DELETE is selected.

The relationships between OData data types and converted X-UP data are as follows:

User Method Function

The User method allows you to directly write user-defined code when developing a model. The model is actually created in a Java source method, and the desired Java code can be freely defined and added to a model without a Java file.

The following User method properties are provided:

• General: General information

• Source: Java code window

DataSetRowLoop Function

When a single dataset is linked to the DataSetRowLoop function in X-UP Builder's automation model editor, the function repeats (loops) a number of times equal to the number of linked dataset rows and generates events.

After linking a dataset to the DataSetRowLoop function, right-click the DataSetRowLoop component and select [AddEvent > loopEvent] to show the event (Start, End). The Variable-type rowIndex and DataSet-type dataset are extracted as parameters in the Start event.

The following DataSetRowLoop function properties are provided:

• General: General information

• DataSet RowType: Dataset row type configuration window.

  • Normal

  • Inserted

  • Updated

  • Deleted

Quick Merge Function

The quick merge function is a component for generating a new dataset from two datasets.

The following quick merge function properties are available:

• General: General information.

• InvokeInfo: Displays amalgamation information.

• Exception

The amalgamation model development procedure is as follows:

• Set a target dataset.

• Implement amalgamation logic.

Set a target dataset

Set a target dataset to be used for amalgamation. An X-UP model dataset or a dataset passed as a parameter by the user can be set as the target.

Implement amalgamation logic

Amalgamation is available in two forms; One method utilizes the sort merge algorithm, and the other utilizes the hash join algorithm.

Sort Merge: Two datasets are sorted according to the key column input, and amalgamation is performed thereafter. The join type (inner join or outer join) option is provided, and duplicate columns can be excluded from amalgamation. If the two target datasets have already been sorted, the sort option can be disabled.

Hash Merge: A hash table is generated with the two target datasets according to the key column settings, and amalgamation is performed according to the respective values. A join type option is provided similar to the sort merge method.

Quick Merge API

The quick merge API performs in the same manner as its equivalent function.
The following API classes are provided:

• com.tobesoft.xplatform.data.DataSetSortMerger

• com.tobesoft.xplatform.data.DataSetHashMerger

Please refer to the X-UP API documentation for detailed information.

Merge Function

The merge function is a component for generating a new dataset from multiple datasets.

These types of functions are executed by multiple canonicalized datasets with logic expressed by a built-in DBMS as SQL query statements.

The following merge function property tabs are available:

• General: General information.

• InvokeInfo: Output information about SQL query statements that execute merge functions.

• Index: Set up a parameter index column linked to an input parameter.

• Decimal: Decimal place setting. (A big decimal-type in an input parameter is the target.)

• Exception: Exception handling.

The amalgamation model development procedure is as follows:

• Set a target dataset.

• Implement an amalgamation logic and SQL query.

• Generate a new dataset.

Set a target dataset

Set a target dataset to be used for amalgamation. An X-UP model dataset or a dataset passed as a parameter by the user can be set as the target.

Implement an amalgamation logic and SQL query

A built-in DBMS is used for amalgamation in X-UP, and the logic is implemented using the SQL Select syntax. X-UP transmits developer-implemented SQL and a target dataset to the built-in DBMS and processes return values resulting from an SQL retrieval to generate amalgamated raw data.

Generate a new dataset

The raw data amalgamated by the built-in DBMS is converted into a newly-generated dataset rather than simply being returned.

XML Parser Function

The XML Parser function is a component for parsing information to be generated in a parameter format. When called, the information is retrieved in a variable or a dataset format.

The XML Parser Function dialog (for invoke creation) and the following property tabs are available for the XML parser function.

• General

• InvokeInfo

• InputBinding

• OutputBinding

• Exception

InvokeInfo

InvokeInfo displays the information required to run an invoke.

Only the information is output if the in-out information for running an invoke is already fixed like other invokes.

The following information is output in InvokeInfo for the XML parser function.

• Parser List: Defined parser list output.

• Parser Information: Information output for a selected parser.

XML Parser Function Dialog

The following dialog is displayed when creating an XML parser function.

• Parse List: XML parsing list.

• XML Content: Directly input the XML information to be parsed.

• Preview: Preview parsing results.

• Parse Info: Define parsing information for a selected parser.

  • The XML information is displayed in tree form on the left side.

  • XPath: Define the XML path of an item selected from the tree.

  • Const column: Define a const column for a dataset.

  • Condition: Define to parse items that satisfy a certain condition.

  • Options: Input a delimiter for value processing if a duplicate item name exists.

Extract DataSet Function

The Extract DataSet function automatically generates a single dataset from multiple variables linked to the Extract DataSet function as input parameters.

In simpler terms, the function creates a dataset from variables.

If the Extract DataSet function is connected to multiple variables, a dataset is automatically generated and extracted as output values.

• If the variables linked to the Extract DataSet function are updated: The output dataset (created when variables were added or deleted) is deleted, and a new updated dataset is generated.

• If no variables are linked to the Extract DataSet function: The output dataset is deleted.

The following extract dataset function property tabs are available:

• General

Extract Variable Function

The Extract Variable function easily generates output-type variable parameters using a dataset's column values such as column name, column value, and column size.

In simpler terms, the function creates variables from a dataset.

If the Extract Variable function is linked to a dataset, output values (column number, name, type, and size) are automatically extracted from the dataset.

For example, if a dataset contains four columns, four variables are output. Each variable name, type, size, and value correspond to the dataset's column name, type, size, and value.

The following extract variable function property tabs are available:

• General

Decision

The Decision function allows for conditional branch processing. A particular process can be executed if a condition is satisfied.

If, else if, and else conditions are available, and the user can select a connection and modify its condition type.

The following conditional connection properties are available:

• General: Common property for all components.

• Connection Info: Common property for all connection nodes.

• Condition Type: Select if, elseif, or else.

• Source: Input condition logic.

General

The alias, visibility, and description information can be defined in the General property of a conditional connection.

The Visible option does not contain name and alias information unlike the Visible option in other components. Therefore, the option determines whether the alias will be displayed in the middle of the connection.

Connection Info

The Connection Info property is common for all connections, and so the conditional connection is also the same.

Routing: Determines connection routing type. (The lower right image represents the "enabled" setting.)

The user can define the connection shape for a bendpoint routing connection.

Binding: Determines whether a condition type name is displayed for a conditional connection. When unchecked, the if, elseif, and else strings on the connection are hidden.

Condition Type

The user can directly select the condition type.

• If, elseif, and else are available.

Source

The user can define a desired condition logic for the condition code using Java code.

All parameters present on the editor exist in the global parameter set, and therefore, a desired parameter can be retrieved to define a condition logic.

True or false must be returned as a resulting value of the logic.

All Java code editing windows within a property feature the same assist popups and Java grammar error checking functionalities commonly provided in the Java editor.

Repeat Task

The Repeat Task function uses a decision node to implement repeat statements.

A repeat connection is automatically generated when a Decision end node is linked to a Decision start node. Only one condition must exist in such instances. A repeat connection is not established if more than one conditional connection exists.

The break and continue nodes are only available for use in a repeat syntax and can be used at any point in time to continue or stop a loop.

The source code is displayed in “Condition Code” under [Properties] when a break or continue node is selected. The user can define the condition code by right-clicking on the source code and selecting [Edit] from the context menu.

Debug and Break Point

A breakpoint can be added directly into a node from the editor for automation model debugging. When a breakpoint is added to a node, it's automatically registered in a line when the editor generates the source.

Breakpoints can be added individually after selecting each node or added at once by selecting multiple nodes.

Added breakpoints can be deleted using [Remove BreakPoint] from the menu.

Automation model debugging can be mainly conducted in two ways.

• Quick debugging using [Debug] from the editor menu.

• Run debug mode after creating a JUnit test class.