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 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.
Extending the run-time environment
The run-time environment defines the plug-ins on which all other plug-ins depend. The run-time environment is responsible for defining a structure for plug-ins and the implementation detail behind them.
Extending subsystem management during a test run
A subsystem is a collection of classes in a discrete component within the performance testing engine that provides a service to many actions. For example, in test execution, the KernelWait subsystem manages think and sleep time for virtual users while a test is running.
Informing the test engine that the subsystem exists
Subsystems are identified to the performance test engine with extensions. Typically, a new protocol indicates in its plugin.xml file the class name of the subsystem that it is providing. This example modifies an existing performance test plug-in and specifies the class name of the sample plug-in in the plugin.xml file.

Rational® Performance Tester
- Release Notes
  This document contains information about what's new, installation instructions, known problems 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 started 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 software, 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.
  - 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.
    - Protocol extension structure
      Before organizing your extension, note the restrictions and guidelines provided in this topic.
    - Extending the test recorder
      To generate a test, the data exchanged by an application and another entity such as a server must be recorded. The recorded data is then processed to generate a test.
    - Extending the test generation framework
      Test generation consists of processing the recorded data and producing a test.
    - Contributing annotations
      An annotation is an action that a user performs during a recording session. Annotations are used to document or structure the test generated from the recording.
    - Extending the load test behavior model
      The load test behavior model (LTBM) is a model of the behavior of a performance test in Rational® Performance Tester.
    - Extending data correlation
      Data correlation is the process of extracting data that is returned from a server, and then sending it back to the server in a subsequent request.
    - Extending the test editor
      The performance testing software provides application programming interface (API) classes for extending the test and performance tools platform (TPTP) to write new editors and protocol extensions.
    - Contributing error handlers
      An error handler is associated with an error condition. Error handlers specify the action to take when a specified error condition occurs. Error handlers are provided for conditions such as verification-point failures, connection failures, server timeouts, and data-correlation problems. You can add new types of errors and error handlers.
    - Extending the schedule component
      When you extend the schedule component in performance testing, another plug-in can contribute options to a schedule. Those options can be set up to persist in the schedule model, and a corresponding user interface can be displayed for editing the new options.
    - Extending code generation
      The code generation subsystem maps Load Test Behavior Model (LTBM) elements to objects of the code generation element model (IModelElement), which in turn are mapped to objects of its ILanguageElement class. As a result, a language element tree is created that contains all equivalent elements of the behavior model test element tree and at the same time determines the structure of code to be generated.
    - Extending the run-time environment
      The run-time environment defines the plug-ins on which all other plug-ins depend. The run-time environment is responsible for defining a structure for plug-ins and the implementation detail behind them.
      - Blocked Action detection
        The performance testing execution engine provides the capability of detecting that an Action is blocked. The definition of blocked is provided by the author of the Action. The definition is provided as an amount of time an Engine Worker Thread is allowed to be unresponsive in the course of executing the Action before it is considered blocked. The performance testing execution engine logs the detection of blocked actions at level FINEST in the Problem Determination Log. In the simplest case, the run would be hung, and discovery of the blocked action would come from examining the Problem Determination log after clicking Stop to end the run.
      - Extending subsystem management during a test run
        A subsystem is a collection of classes in a discrete component within the performance testing engine that provides a service to many actions. For example, in test execution, the KernelWait subsystem manages think and sleep time for virtual users while a test is running.
        Informing the test engine that the subsystem exists
        Subsystems are identified to the performance test engine with extensions. Typically, a new protocol indicates in its plugin.xml file the class name of the subsystem that it is providing. This example modifies an existing performance test plug-in and specifies the class name of the sample plug-in in the plugin.xml file.
        Creating a simple test and VU Schedule
        You must create a simple performance test and VU Schedule. By creating and playing back a test and a VU Schedule, code is generated for both. Later, you will modify the generated test code so that the test contains a special action that uses the sample subsystem.
        Adding SampleAction and SampleSubsystem to the project
        Import the performance test and schedule source files into the testproj project.
        Running the schedule with SampleAction using SampleSubsystem
        Modify the generated test code to use SampleAction, so that the subsystem is active during the next playback.
        SampleAction.java code sample
        This is an example of SampleAction.java.
        SampleSubsystem.java code sample
        This is an example of SampleSubsystem.java.
      - Extending initialization and finalization during a test run
        You can specify code for your protocol to be executed by the Rational® Performance Tester engine threads at strategic points during startup and shutdown. For example, you can specify code to load libraries, unload libraries, or perform other initialization or cleanup as required by the protocol.
      - Public APIs for run time
        The public APIs contain the public interfaces and classes that you can use to extend the run-time environment functionality.
    - Extending the test log viewer
      After running a test, the test results are saved in a test log. Use the Test Log viewer to check the results for specific events, such as the script start and end, loop, invocation, message, or verdict.
    - Extending evaluation results
      Reports are a specification of how performance test data should be extracted from the statistical model and presented to the user.
- 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)
  This page contains the release notes, system requirements, and persona guides for IBM® Rational® Performance Tester in PDF format.
- 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.

Informing the test engine that the subsystem exists

Subsystems are identified to the performance test engine with extensions. Typically, a new protocol indicates in its plugin.xml file the class name of the subsystem that it is providing. This example modifies an existing performance test plug-in and specifies the class name of the sample plug-in in the plugin.xml file.

About this task

To identify the subsystem to the performance testing engine, complete the following steps.

Procedure

Open a command prompt, and change directory to the __PT_ACRONYM__ plug-ins directory.
Save a copy of the existing HTTP execution JAR. For example: C:\__BRAND_NAME__\common\plugins>copy com.ibm.rational.test.lt.execution.http_7.0.0.v200609010404.jar com.ibm.rational.test.lt.execution.http_7.0.0.v200609010404.jar.orig
Make a new copy of the HTTP execution JAR for modification. For example: C:\__BRAND_NAME__\common\plugins>copy com.ibm.rational.test.lt.execution.http_7.0.0.v200609010404.jar foo.jar
Extract the plugin.xml file. For example: C:\__BRAND_NAME__\common\plugins>jar xvf foo.jar plugin.xml Note: You must have a Java™ SDK in your PATH statement so that you have access to the JAR utility.

Add these lines to the plugin.xml file just above the </plugin> line at the bottom:

<extension
	point="com.ibm.rational.test.lt.execution.Subsystem">
	<Subsystem
		feature="com.ibm.rational.test.lt.feature.lt"
		class="test.SampleSubsystem"/>
</extension>

Start Rational® Performance Tester with the -clean option so that the plug-ins are reloaded, for example: C:\IBM\RPT>eclipse –clean.