Name Type Since Description File-File to be deployed. User property is: file. String-Server Id to map on the under section of settings.xml In most cases, this parameter will be required for authentication. With the tips above, it’s pretty easy to come up with a password. Just bash your fingers against your keyboard and you can come up with a strong password like 3o(t&gSp&3hZ4#t9. That’s a pretty good one—it’s 16 characters, includes a mix of many different types of characters, and is hard to guess because it’s a series of random characters. In the Primer Pair Specificity Checking Parameters section, select the appropriate source Organism and the smallest Database that is likely to contain the target sequence. These settings give the most precise results. For broadest coverage, choose the nr database and do not specify an organism.

One of the important features of TestNG is parameterization. This feature allows user to pass parameters to tests as arguments. This is supported by using the testng @Parameters annotation.

There are mainly two ways through which we can provide parameter values to testng tests.

1. Through testng.xml XML configuration file
2. Through DataProviders [link]

The @Parameters annotation can be used for any of the @Before, @After, @Factory, and @Test annotated methods. It can be used to initialize variables and use them in a class, test, or may be for the whole test execution.

1. TestNG @Parameters – test parameters with testng.xml

If you need to pass some simple values such as String types to the test methods at runtime, you can use this approach of sending parameter values through testng XML configuration files. You have to use the @Parameters annotation for passing parameter values to the test method.

Let’s write a simple example of passing parameters to test methods through the XML configuration file.

1.1. Tests

In below test, we created a test class with multiple methods that accepts parameters from testng. The parameter values are set at both suite and test level in the testng XML file.

Any parameter value defined at the test level will override the value of a parameter, with same name, if defined at suite level. You can see this in test three for test method prameterTestThree().

1.2. testng.xml

Now add a testng.xml file to the project root and put the following code to it. Here we define the parameter values to be passed.

1.3. Demo

Now run above tests using testng.xml. Output of above test run is given below:

As you can see from the test results, only timeTestTwo() for executed because it’s execution time was less than timeout time defined in testng.xml file. timeTestOne() execution got cancelled because it took more time to complete than timeout duration configured.

2. TestNG @Parameters – Optional parameters

TestNG also provides an option to provide optional parameters, this value will be used if parameter value is not found in the defined file.

2.1. Test with @Optional annotation

To pass optional parameters, use @Optional annotation.

The preceding class file contains a single test method that takes one parameter as input. The said test method on execution prints the parameter value that is passed onto the console using the System.out.println method.

The parameter value is passed to the test method using the parameter named optional-value from the XML file. An optional value for the said parameter is defined using the @Optional annotation against the said parameter.

2.2. Test with @Optional annotation

In this testng.xml file has two tests defined above. No parameter is defined in the first test where as the second test declares a parameter named ‘optional-value‘ in it.

2.3. Demo

Output of running above code as test suite is :

As you can see from the previous test results, TestNG has passed the optional value to the test method during first test execution. This happened because TestNG was unable to find a parameter named optional-value in the XML file from the first test.

During the second test it found the parameter value in the XML and passed the said value to the test method during execution.

Happy Learning !!

Was this post helpful?

Query parameters enable the definition of reusable queries. Such queries can be executed with different parameter values to retrieve different results. Running the same query multiple times with different parameter values (arguments) is more efficient than using a new query string for every query execution, because it eliminates the need for repeated query compilations.

Named Parameters (:name)

The following method retrieves a Country object from the database by its name:

The WHERE clause reduces the query results to Country objects whose name field value is equal to :name, which is a parameter that serves as a placeholder for a real value. Before the query can be executed a parameter value has to be set using the method. The method supports method chaining (by returning the same instance on which it was invoked), so invocation of can be chained to the same expression.

Named parameters can be easily identified in a query string by their special form, which is a colon (:) followed by a valid JPQL identifier that serves as the parameter name. JPA does not provide an API for defining the parameters explicitly (except when using criteria API), so query parameters are defined implicitly by appearing in the query string. The parameter type is inferred by the context. In the above example, a comparison of :name to a field whose type is String indicates that the type of :name itself is String.

Queries can include multiple parameters, and each parameter can occur multiple times in the query string. A query can be run only after setting values for all its parameters (no matter in which order).

Ordinal Parameters (?index)

Setting Up Unique Parameters Types

In addition to named parameters, whose form is :name, JPQL also supports ordinal parameters, whose form is ?index. The following method is equivalent to the method above, except that an ordinal parameter replaces the named parameter:

The form of ordinal parameters is a question mark (?) followed by a positive int number. Apart from the different notation, named parameters and ordinal parameters are identical.

Named parameters can provide added value to the clarity of the query string (assuming that meaningful names are selected). Therefore, they are preferred over ordinal parameters.

Criteria Query Parameters

In a JPA query that is built by using the JPA Criteria API - parameters (as other query elements) are represented by objects (of type or its super interface ) rather than by names or numbers.

See the Parameters in Criteria Queries section for more details.

Parameters vs. Literals

Following is a third version of the same method, this time without parameters:

Setting Up Unique Parameters Meaning

Instead of using a parameter for the queried name, the new method embeds the name as a String literal. There are a few drawbacks to using literals rather than parameters in queries.

First of all, the query is not reusable. Different literal values lead to different query strings, and each query string requires its own query compilation, which is very inefficient. On the other hand, when using parameters, even if a new instance is constructed on every query execution, ObjectDB can identify repeating queries with the same query string and use a cached compiled query program, if available.

Secondly, embedding strings in queries is unsafe and can expose the application to JPQL injection attacks. Suppose that the name parameter is received as an input from the user and then embedded in the query string as is. Instead of a simple country name, a malicious user may provide JPQL expressions that change the query and may help in hacking the system.

In addition, parameters are more flexible and support elements that are unavailable as literals, such as entity objects.

API Parameter Methods

Setting Up Unique Parameters Definition

Over half of the methods in and deal with parameter handling. The Query interface defines 18 such methods, 9 of which are overridden in TypedQuery. That large number of methods is not typical to JPA, which generally excels in its thin and simple API.

There are 9 methods for setting parameters in a query, which is essential whenever using query parameters. In addition, there are 9 methods for extracting parameter values from a query. These get-methods, which are new in JPA 2, are expected to be much less commonly used than the set methods.

Two set methods are demonstrated above - one for setting a named parameter and the other for setting an ordinal parameter. A third method is designated for setting a parameter in a Criteria API query. The reason for having nine set methods rather than just three is that JPA additionally provides three separate methods for setting Date, parameters as well as three separate methods for setting Calendar parameters.

Date and Calendar parameter values require special methods in order to specify what they represent, such as a pure date, a pure time or a combination of date and time, as explained in detail in the Date and Time (Temporal) Types section.

For example, the following invocation passes a Date object as a pure date (no time):

Since . represents a pure date, the time part of the newly constructed java.util.Date instance is discarded. This is very useful in comparison against a specific date, when time should be ignored.

Setting Up Unique Parameters Examples

The get methods support different ways to extract parameters and their values from a query, including by name (for named parameter), by position (for ordinal parameters) by Parameter object (for Criteria API queries), each with or without an expected type. There is also a method for extracting all the parameters as a set (), and a method for checking if a specified parameter has a value (). These methods are not required for running queries and are likely to be less commonly used.