Home
Test Author Guide
This guide describes how to create test scripts and enhances them by applying different test elements such as dataset, variables, and verification points.
Extending the Functional Test perspective
You can use custom code to extend the default functional testing capabilities. You can write custom code and call the code from the test. You can also specify that results from the tests that are affected by your custom code to be included in reports.
Using the API to edit functional test scripts
These topics describe how you can take advantage of the HCL OneTest™ UI application programming interface (API) or the scripting framework to make changes to functional test scripts. As a general rule, the modifications that you make with the scripting SDK, should emulate as closely as possible, the user interactions to test with the application-under-test.
Closing unexpected HTML dialog boxes during playback
You can use the dynamic find() API to close HTML dialog boxes that are displayed unexpectedly during playback, to ensure smooth playback.

Test Author Guide
This guide describes how to create test scripts and enhances them by applying different test elements such as dataset, variables, and verification points.
- Testing in the UI Test perspective
  When you develop web applications, Windows-based applications, or mobile applications, you can use HCL OneTest™ UI to create functional tests for these applications. You must first record the tests and then use HCL OneTest UI to run the tests before you can view the test results.
- Testing in the Functional Test perspective
  When you develop Java, HTML, or Terminal-based applications, you can use HCL OneTest™ UI to create traditional functional tests for these applications. You must first record the tests and then use HCL OneTest UI to run the tests before you can view the test results.
- Extending the UI Test perspective with custom code
  You can use custom code to extend the default Web UI testing capabilities. You can write custom Java™ code and call the code from the test. You can also specify that results from the tests that are affected by your custom code to be included in reports.
- Extending the Functional Test perspective
  You can use custom code to extend the default functional testing capabilities. You can write custom code and call the code from the test. You can also specify that results from the tests that are affected by your custom code to be included in reports.
  - HCL OneTest™ UI proxy SDK
    Extend automated functional testing support for your application's user interface controls.
  - Customizing a script template
    HCL OneTest™ UI uses its default script templates to format and provide basic information when you create a script. You can customize the information and format by customizing the script templates.
  - Using the API to edit functional test scripts
    These topics describe how you can take advantage of the HCL OneTest™ UI application programming interface (API) or the scripting framework to make changes to functional test scripts. As a general rule, the modifications that you make with the scripting SDK, should emulate as closely as possible, the user interactions to test with the application-under-test.
    - Writing messages to the log
      A log is a file that contains the record of events that occur while a Functional Test script is playing back. There are several different methods you can use to write messages to the log.
    - Modifying options for script execution
      Some scripting framework options that affect script execution can be specified through the user interface. Values that you set in the user interface persist as the default values from script to script. However, you can also use the scripting framework to set some of these options directly in the functional test script, for example, the amount of time between keystrokes.
    - Starting a test script from within a script
      Test scripts can contain methods that invoke other test scripts. You might want to take advantage of this functionality by creating a test script that serves as a command file for a suite of scripts.
    - Querying values of object properties
      Components in the application-under-test, such as dialog boxes, command buttons, and labels, have associated pieces of information called properties. Properties have a name and a value. This topic provides examples of why you may want to modify your script to access an object property.
    - Unregistering references to test objects
      Helper script methods refer to an object in the application-under-test by using the test object map. HCL OneTest™ UI finds such mapped objects each time a method is called on the object. In some cases; however, you might not want HCL OneTest UI to do this.
    - Handling ambiguous recognition
      In some situations during playback, HCL OneTest™ UI might not be able to differentiate between two similar objects in the software that is being tested. This topic describes handling these situations.
    - Adding manual and dynamic verification points
      In addition to verification points specified during recording, you can also incorporate new verification points into a Functional Test script. Scripting manual and dynamic verification points enables you to specify data for comparison against an object that is not found in the test object map. The data, however, must be value-class based.
    - Handling unexpected active Windows
      A common problem in GUI testing is the appearance of an unexpected active window -- for example, a warning message box in an HTML browser. This topic describes how to handle this problem.
    - HCL OneTest™ UI examples
      HCL OneTest™ UI ships with some example code you can use in your own scripts. You can open these examples from within the sample project shipped with HCL OneTest UI.
    - Determining the values of cells in a table
      When working with Java™ or HTML tables, you might want to extract the value of a given cell in the table. There are many ways to do this; one simple approach is to query the table directly.
    - Reading the Windows registry
      The Windows® registry is a database used by the Windows operating system to store configuration information. Often it becomes necessary for a tester to read information out of this database using HCL OneTest™ UI commands. This topic provides examples for doing this.
    - Iterating through items in a tree control using the getTestData method
      This topic provides an example of using HCL OneTest™ UI's getTestData method to programmatically access the values on the branches of a tree control.
    - Iterating through table cells using the getTestData method
      This topic provides an example of using HCL OneTest™ UI's getTestData method to access the values in the cells of a grid control.
    - Passing parameters to the callScript method
      This topic describes how to use the different signatures of the callScript method to pass data from one script to another.
    - Extracting data from a combobox/list control (JComboBox)
      You can use HCL OneTest™ UI's getTestData method to access the values in the list of a ComboBox/List control.
    - Playing back low level mouse and keyboard actions
      Low-level playback of mouse and keyboard actions provides more control of events of user actions. For example, HCL OneTest™ UI currently supports TestObject.click(), where the click consists of low-level actions including mouse move, left mouse button down, and left mouse button up. With this functionality, you can play back the individual components of a mouse click.
    - Searching for test objects
      You can search for one or more test objects that match specified search criteria. The search is based on name/value pairs that represent properties of the test object or test objects you are looking for. The search can either be global, or limited to children of a parent test object.
    - Searching for SAP TestObjects
      With HCL OneTest™ UI, you can locate one or more SAP TestObjects matching a specified search criteria, even without using the Object Map.
    - Tracing AJAX requests
      You can test AJAX-based applications in two different ways; by setting the Auto Trace option to true or by setting the Auto Trace option to false on the corresponding document object. By setting Auto Trace option to true, you can trace the AJAX requests.
    - Searching for GEF objects
      HCL OneTest™ UI recognizes the GEF EditParts and Palettes. Some Figures may not have an association with an EditPart. You can use HCL OneTest UI APIs to find such Figures as shown in the below examples.
    - Passing parameters by using the describe function in PowerBuilder
      In PowerBuilder, you can use the describe() function to identify the properties of DataWindow objects and their controls. The describe() function is available only with the PowerBuilder DataWindow. The describe() function returns a string as a result of the parameters that are specified as a part of the describe() function. For example, you can find the data types of the column in a table style presentation. You can use the describe function in HCL OneTest™ UI as shown in the following examples.
    - Finding the state of the browser
      When you record functional test scripts, if you find that some controls were not picked up by the recording, you can verify whether the browser used during the recording was in a ready state for recording. Similarly, if you encountered problems during playback, you can verify the state of the browser. You can use the dynamic find() API and use the Html.HtmlBrowser method for this purpose.
    - Finding objects in a Dojo tree
      You can use the dynamic find() API and the dojoTreeExpand() method to find all objects within a Dojo tree control within the application under test.
    - Reading multiple datasets from a functional test script
      You can use the dynamic find() API to read multiple datasets from a functional test script.
    - Selecting an item from a Java drop-down list
      You can modify the dynamic find() API to use the mapped and dynamic test objects, to select an item from a drop-down list in a Java application, as the following example illustrates:
    - Verifying the status of a radio button or check box
      You can use the dynamic find() API to verify the status of a radio button or check box during playback, such as whether the control was selected or not.
    - Closing active browsers before playback
      You can use the dynamic find() API to find and close all active browsers before you play back a script to ensure that there are no active browser instances before playback.
    - Closing unexpected HTML dialog boxes during playback
      You can use the dynamic find() API to close HTML dialog boxes that are displayed unexpectedly during playback, to ensure smooth playback.
- Experimental Features
  HCL OneTest™ UI contains a set of pre-releases that enable you to test various experimental features. These experimental features, while still in progress, are introduced early in the release to seek your feedback on its overall functionality and performance. You can play around with these capabilities before they are made available and supported as a general feature in an upcoming release.

Closing unexpected HTML dialog boxes during playback

You can use the dynamic find() API to close HTML dialog boxes that are displayed unexpectedly during playback, to ensure smooth playback.

HCL OneTest™ UI provides the unexpected window handling feature to handle unexpected windows that are displayed during playback. For more information about this feature, see Configuring how to handle unexpected windows during playback.

You can also use the dynamic find() API, modified as shown in this example, to close HTML dialog boxes, both Html.Dialog or Html.HtmlDialog, that are displayed unexpectedly during playback. If you use this example during playback, it takes precedence over the unexpected window handling settings in the Configure Handling of Unexpected Windows dialog box.

public static void closeHtmlBrowserDialogs() {

	
	//Get all domains and search each domain 
	DomainTestObject domains[] = getDomains();
	for (int i = 0; i < domains.length; ++i) {
		if (domains[i].getName().equals("Html")) { // Look for the HTML web domain. Once HTML is found, get the top-level test objects.
			TestObject[] topLevelObjects = domains[i].getTopObjects();
			if (topLevelObjects != null) {
				for (int j = 0; j < topLevelObjects.length; ++j) {
					
					String className = null;
					try{
						className  = (String) topLevelObjects[j].getProperty(".class");
						
					} catch (PropertyNotFoundException ex){ // Throw an exception property not found exception
															// when the requested get property was not available
						ex.printStackTrace(); // print the detailed exception if any
					}
					
					// If Html.HtmlDialog or Html.Dialog pop-up windows are displayed during playback, both are handled. 					
					if((className != null) && (className.equalsIgnoreCase("Html.Dialog")
												||className.equalsIgnoreCase("Html.HtmlDialog")) )
							 ((TopLevelTestObject) topLevelObjects[j]).close(); // The HTML pop-up window is closed.
					
				}
			}
			
			
		}
	}
	
	unregisterAll(); // Clean up any used test objects to prevent memory-related problems.