Home
Rational® Performance Tester
Test Execution Specialist Guide
This guide describes tasks that you can perform on schedules, test execution with custom code, and Extending Rational® Performance Tester 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.
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.

Rational® Performance Tester
- Release Notes
  This document contains information about what's new, installation instructions, known issues in IBM® Rational® Performance Tester and contact information of IBM Customer Support.
- System Requirements
  This document includes information about hardware and software requirements for IBM® Rational® Performance Tester.
- Getting Started
  This guide provides an overview and describes the task flows to get you to start with Rational® Performance Tester. This guide is intended for new users.
- Tutorials
  This section contains the tutorials which explains the main features of Rational® Performance Tester.
- Samples
  This section describes about the sample project which can be used with Rational® Performance Tester to test the functionality of an application.
- Administrator Guide
  This guide describes how to install Rational® Performance Tester. After you install the product, you can perform administration tasks such as license configuration and integration with other products. This guide is intended for administrators.
- Test Author Guide
  This guide describes how to create test scripts in Rational® Performance Tester and enhances tests by applying different test elements such as dataset, variables, and verification points. This guide is intended for testers.
- Test Execution Specialist Guide
  This guide describes tasks that you can perform on schedules, test execution with custom code, and Extending Rational® Performance Tester 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 Rational® Performance Tester to support other protocols
    The Rational® Performance Tester 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 Rational Performance Tester.
- Test Manager Guide
  This guide describes how to keep track of the performance of the application by evaluating the test results. This guide is intended for test managers.
- Troubleshooting Guide
  This guide describes how to analyze and resolve some of the common problems that you might encounter while you work with Rational® Performance Tester.
- Reference Guide
  This guide describes, additional topics to gain more knowledge about Rational® Performance Tester.
- All Guides (PDFs)
  You can find the link to view or download the content of the release notes, system requirements, and persona guides of Rational® Performance Tester as a PDF file.
- Security Considerations
  You can take certain actions to ensure that your installation is secure, customize your security settings, and set up user access controls.
- Notices
  This document provides information about copyright, trademarks, terms and conditions for the product documentation.

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.

The properties that you can get through a custom code are as follows:

Total number of rows
Total number of columns
Name of the columns
The value that is set for the Open mode option
The value that is set for the Access mode option

After the test run is complete, you can view the properties of the dataset in test logs. See Viewing test logs.

The following sample custom code provides the properties of the dataset in test logs:

package datasets;

import java.awt.list;

/**
 * @author IBM Custom Code Samples
 */

public class myds implements com.ibm.rational.test.lt.kernel.custom.ICustomCode2 {

    public myds() {
    }
    public String exec(ITestExecutionServices tes, String[] args) {
         // the name of the dataset is the same as what is shown in the test.
         //The dataset must be added to the test in order to get a controller for it.
        IDataSetController control = tes.getDataSetController("/testproj/myds.csv");
        try
        {
             tes.getTestLogManager().alwaysReportMessage(" Total Rows in DS "+(Integer.toString(control.getTotalRows())));
             control.getAccessMode();
             tes.getTestLogManager().reportMessage(" DS Access Mode is "+(control.getAccessMode()));
             tes.getTestLogManager().reportMessage("DS Open Mode is "+(control.getOpenMode()));
             tes.getTestLogManager().alwaysReportMessage("Column headers in DS "+control.getColumnHeaders().toString());
             control.writeRow(-1, Arrays.asList("a","b","c"), false);
             tes.getTestLogManager().alwaysReportMessage("Total Rows after adding new row in DS "+Integer.toString(control.getTotalRows()));
        }
        
        catch (Exception e)
        {
            tes.getTestLogManager().alwaysReportMessage( e.toString());
// TODO Auto-generated catch block
e.printStackTrace();
}