org.easetech.easytest.annotation

Annotation Type Param

@Retention(value=RUNTIME)
@Target(value=PARAMETER)
public @interface Param

A parameter level optional annotation that converts the data for EasyTest based test methods to consume. This Annotation gives the ability to pass input parameters to the test method. EasyTest will automatically call the test method as many times as there are number of data sets to be run against that particular method. For example, if the user has specified 5 data set for a single test method, EasyTest will call the method five times, each time providing the test data that was provided by the user.
The annotation is used in conjunction with DataLoader annotation. DataLoader annotation is used to provide test data to the test cases.

The annotation is optional. In case the name of the input parameter provided in the data file(XML, Excel, CSV or custom) is same as the name of the input parameter type then this annotation can be omitted. For eg:
public void testWithStrongParameters(LibraryId id , @Param(name="itemid") ItemId itemId) { .... }
In the above example we have not provided @Param annotation to the input parameter LibraryId. In this case the test parameter name in the test file should be LibraryId. You have to take care that in scenario where the input parameters are of the same type, the names should be different. Thus if you have two input parameters of type LibraryId then you should provide atleast @Param annotation on one of the input parameters. The annotation contains a single mandatory field and one optional field:

• name : the name of the parameter(Mandatory) as is present in the input test data file.
• In case the param annotation is not specified and the Parameter type is Map, Param.DataSupplier simply provides the HashMap instance that was created while loading the data. This HashMap represents a single set of test data for the test method.
• In case the param name is specified along with the Param annotation, the framework will look for the parameter with the specified name in the loaded test data.
  
• convertEmptyToNull : whether the empty string values be converted automatically to Null or whether they should be left as empty.

Moreover, the framework supports PropertyEditors support for strongly typed objects. If you have a custom object and its property editor in the same package, the EasyTest framework will convert the String value to your specified custom object by calling the right property editor and pass an instance of custom object to your test case. This provides the users facility to write test cases such as this :

@Test @DataLoader(filePaths ={ "getItemsData.csv" })
public void testWithStrongParameters(LibraryId id ,@Param(name="itemid") ItemId itemId) { .... }

Example of using Map to get the entire data:

@Test @DataLoader(filePaths= {"getItemsData.csv" })
public void testGetItemsWithoutFileType( Map inputData) {
........ }

The EasyTest framework also supports custom Converters. Converters are a mechanism for the user to translate a map of key/value pair into custom objects that can be passed as input parameters to the test cases. For example, if you want to pass a complex object as input parameter to a test case then you will simply write a custom converter that extends AbstractConverter and will override the Converter.convert(Map) method. You can look at example of CustomConverter here : https://github. com/EaseTech/easytest-core/blob/master/src/test/java/org/easetech/easytest/example/ItemConverter.java
If you want to pass a Collection type, then EasyTest framework provides the functionality to instantiate the Collection class for you and pass in the right generic parameter if possible. For eg. if you have a test method like this :

@Test
public void testArrayList(@Param(name="items") ArrayList<ItemId> items){
Assert.assertNotNull(items);
for(ItemId item : items){
System.out.println("testArrayList : "+item);
}
}
then all you have to do is : pass the list of itemIds as ":" separated list in the test data file(XML, CSV,Excel or custom), for eg: 23:56:908:666
and register an editor or converter for converting the String data to object.
In case the generic type argument to the Collection is a standard Java type(Date, Character, Timestamp, Long, Interger, Float, Double etc) then you don't have to do anything and the framework will take care of converting the String data to the requested type.

Finally, even though the EasyTest framework is compiled with JDK 1.5, it does not stop you from using Java 6 Collection Types in case you are running your code on JRE 6. For using Java 6 Collection type(like Deque , LinkedBlockingDeque etc) in your test cases, all you have to do is register an empty implementation of AbstractConverter in the BeforeClass method. Note that you should pass only the Concrete type as parameter argument while extending the AbstractConverter and not the Abstract type or the interface type. You can always override the default implementation of creating a specific type instance for use in your test cases by overriding the AbstractConverter.instanceOfType() method.

Author:

Anuj Kumar