This topic describes the changes made to TestComplete 2.0. For information on the changes made to other versions of the product, see Version History.
- Now TestComplete supports Windows XP in addition to Windows 95, 98, ME, 2000 & NT 4.0 (SP 3 or later).
- Testing Web pages. TestComplete includes special means for testing Web pages. To access elements of the page, TestComplete uses the HTML object model. The created scripts are very similar to VB or Java scripts you may use on your Web pages. Also, TestComplete provides its own object model, which may be useful to get an overview of the page. TestComplete adds specific methods and properties to the Internet Explorer process and windows that display the Web pages. These methods and properties allow you to navigate to the desired web page, delay the script execution until the page is fully downloaded, etc. The Web testing feature is available in the TestComplete Enterprise version only.
- Forms. Now you can create forms in TestComplete projects. The use of forms in TestComplete is very similar to the use of forms in Visual Basic, Delphi or C++Builder. Each new unit may have a form associated with it. The new Component Palette panel holds a list of components that can be placed on a form. This list is entirely customizable. To add a component to a form, you should simply select it in the Component Palette and then click somewhere on the form to specify the component's location. A form can hold any ActiveX component. For instance, you can put the Microsoft ADO Data Control on it and use this control for work with databases from scripts. (This is a new way of working with databases from scripts. You may prefer to use the ADO Data Control rather than the use of the ADO or BDE plugins.) Properties of the selected components can be changed in Component Inspector. This panel was designed specially for modifying the component properties. It looks like the Properties window in Visual Basic, or like the Object Inspector in Delphi or C++Builder. Though forms can hold any ActiveX components, their primary task is to create event handlers for events (see below).
- Events and Event Handlers. Now TestComplete can trace events that occur during the script execution. These can be events that occur in TestComplete or in any ActiveX object located in an external application, for example, events in Microsoft Word. You can create event handlers for these events. For instance, you can create specific scripts which are called when an unexpected window appears, when TestComplete starts or stops a script, or when MS Word creates a new document. If your tested application contains an ActiveX control, you can handle its events too.
- To process these events, TestComplete uses the ProjectEvents control (an ActiveX control that contains events that can be handled). This control can be placed in a Connected Application (or in any other application) to process the desired events. Note that the list of events of the ProjectEvents control is customizable. You can add new events or remove existing ones using the new ActiveX Wizard panel.
- Testing Java and .NET applications. TestComplete includes two plugins specially designed for testing Java and .NET applications. The plugins include files that allow you to create and test Java and .NET Open Applications. That is, being compiled with these files your application opens its internal elements to TestComplete. For Java applications that means access to public methods and fields; for .NET applications - access to public, protected, private, internal and private internal properties and methods.
- Changes in C++ scripts. The TestComplete forbearer, AQtest, can only record scripts in C++. To run them, you should insert the recorded script code to a C++ Connected Applications. Now TestComplete can both record and play back C++ scripts. The syntax of C++ script has been changed. The syntax used in AQtest is still supported, though.
- Changes in C++ Open Applications. In the previous version scripts got access to the application internals either via the Debug Info Agent™ or via wrappers to MFC classes. There was one inconvenience: MFC wrappers cannot give access to user-defined methods and fields. They can be accessed by the Debug Info Agent™. In fact, you could not have rapid access to MFC and user-defined class members. This inconvenience has been eliminated. Now Debug Info Agent™ and MFC wrapper work together and provide you with rapid access to both MFC and custom methods simultaneously. Also, TestComplete contains wrappers for almost all MFC classes and Win32 structures.
- MSAA Plugin. This
plugin provides deeper access to application windows. Each
windowobject gets a number of child objects that represent the window's title, menus, scroll bar, client area, etc. as programming objects in scripts. Also, this plugin provides access to non-windowed controls of windows that implement the IAccessible interface. Since some windows implement this interface by default (for example, forms in Visual FoxPro 7.0 or later), the MSAA plugin makes them more "open" for TestComplete even without recompiling of the application.
- Test Suites. In previous versions, if you needed to run several scripts you had to create a "main routine". That is, you had to create a script routine that would call other script routines in the desired order. To modify the sequence, in which scripts are run, you had to change source code of the script. Now, this task can be performed much easier with the help of test suites. A test suite is a collection of script routine. A project can have any number of test suites. The new Test Suites panel displays all test suites that exist in the project. There is no need to modify the script code now. You can modify the sequence, in which routines are run, by simple dragging test suites in the panel.
- Project Suites. In TestComplete, project suites are similar to project groups in Visual Basic, Delphi or C++Builder or to workspaces in Visual C++. Each project suite includes a number of projects that can be run in any desired sequence. The sequence, in which the projects are run, can be easily modified.
- Local Variables panel. This panel maintains a list of variables that hold computer-dependent values, for instance, paths to files. This feature assists in porting TestComplete projects from one computer to another.
- The Test Log has some improvements:
- For network projects it can display results stored on other computers in the local network.
- Both the Tests
and Messages tables of the Test Log panel
can now display testing results using a tree-like structure. TestComplete uses
this feature to display results of a test suite run. The
Logobject contains new methods,
CloseNode, that let you create child nodes from scripts.
- There are several new methods and objects that provide access to the test log from scripts.
- The new Load Mode option specifies the mode of loading results into the Test Log panel. There are three possible modes: Current, Accumulative and All. They are intended to decrease the time needed to load results and to decrease the amount of memory used by TestComplete.
- The new option, Priorities, let you modify priority settings visually. Earlier you can do this only from scripts.
- Now you can post images to the test log in the .gif format (in previous versions, you could post only .bmp and .jpg images).
- The Object Browser panel and the Object Properties window have a new page, Events, that displays the events of the object being explored. The context menu of the Object Properties window also has a new item, Highlight in Object Tree. It selects the object, whose properties are currently displayed in this window, in the Object Browser panel.
- Now the Pause/Resume shortcut stops and resumes both the script recording and playback. (In previous versions, it only stopped the recording). The Stop shortcut stops both scripts and Connected Applications.
- Improvement in the image comparison: If two
compared pictures are not equal, the
Regions.Comparemethod logs an image that explains the difference between the pictures. On this image, unequal pixels are marked with red.
- The PRegister utility has one more command-line argument, -console. If it is specified, PRegister sends the output to console rather than to the text box located at the bottom of the PRegister window. Also, PRegister now supports exit codes that let you determine if the wrapper files were generated successfully.
- The TestComplete
Enterprise version includes two additional products: TestRecorder
and TestExecute. Both products were
built via the TestComplete technology. They support all objects and plugins
used in TestComplete, but require fewer resources than TestComplete.
- TestRecorder allows you to embed the recording capability into your applications. The recorded scripts are fully compatible with TestComplete. Later they can be run in TestComplete or in TestExecute.
- TestExecute is a command line utility that allows you to run TestComplete projects and to log results on computers where TestComplete is not installed. You can purchase an unlimited distribution for TestExecute. It can be even installed on your customer computers to play back script routines there.
Interfaces to Win32 objects
TestComplete provides specific objects,
methods, properties and actions used for testing of the following Win32
Win32Menuobject has new properties that provide access to menu items from scripts.
PopupMenuactions of window objects were converted to properties. This let you explore the menu structure directly within the Object Browser.
- Name Mapping plugin. This plugin let you map object names to custom ones. This makes the scripts more readable and solves a problem with recognition attributes. In AQtest, if the recognition attributes of an object changed from one application build to another, you had to modify source code of your scripts (multiple changes). Now you have to modify only the mapping settings (one change only).
- DLLAccess plugin. This plugin allows scripts to call routines from almost any dll. There is no need to re-compile the dll in a special way.
- Classes plugin. Allows you to create custom classes in scripts.
- Storages plugin. This plugin provides several objects that allow you to read data from and to write it to .xml, .ini and binary files as well as to Windows Registry.
Runner objectallows you to control the script execution from the script. It includes three methods that allow you to stop the execution and to run a script routine by specifying its full name (unit_name.routine_name).
- New built-in routines:
RaiseEvent- Generates an event for the specified object. The list of available events is displayed on the Events page of the Object Browser panel.
GetListCount- Functions used to work with strings in which values are separated with line breaks (
IsSupported- Checks if the object contains a property or methods with the specified name.
These four routines are available in both the Standard and Enterprise editions of TestComplete. The following five routines exist in TestComplete Enterprise only. They provide extended support for data-driven testing:
SetValue- Gets and sets a value of an object property by the property name. You can use these methods if you are not sure whether an object contains the desired property.
CallMethod- Calls an object method by its name.
GetCSVItem- Functions used to work with strings in which values are separated with commas.
New method common for all tested objects:
Validate- Generates the
OnValidateevent. You can write an event handler for this event to check values of the object properties.
New methods and properties of the
Close- Closes the process by sending the close command to its main window.
Terminate- Terminates the process.
CommandLine- The command line passed to the process when it was created.
VMSize- Works in Windows NT, 2000 and XP only. Returns the amount of memory used by the process.
Clipboardproperty of the
Sysobject lets you place and read text to and from the Clipboard.
A new parameter of the
Sys.Keys()function, [Pnnn], allows you to pause text "typing" for the specified number of milliseconds.
WaitChildroutine now supports wildcards (* and ?). This allows you to search for child objects whose recognition attributes change from one application run to another.
- The Evaluate Dialog includes the Inspect button. It lets you explore properties of the evaluated objects. (Currently, this feature works for DelphiScript only.)
- TestComplete includes the new printing system. In earlier versions, the printed capabilities were rather plain and unsophisticated. Now the printed output can be customized for page properties, font style and color, background, etc.