Home > Articles > Programming

This chapter is from the book

Timing How Long Something Takes to Execute in a Script

Rational Functional Tester provides timers that give an indication of the amount of time that elapsed during script playback. You can use these to estimate how long your scripts take to complete. You can also use these for capturing how long a specific section of your script takes to play back.

The first option that Rational Functional Tester provides is the built-in timer. You can use this option while recording. You can also add it to your scripts later, using two simple lines of code.

While recording, you can define a timer from the GUI recording options, resulting in the appropriate piece of code being written into your script. This option is available from the Script Support Functions button on your Recording toolbar. Figure 3.7 shows this option.

You need to enter only a name for your timer, and then click the Insert Code button. This creates the following line in your script:

timerStart("TRANSACTION1");

If you use Rational Functional Tester .NET, you see the following line instead:

TimerStart("TRANSACTION1")

You need to create the corresponding command to stop your timer. To do this, you simply perform the following steps:

  1. Access your Script Support Functions.
  2. Choose the Timer tab.
  3. Click the name of timer (you would like to stop) from within the Timers: combobox.
  4. Click the Insert Code button.

This will insert either a timerStop("TRANSACTION1"); line or a TimerStop ("TRANSACTION1") line into your script, depending on which version of Rational Functional Tester you are using, Java or .NET, respectively.

These can be added manually, too. You simply type in the necessary timerStart() and timerStop() methods. For instance, Listing 3.4 shows how to use the timerStart() and timerStop() methods for timing how long it takes for the main window of the application to render.

Listing 3.4. Using timers in a script

Java
public void testMain(Object[] args)
{
      // TIME HOW LONG MAIN WINDOW TAKES TO RENDER
      // AFTER STARTING THE APP
      timerStart("TRANSACTION1");
      startApp("ClassicsJavaA");
      timerStop("TRANSACTION1");

      // Frame: ClassicsCD
      classicsJava(ANY,MAY_EXIT).close();
}
VB.NET
Public Function TestMain(ByVal args() As Object) As Object
' TIME HOW LONG MAIN WINDOW TAKES TO RENDER
' AFTER STARTING THE APP
TimerStart("TRANSACTION1")
StartApp("ClassicsJavaA")
TimerStop("TRANSACTION1")

' Frame: ClassicsCD
ClassicsJava(ANY,MAY_EXIT).Close()

Return Nothing
End Function

The prior two scripts result in a couple of events being written into the test log. The first is the timer getting started by the script. The second is the timer stopping. The stop event also displays the amount of time that elapsed. Figure 3.8 shows what these events look like in the HTML log.

Note that Rational Functional Tester’s Script Assure technology can influence timers. If a test object’s property values change and it is wrapped in between timer commands, you can, and often do, see excessive elapsed times in your log files. This is because the time it takes to find a test object gets captured and added into the timer.

One downside of Rational Functional Tester’s timers is that they don’t return a value for external consumption. For instance, you might want to write the elapsed time out to an external file (for example, if you have a test harness that has its own logging mechanism). This is where you can turn to the native scripting language, Java, or VB.NET.

Java’s System class provides the currentTimeMillis() method for capturing transaction times. It returns a long data type. It is a native method that directly calls out to the operating system. Therefore, its resolution can vary when you run your tests on different machines running different operating systems. Listing 3.5 revisits the waitForExistence(double arg0, double arg1) method. This time the System.currentTimeMillis() method is used to capture how long the waitForExistence() method actually had to wait.

Listing 3.5. Capturing elapsed times using native Java capabilities

public void testMain(Object[] args)
{
      startApp("ClassicsJavaA");

      // START TIMER - first call to System.currentTimeMillis()
      long startTime = System.currentTimeMillis();

      // USE waitForObject() ON MAIN WINDOW TO MAKE
      // SURE IT IS THERE BEFORE PERFORMING VERIFICATION
      classicsJava().waitForExistence(180.0, 2.0);

      // END TIMER - second call to System.currentTimeMillis()
      long stopTime = System.currentTimeMillis();

      // CALCULATE HOW LONG THE waitForExistence METHOD TOOK
      long intervalTime = stopTime - startTime;

      // WRITE INTERVAL TO LOG
      logInfo("Playback needed to wait " + intervalTime + " ms for
application to launch");

      // AND CONSOLE
      System.out.println("Playback needed to wait " + intervalTime + "
ms for application to launch");

      // AND EXTERNAL FILE (TO BE IMPLEMENTED)
      // TODO - ADD CODE TO WRITE TO FILE

      // Frame: ClassicsCD
      tree2().performTest(VerifyComposerListVP());
      classicsJava(ANY,MAY_EXIT).close();
}

VB.NET’s System namespace offers the DateTime and TimeSpan structures for acquiring elapsed times. To use these, you first obtain the value contained in DateTime’s Now property to capture the start time. You capture Now’s value again when you want to get the stop time. To gather the total elapsed time, you use the TimeSpan structure and initialize it with the difference between your stop and start times. Depending upon how you want to view the elapsed time, TimeSpan lets you display it in hours, minutes, seconds, milliseconds, and so on. Listing 3.6 shows how this comes together. This builds off of an earlier script that used the WaitForExistence() function.

Listing 3.6. Capturing elapsed times using native VB.NET capabilities

Public Function TestMain(ByVal args() As Object) As Object
      StartApp("ClassicsJavaA")

' START TIMER - first call to System.DateTime.Now
Dim startTime As System.DateTime = System.DateTime.Now

' USE WaitForObject() ON MAIN WINDOW TO MAKE SURE IT IS THERE BEFORE
PERFORMING VERIFICATION
ClassicsJava().WaitForExistence(180.0, 2.0)

' END TIMER - second call to System.DateTime.Now
Dim stopTime As System.DateTime = System.DateTime.Now

' CALCULATE HOW LONG THE waitForExistence METHOD TOOK
Dim intervalTime As System.TimeSpan = stopTime - startTime

' WRITE INTERVAL TO LOG
LogInfo("Playback needed to wait " & intervalTime.TotalMilliseconds & "
ms for application to launch")
' AND MsgBox
MsgBox("Playback needed to wait " & intervalTime.TotalMilliseconds & "
ms for application to launch")

' AND EXTERNAL FILE (TO BE IMPLEMENTED)
' TODO - ADD CODE TO WRITE TO FILE

' Frame: ClassicsCD
      Tree2().PerformTest(VerifyComposerListVP())
      ClassicsJava(ANY,MAY_EXIT).Close()
      Return Nothing
End Function

Synchronization and timing are two critical tools in an automation engineer’s toolbox. They help you determine how long a piece of your script takes to execute and, perhaps more importantly, they help you keep your scripts—or pieces of them—in synch with your application’s playback.

This section covered the appropriate timing and synchronization methods provided by Rational Functional Tester. You saw how you can use delays to wait a specified number of seconds. You also saw how you can tell your scripts to wait until a desired test object appears. Lastly, you learned how to use timers to capture how long a piece of your script takes to execute.

You should now be able to apply the appropriate techniques and script code to deal with any latency issues that appear in the application you test. You can use timers to determine the duration of the latencies. You can then select the appropriate method for dealing with them.

  • + Share This
  • 🔖 Save To Your Account