使用 Java 扩展 Rational Performance Tester

核心提示：基于 Eclipse 的 IBM® Rational® 测试产品的可扩展能力，特别是 Rational Performance Tester 和 Rational Functional Tester 可以使用 Java™ 编写定制代码，使用 Java 扩展 Rational Performa

基于 Eclipse 的 IBM® Rational® 测试产品的可扩展能力，特别是 Rational Performance Tester 和 Rational Functional Tester 可以使用 Java™ 编写定制代码，使之成为开发复杂和灵活测试程序的明智选择。

Rational Functional Tester 在用于基于 Web 或者 Java 的应用程序时，是一种更加面向 Java 的测试工具，测试脚本会直接以 Java 生成，并提供对客户端程序内部 Java 对象的直接访问。Rational Functional Tester 为更便捷的扩展性提供了一个内构的模型，使用 SuperHelper 类来扩展 Helper。扩展 Rational Functional Tester 的各种范例，可以在 developerWorks® Rational® 专区中找到。

由于性能测试方面存在的差异，相似的内构类扩展功能并不存在于 Rational Performance Tester 中，与功能性测试和执行相反。例如，客户对象映射并不是性能测试模型的关键构件。另外，性能测试被设计成生成尽可能少的负荷，所以并不会产生冗繁的结果。

本文讨论了两个潜在的区域，该区域为 Rational Performance Tester 提供了强大的扩展点：通过一个超类来进行对象扩展，以及通过静态的方法来使用可再用设施。本文中的范例为性能测试之间持续性的变量，使用了一种不用编码的执行方法，非程序员可以很轻松地重复利用这些变量，非程序员可能会记录测试或者运行测试场景。

本文中的范例使用基于 Windows® 平台的 Rational Performance Tester，并采用默认设置。这里所讨论的功能在不同的平台之间不应该有所差异。本文中并没有涉及 Rational Functional Tester 的定制代码问题。

定制代码环境

假设您阅读了本文，并且熟悉 Rational Performance Tester 机制，以添加定制代码，并查找潜在的改善机会。其他的关于向测试添加定制代码的信息（许多其他的 Rational Performance Tester 相关话题）可以在 IBM Redbooks® 发布的“使用 Rational Performance Tester V7”一文中找到，您可以从 IBM Redbooks 站点中找到。本书中的许多内容同样适用于 RPT V8 版本。

通用的代码执行

在继续深入定制之前，让我们快速地查看一下 Java 代码执行的问题。Rational Performance Tester 按默认的定制代码构件来使用项目中的 src 文件夹，它位于一个名为 test 的包中。这个包中也是从 其他 Rational Performance Tester 构件动态生成 Java 的位置，例如测试和日程安排。

本文中的范例以一种更加结构化的格式来处理代码，以将通用的代码与动态生成的代码隔离开来。基本的 src 文件夹，是一个标准的 Java 项目命名规则，仍然作为根来使用。

为了与更加普通的业界标准保持一致，在这个执行中定义的包可以概括到表 1 中。

表 1. 本文中的 RPT 包

包的名字	描述
com.ibm.rpt.template	包含模板文件的包
com.ibm.rpt.util	包含灵活可再用 Java 类的包
com.yourco.example.var	与本文中描述的范例相关的范例包

为该执行的安装或者扩展使用一个相类似的命名规则。例如：

yourSuffix.yourCompanyName.applicationName.var

位于：

yourSuffix 就是公司标示符的后缀；例如，来自 ibm.com 的 com。yourCompanyName 就是您所在公司的名称。

applicationName 就是与变量相关程序的名字，在这些例子中就是 sample。

var 是一个常量，它指示了与变量相关的包。

提取范例

本文中含有一个包含代码、模板以及范例目录结构的 ZIP （rpt_ext.zip）文件，以及范例的目录结构。将 ZIP 文件复制到项目工作区内的src文件夹中并提取出内容。您会看到一个与如图 1 中所示相似的结构。

图 1. 范例的目录结构

因为您已经步入了 Java 编程的王国，切换至 Java 透视图并使用 Package Explorer 视图来查看布局。您会看到接下来的模板以及设施程序，以及一个名为 com.yourco.example.var 的空包。正如前面描述的那样，test 包是所有 Rational Performance Tester 生成的 Java 文件的默认位置。

图 2. Java 透视图 Package Explorer 视图

testsA 测试中的变量持续性通常包含了动态生成的值，尽管数据源中或者其他形式数据外部化没有包含合适的后续对象，它们仍然需要保留到最后的测试阶段。

Rational Performance Tester 使用 IDataArea 类来保留这些值，它可以得到实例化，并在虚拟的用户层次上进行访问，确保数据没有错误。

向测试插入定制代码的问题就是 Arguments 区域，只允许通过的值，而且没有提供名字关系。

为了解决这个问题，为您需要保存的每一个变量创建一个单独的类，给类命的名要参考在随后的测试中您需要应用的变量名。然后定义变量的脚本就可以访问一个普通的 Java 类（在本文中，是 VariablePersister.java），以执行持续性函数。

这种设计的一种好处，在于如果变量必须更改的话，那么每一个变量都可以得到扩展，这就使得变量得到显著的增加或者降低。

VariablePersister 执行

变量持续性最有可能的候选对象，是一个简单的字符串值。这个部分描述了怎样长久化一个带有提供模板的字符串值。不需要代码更改。

您并不需要成为一个 Java 程序员，以使用这里提供的 VariablePersister 执行，但是如果您熟悉定制代码的话，理解起来会更加的方便。

为了演示一个简单的 VariablePersister 用法，会记录一个随机生成的词（来自 http:// www.merriam-webster.com/ 的现代词）并保存。然后词语会翻译为其他的语言（通过 http://babelfish.yahoo.com/ 的 Yahoo! Babel Fish 进行翻译）。

创建一个 VariablePersister 字符串类

确定您处于 Java 透视图下，Package Explorer 视图中。

从com.ibm.rpt.template 包中复制 PersistentVariableStringTemplate.java 文件，并将其粘贴到分配给包含值的包中（在本例中，就是 com.yourco.example.var 包）。

将文件重命名以匹配您想要长久使用的变量的名字。为了做到这一点，您可以右击文件并点击 Refactor > Rename，如图 3 所示。

图 3. 重命名 PersistentVariableStringTemplate.java

查看原图（大图）

将拷贝版本的 Java 模板的名字更改为 SAMPLE_VAR1。

图 4. 重命名文件界面

保持其他默认的值不变，然后点击 Finish。

切换回 Test 视角。

获取作为应用的变量

Rational Performance Tester 将会验证用作变量的一些潜在值，但是在其他的一些实例中，您需要自己定义它们。在记录该场景的页面中显示在图 5 中。

图 5. 今天的 Merriam-Webster 词

为了将特定的值定义为一个引用，您可以执行下面的步骤：

打开来自您刚刚记录的页面中的回应：

图 6. WordOfTheDay 响应

Content 部分如清单 1 所示。

清单 1. WordOfTheDay 内容

[--　Content　data　is　27,493　characters　long.　
Press　Ctrl+Shift+Space　or　Ctrl+Left　Click　here　to　display　it.　--]

显示内容（如上所述），并搜索今天的词。在这里 HTML 定义的条件下，定位合适的实例（<span class="headword">debonair</span>）。引用必须足够独特以为未来的测试做好准备。

右击定位的文本并选择 Create Reference。

在左边的窗格中，点击 Test Data Sources 项。选择 References，并清除 Matching Only。您应该看到新定义的引用值（见于图 7）。

图 7. WordOfTheDay 数据源

为了对 SAMPLE_VAR1 设置值，您在前面复制的 Java 模板，执行以下的步骤：

在记录测试的 Test Contents 区域中，在主 URL 回应条目的下面，点击 Insert 并选择 Custom Code。

图 8. 插入 WordOfTheDay 定制代码

在 Class Name 区域的右边，输入 com.yourco.example.var.SAMPLE_VAR1。

点击 View Code 以确认您的进入。

点击 Arguments 框旁边的 Add，切换至 URl 入口，并点击您刚刚创建的引用值。

图 9. 选择 WordOfTheDay Arguments

SAMPLE_VAR1 现在已经设置为动态的值，如引用中定义的那样。

图 10. WordOfTheDay Test Element 细节内容

查看原图（大图）

通过向 Arguments 区域添加额外的值，您就可以执行相同的程序以创建一个 String[] 数组。在接下来的章节中将会处理这一点。

引用持续性的变量

为了引用来自原始的请求中获取的值，您可以切换至 URL 定义，会向这个定义发送一条请求，并检查 Data 区域以得到合适的值，如图 11 所示。

图 11. 持续性的变量值

查看原图（大图）

当测试得到记录之后，词 sample 用于获取请求数据。在 Data 区域内选择整个词 sample，右击并选择 Substitute from>Custom Code : com.yourco.example.var.SAMPLE_VAR1。

未来运行的测试将会使用新发现的值来替换值 sample。

具体的变量持续值

本部分涉及到了简单 Variable Persister 的免代码执行，让我们查看一下这个函数的机制。

注意：
接下来的部分假设您对 Java 编程语言已经很熟悉了。

接下来的表格列出了包含在三个 Template 类中的 Javadoc 注释：

这里是对来自 Javadoc 代码范例的描述：

通过虚拟用户的 IDataArea 持续 RPT 变量的使用。两个 Constructors 允许简单字符串值或者任意种类 Objects 的持续。可以在 com.ibm.rpt.template 包中找到模板。

表 2. 持续性的变量模板描述

模板文件名	描述
PersistentVariableStringTemplate	简单的字符串变量。
PersistentVariableSequentialTemplate	设置类 String[]（数组）的持续性变量，按照它们输入数组的顺序来一次性返回值。数组会不断循环直到测试完成为止。
PersistentVariableRandomTemplate	设置类型 String[]（数组）的持续性变量，随机地返回值。

每一个类都使用包 com.ibm.rpt.util 中的 VariablePersister 类。VariablePersister 类执行实际的设置并使用 IDataArea 类的 put(String，Object) 和 get(String) 方法来得到定义变量的函数。

首先我们将会查看一下简单的类 PersistentVariableStringTemplate，以描述基本的工作。在 超类执行部分中将会讨论 Sequential 和 Random 模板。

PersistentVariableStringTemplate 类工作的一个假设是做出了单个字符串对单个字符串的联系。在清单 2 中显示了模板的简化视图。

清单 2. 模板代码范例

public　class　PersistentVariableStringTemplate　implements　ICustomCode2　{　
　//　Set　the　name　of　the　variable　key,　based　on　this　class　name　
　private　final　String　variableKey　=　this.getClass().getSimpleName();　
　
　public　PersistentVariableStringTemplate()　{　
　}　
　
　/**　
　*　The　exec(ITestExecutionServices,　String[])　Method　is　the　standard　
　*　format　for　calling　Java　extension　classes　from　RPT.　
　*/　
　public　String　exec(ITestExecutionServices　testExecutionServices,　String[]　args)　{　
　//　Set　the　initial　persisted　variable　value　to　null　
　String　variableValue　=　null;　
　//　Reset　the　variable　variable　value　if　an　input　value　is　provided　
　if　(args.length　==　1)　{　
　variableValue　=　args[0];　
　}　
　return　new　VariablePersister(testExecutionServices,　
　variableKey,　variableValue).getVariableValue();　
　}　
}　

正如上面注释中提到的那样，定制代码类的标准运行机制是 exec(ITestExecutionServices，String[]) 方法。在访问定制代码时，会通过这些自动生成的值，ITestExecutionServices 对象会提供关于测试环境的信息，而定制代码定义中 String[] 数组就是 Arguments 部分中所列的值。

实际的 VariablePersister 代码将会由模板文件重新分配为 VariablePersister.java，它会得到简单的处理。

程序中代码的关键两行是：

字符串变量 variableKey 的最终定义，会定义关键值的名字，以匹配新分配文件的名字（见于 VariablePersister Implementation），它用作变量的引用。

这个简单的模板假设了单个的值。代码中执行了确认操作，以确保提供了唯一的论题，它用作变量值；否则就会返回当前设置的值。该代码不同于 PersistentVariable Random 和 Sequential Templates，在稍后将会对其作出处理。

对新的 VariablePersister 对象的访问，会执行剩余的工作，返回与来自 PersistentVariableStringTemplate 文件创建的文件相关的变量的字符串值。

VariablePersister 类被设计成为单个字符串值的实例 ：

new　VariablePersister(ITestExecutionServices，String，String);

其中的参数是：

testExecutionServices，用于获取 IDataArea 的 ITestExecutionServices。

aVariableKey，应用持续性变量关键的名字。

aVariableValue，持续性变量的字符串值。

或者对于一个对象值：

new　VariablePersister(ITestExecutionServices，String，Object);

其中的参数是：

testExecutionServices，用于获取 IDataArea 的 ITestExecutionServices。

aVariableKey，应用持续性变量关键的名字。

aVariableContent，持续性值的目标值。

两个版本的构造方法实际上都是相类似的，除了存储值的格式之外，如清单 3 所示。

清单 3. 持续性的代码

public　VariablePersister(ITestExecutionServices　testExecutionServices,　
　String　aVariableKey,　String　aVariableValue)　{　
　//　Set　variable　key/value　from　input　
　variableKey　=　aVariableKey;　
　//　Capture　the　Virtual　User's　IDataArea　Object　from　ITestExecutionServices　
　virtualUserDataArea　=　testExecutionServices.findDataArea(IDataArea.VIRTUALUSER);　
　
　//　Set　the　persisted　value　if　input　is　provided　(aVariableValue)　
　if　(aVariableValue　!=　null)　{　
　variableValue　=　aVariableValue;　
　virtualUserDataArea.put(variableKey,　variableValue);　
　}　else　{　
　//　Try　to　get　current　value...　
　try　{　
　variableValue　=　(String)virtualUserDataArea.get(variableKey);　
　}　catch　(NullPointerException　e)　{　
　//　No　value?　Obviously　not　defined...　set　to　empty　String　
　variableValue　=　EMPTY_STRING;　
　virtualUserDataArea.put(variableKey,　variableValue);　
　}　
　}　
}　

为了避免 nullPointerExceptions，可使用的方法有：

getVariableValue – 对于字符串值

getVariableContent – 对于对象值

它们分别返回一个空的字符串值或者一个空的 String[] 数组。

因为这些值都维护在虚拟用户的 IDataArea 中，没有跨用户值污染的可能性存在。

超类执行

生成的定制代码使用一个超类模型，如清单 4 中标准生成的定制代码所示。

清单 4. 生成的 RPT 类

package　test;　
　
import　com.ibm.rational.test.lt.kernel.services.ITestExecutionServices;　
　
public　class　GeneratedClass　implements　
　com.ibm.rational.test.lt.kernel.custom.ICustomCode2　{　
　
　public　GeneratedClass()　{　
　}　
　/**　
　*　For　javadoc　of　ICustomCode2　and　ITestExecutionServices　interfaces,　select　
　*　'Help　Contents'　in　the　Help　menu　and　select　'Extending　Rational　
　*　Performance　Tester　functionality'　->　'Extending　test　execution　with　custom　
　*　code'　
　*/　
　public　String　exec(ITestExecutionServices　tes,　String[]　args)　{　
　return　null;　
　}　
}　

执行的默认超类是 com.ibm.rational.test.lt.kernel.custom.ICustomCode2。

提供的两个基于数组的模板，PersistentVariableRandomTemplate 和 PersistentVariableSequentialTemplate，都扩展了 com.ibm.rpt.util.SuperObject，而它反过来又扩展了 ICustomCode2，提供了一种内部的位置以运行普通的定制代码。

SuperObject 类的概念

SuperObject 类中的主要功能，与处理永久性数组变量相关：

序列数组由 ariablePersister 函数处理，创建一个与 VariablePersister 类相同名字的变量，该类创建自以 _POINTER 为后缀的模板。对 VariablePersister 类的每一次访问，反过来都会访问 SuperObject 类 getNextPointerValue 方法，通过 VariablePersister 类中保持数组中的值进行循环。

随机数组由对 SuperObject 中 getRandomValue(String[]) 方法的调用处理，通过使用静态方法容器类 NumericGenerator 中的静态方法 getRandomInt(int) 中的准随机数字生成器。

使用动态生成的数据或者随机数据，来澄清从测试中使用非相似数据以进行测试是否可以简化测试结果的讨论。本文并不没有涉及到这个讨论。

SuperObject 类（见于清单 5）以下面的内容开始：

执行 ICustomCode2 类；它的超类

创建一系列的值以支持函数

提供了一个 exec(ITestExecutionServices, String[]) 方法，以匹配它的超类

清单 5. SuperObject 代码

package　com.ibm.rpt.util;　
　
import　com.ibm.rational.test.lt.kernel.IDataArea;　
import　com.ibm.rational.test.lt.kernel.custom.ICustomCode2;　
import　com.ibm.rational.test.lt.kernel.services.ITestExecutionServices;　
　
public　abstract　class　SuperObject　implements　ICustomCode2　{　
　//　definitions　for　persisted　variable　array　with　pointer　
　public　String　variableKey;　
　public　String[]　variableValue　=　null;　
　public　String　pointerKey;　
　public　Integer　pointerValue　=　null;　
　
　//　RPT　Virtual　User　definition　for　ITestExecutionServices　
　public　ITestExecutionServices　virtualUserTestExecutionServices;　
　//　RPT　Virtual　User　definition　for　IDataArea　
　public　IDataArea　virtualUserDataArea;　
　
　//　set　Constant　values　
　public　static　final　String　POINTER_SUFFIX　=　"_POINTER";　
　
　//　required　method　as　part　of　implementation　of　ICustomCode2　
　public　String　exec(ITestExecutionServices　arg0,　String[]　arg1)　{　
　return　null;　
　}　

大多数的后续方法为 VariablePersister 模板提供了功能。

清单 6. VariablePersister 模板

public　public　PersistentVariableRandomTemplate()　{　
}　
　public　String　exec(ITestExecutionServices　testExecutionServices,　String[]　args)　{　
　//　populate　super　class　(com.ibm.rpt.util.SuperObject)　values　
　virtualUserTestExecutionServices　=　testExecutionServices;　
　variableKey　=　this.getClass().getSimpleName();　
　pointerKey　=　variableKey　+　POINTER_SUFFIX;　
　//　Capture　the　Virtual　User's　IDataArea　Object　from　ITestExecutionServices　
　virtualUserDataArea　=　virtualUserTestExecutionServices.　
　findDataArea(IDataArea.VIRTUALUSER);　

执行模板代码可以在超类的层次上传播与 ITestExecutionServices 和 IDataArea 对象相关的值。

SuperObject 类中还包含了一个范例日志，如清单 7 所示。

清单 7. 范例日志方法

/**　
　*　<p>Write　a　message　out　to　the　test　execution　log.</p>　
　*　@param　message　The　String　value　to　be　written　to　the　log.　
　*/　
　public　void　putMessage(String　message)　{　
　virtualUserTestExecutionServices.getTestLogManager().reportMessage(message);　
　}　

这种方法为对测试日志编写一条信息提供了一种快捷的方式，或者以 refactoring 的方式提供了一个值。这可能是一个非必要的方法，但是它确实演示了提供普通机制的能力。一个更加有用的执行方法可能是对一个外部的源追踪特定的事件来使用一个普通的日志，在中央的位置拥有代码，会提供简化的维护与编辑方式。

使用 SuperObject 类

接下来的范例首先执行了来自 XE.com Universal Currency Converter 的货币兑换。初始的记录将会将一加元的值转化为相应的美元值。为了演示 SuperObject 与 PersistentVariableSequentialTemplate 类，会创建一个数组以从网站获得顶端的货币。

首先，从 PersistentVariableSequentialTemplate 来创建 SAMPLE_VAR2，与对 SAMPLE_VAR1 所做的操作相类似。

在 URL 应用下插入通用的代码，并将类设置为 com.yourco.example.var.SAMPLE_VAR2。

图 12. 货币性能测试

为 SAMPLE_VAR2 定制代码进行 Add，以添加多个值创建一个数组。

图 13. 选择货币论题

在记录的测试中扩展对 XE.com Conversion 请求的入口，并选择 URL www.xe.com/ucc/convert.cgi。

图 14. 选择货币 URL

将记录（USD）中第二个货币类型值替换为来自 SAMPLE_VAR2 的定制代码。

图 15. 显示货币值

查看原图（大图）

SAMPLE_VAR2 中的定制代码，将会在测试运行期间通过定义的数组，在值的末端重新启动。

与之相类似，PersistentVariableRandomTemplate 可以用以执行一个随机访问的数组。

使用定制代码中的静态方法

静态方法的使用可能是一种糟糕的面向对象的编程操作。但是，在有些情况下这是达到目标最快的一种方式。

扩展前面的范例，更改转化的值，使用一个 com.ibm.rpt.util.NumericGenerator.java 文件中简单的、可再用的准随机的数字生成器。

在初始的 URL 访问之前添加新的定制代码，使用一个类名：com.yourco.example.var.SAMPLE_VAR3。点击 Generate Code。

图 16. 货币转化

更改 SAMPLE_VAR3 中的代码：

清单 9. 更改前的代码

public　class　SAMPLE_VAR3　extends　
　com.ibm.rational.test.lt.kernel.custom.ICustomCode2　{　
　/**　
　*　Instances　of　this　will　be　created　using　the　no-arg　constructor.　
　*/　
　public　SAMPLE_VAR3()　{　
　}　
　
　public　String　exec(ITestExecutionServices　tes,　String[]　args)　{　
　return　null;　
　}　

变更为：

清单 10. 变更后的代码

public　class　SAMPLE_VAR3　extends　
　com.ibm.rpt.util.SuperObject　{　
　/**　
　*　Instances　of　this　will　be　created　using　the　no-arg　constructor.　
　*/　
　public　SAMPLE_VAR3()　{　
　}　
　
　public　String　exec(ITestExecutionServices　tes,　String[]　args)　{　
　return　NumericGenerator.getRandomCurrency("5000");　
　}　
}　

NumericGenerator.getRandomCurrency（字符串）方法接受了一个数字的字符串代表，指示了生成的最高值，反过来提供了一个准随机的值，它基于一种货币（$.¢¢）格式的 DecimalFormat。数字的随机性使用 java.util.Random 来搜索，反过来又使用来自 System.currentTimeMillis() 的值来寻找。

清单 11. 生成随机货币的代码

public　static　String　getRandomCurrency(String　high)　{　
　refreshRandom();　
　double　randomDouble　=　
　Math.round(random.nextDouble()　*　Double.parseDouble(high));　
　return　currencyDecimalFormat.format(randomDouble).toString();　
}　
　
private　static　void　refreshRandom()　{　
　random.setSeed(System.currentTimeMillis());　
}　

一个错误显示出来，指示 NumericGenerator cannot be resolved。右击错误指示器，并选择 Quick Fix > Import NumericGenerator(com.ibm.rpt.util)。

图 17. 错误的快速修复

查看原图（大图）

在 www.xe.com/ucc/convert.cgi 的请求数据中，强调显示位于 Amount= 之后的 1，并由定制代码 SAMPLE_VAR3 所取代。1 和 0 之间的准随机数字将向每一次测试运行而提供。

分析

本文中提供的范例是简单的，但是它们却显示了怎样通过使用 Java 操作来扩展测试功能。降低冗余的代码，因此减少了长期的代码维护费用，通常是一个优秀的目标。

Rational Performance Tester 产品中提供的简单定制代码模型，可以轻松地得到扩展，以使用 Java 超类和再使用的代码构件来创建一个良好的测试环境。

本文示例源代码或素材下载