Home
Test Execution Specialist Guide
This guide describes tasks that you can perform on schedules, test execution with custom code, and Extending HCL OneTest™ Performance to support other protocols. This guide is intended for testers or test execution specialists.
Extending test execution with custom code
You can extend how you run your tests by writing custom Java™ code and calling the code from the test. You can also specify that results from the tests that are affected by your custom code be included in reports.
Custom code examples
Custom code enables you to perform such tasks as managing loops, retrieving virtual user information, running external programs from tests, and customizing data correlation.
Reporting custom verification point failures
You can use custom code to report a custom verification point failure.

Test Execution Specialist Guide
This guide describes tasks that you can perform on schedules, test execution with custom code, and Extending HCL OneTest™ Performance to support other protocols. This guide is intended for testers or test execution specialists.
- Running schedules with performance testing
  After you have added the user groups, tests, and other items to a schedule, and you are satisfied that it represents a realistic workload, you run the schedule.
- Extending test execution with custom code
  You can extend how you run your tests by writing custom Java™ code and calling the code from the test. You can also specify that results from the tests that are affected by your custom code be included in reports.
  - Creating custom Java™ code
    Custom code uses references in the test as input and returns modified values to the test. Use the ICustomCode2 interface to create custom code and the ITestExecutionServices interface to extend test execution. These interfaces are contained in the com.ibm.rational.test.lt.kernel.services package.
  - Test execution services interfaces and classes
    You use the test execution services interfaces and classes to customize how you run tests. These interfaces and classes are located in the com.ibm.rational.test.lt.kernel package. Each interface and class is described briefly in this topic and in detail in the Javadoc information.
  - Reducing the performance impact of custom code
    If custom code runs inside a page, it can affect that page's response time.
  - Custom code examples
    Custom code enables you to perform such tasks as managing loops, retrieving virtual user information, running external programs from tests, and customizing data correlation.
    - Controlling loops
      This example demonstrates extending test execution by using custom code to control loops. It provides sample code that shows how you can manipulate the behavior of loops within a test to better analyze and verify test results.
    - Retrieving the IP address of a virtual user
      This example shows how to retrieve the local IP address of a virtual user. Retrieving IP addresses is particularly useful when virtual users are using IP aliases.
    - Printing input arguments to a file
      The PrintArgs class prints its input arguments to the file C:\arguments.out. This class could be used, for example, to print a response returned by the server.
    - Counting the number of times that code is executed
      The CountAllIterations class counts the number of times code is executed by all virtual users. The CountUserIterations class counts the number of times code is executed by an individual virtual user.
    - Setting and clearing cookies for a virtual user
      The SetCookieFixedValue class sets a Cookie for a virtual user, and the ClearCookies class clears all cookies for a virtual user.
    - Determining where a test is running
      The ComputerSpecific class determines where a test is running
    - Determining where a test is running
      The ComputerSpecific class determines where a test is running
    - Extracting a string or token from its input argument
      The ParseResponse class extracts a string from its input argument. The ExtractToken class extracts a particular token (string) from its input argument. Both classes can be useful for handling certain types of dynamic data correlation.
    - Retrieving the maximum JVM heap size
      The JVM_Info class retrieves the maximum heap size of the JVM.
    - Running an external program from a test
      The ExecTest class runs a program, defined in the execName variable, on the system where the test is running.
    - Adding custom counters to reports
      When you want to monitor the specific requirement, you can add custom counters to performance report by using the custom code. After running tests, the results from the custom counters are automatically aggregated in the same way that the default performance testing counters.
    - Using transactions and statistics
      You can use custom code to start transactions, gather additional statistics during a transaction, and stop a transaction.
    - Reporting custom verification point failures
      You can use custom code to report a custom verification point failure.
    - Debugging custom code
      This example demonstrates debugging custom code by adding a breakpoint. It provides sample code to add a breakpoint. This way of debugging custom code is applicable only for a schedule.
    - Accessing the actual schedule name from the custom code
      When there are any special characters in the name of the schedule, you can write the actual name of the schedule in the test log by using the appropriate interface in the custom code.
    - Reading and writing data from a dataset
      When a test is associated with a dataset, you can extend the test either by reading or writing the dataset values from the custom code.
    - Getting the properties of a dataset
      When a test asset is associated with a dataset, you can get the properties of a dataset through a custom code. You can also insert a new row into the dataset.
  - Migrating custom code from previous versions
    You can run scripts that contain custom code from previous releases and edit tests to make new calls to old or new custom code classes.
- Extending HCL OneTest™ Performance to support other protocols
  The HCL OneTest™ Performance Extensibility Software Development Kit (SDK) enables you to create extensions to support testing new protocols without modifying the core product code. You can create an extension that provides functionality for testing other protocols in addition to the HTTP protocol support that is standard in HCL OneTest Performance.

Reporting custom verification point failures

You can use custom code to report a custom verification point failure.

The Javadoc for the test execution services interfaces and classes can be accessed from the product by clicking Help > Help Contents > HCL OneTest Performance API Reference.

The following code shows how to report a custom verification point failure.

package customcode;

import org.eclipse.hyades.test.common.event.VerdictEvent;
import org.eclipse.hyades.test.common.runner.model.util.Verdict;

import com.ibm.rational.test.lt.execution.core.IVerificationPoint;
import com.ibm.rational.test.lt.kernel.services.ITestExecutionServices;

/**
 * @author IBM Custom Code Samples
 */
public class Class implements
		com.ibm.rational.test.lt.kernel.custom.ICustomCode2 {

	/**
	 * Instances of this will be created using the no-arg constructor.
	 */
	public Class() {
	}

	/**
	 * For javadoc of ICustomCode2 and ITestExecutionServices interfaces, select 'Help Contents' in the
	 * Help menu and select 'Extending HCL OneTest™ Performance functionality' -> 'Extending test execution with custom code'
	 */
	public String exec(ITestExecutionServices tes, String[] args) {
		tes.getTestLogManager().reportVerificationPoint("CustomVP", VerdictEvent.VERDICT_FAIL);
		return null;
	}

}