Home
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 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.
Running recorders and clients without a UI
To test recorders, clients, and decorators during the development process, you can run those elements before any UI components are ready to start the recorders, clients, and decorators.

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.
    - Defining a new type of captured data
      The data captured by a recorder must be stored in a file and consumed by a test generator to produce a test. Captured data must be defined so that it can be stored by the recorder and consumed by the test generator.
    - Defining a new recorder
      To capture a new kind of data or an existing kind of data with a new recording technique, define a new recorder.
    - Defining a new client
      To produce data, a recording session must start at least one client. Several clients come with the product. To automate starting a specific application, you can define a new client.
    - Defining how a recorder can record a client
      All recorders cannot record all clients. The framework must be notified that a recorder can record a client. In many cases, the recorder must configure a client before recording, and then undo these configuration actions when the client is closed. In these cases, you can declare a client decorator. A client decorator is a class that configures a client so that it can be recorded by a recorder.
    - Running recorders and clients without a UI
      To test recorders, clients, and decorators during the development process, you can run those elements before any UI components are ready to start the recorders, clients, and decorators.
    - Defining wizards for recorders and clients
      You can define wizards for recorders and clients.
    - Migrating recorder implementations from previous versions
      The new recording framework includes significant improvements over the generic recorder framework (GRF) that was delivered in previous versions. The new framework introduces more flexibility for combining clients and recorders. With the framework, you can start multiple recorders and clients in one session, consolidating the recorded data in one file.
  - 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.
  - 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.

Running recorders and clients without a UI

To test recorders, clients, and decorators during the development process, you can run those elements before any UI components are ready to start the recorders, clients, and decorators.

You can start a recording session that includes the recorders or clients that you have developed by using a recording session configuration file. This file specifies which recorders and clients to start and the options for the recorders and clients to use.

The following file is an example of such a configuration file:

<?xml version="1.0" encoding="UTF-8"?>
<__PT_EXTERNAL__:session xmlns:__PT_EXTERNAL__="__PT_EXTERNAL__">
   <rec:myRecorder <-- recorder configuration -->
   	xmlns:rec="recorder:org.xyz.myplugin"
   	option1="value1"
   	option2="value2"
   	id="myRecorder1"/>
   <cli:myClient <-- client configuration -->
   	xmlns:cli="client:org.xyz.myplugin"
   	optionA="valueA"
   	id="myClient1"/>
   <__PT_EXTERNAL__:binding client="myClient1" recorder="myRecorder1"/>
</__PT_EXTERNAL__:session>

In the preceding example, replace org.xyz.myplugin with the name of the plug-in that defines the recorder and the client. Replace myRecorder with the recorder ID and myClient with the client ID. The option1 and option2 attributes can be replaced by attributes that the recorder supports. You can replace the optionA attribute with an attribute that the client supports. You must save the file with the .recconfig extension.

In the configuration file, a session node can contain as many recorder configurations and client configurations as required. All the recorders and clients that are referred to are launched together and the options from the configuration file are passed to them. All recorders and clients must have id attributes so the recorder and clients can be referred to in a binding node. Examples of recording session configuration files can be generated by opening an existing recording session and clicking File > Save Recording Configuration As.

To start a recording session from a recording configuration file, right-click the file, and then select Start Recording Session.