In earlier versions of TestComplete you could create tests by recording or writing script code. You could also record other types of tests like low-level procedures or HTTP tasks, but the primary source of an automated test was script code. Version 7 introduces a simple but powerful alternative to scripts called keyword tests or otherwise known as keyword-driven tests.

Keyword tests consist of operations that let you perform various test actions: launch tested applications, post messages to the test log, simulate mouse clicks and keystrokes, perform object-specific actions (like selecting a combo box item), run other tests (for instance, low-level procedures or unit tests), call script functions or short code snippets, use checkpoints and much more.

Keyword tests are very similar to macros that you create in Microsoft Access or in AutomatedQA’s Automated Build Studio. You can record these tests like you record script code. You can also create them visually from scratch in a special Keyword Test editor. Creation and use of these tests is much easier than script writing, so even inexperienced users are able to create powerful tests quickly. You can use keyword tests to perform functional testing and use scripts for advanced tasks, or combine both test types at your desire, because script routines can be easily called from keyword tests and keyword tests can be easily run from script code.

This new test type caused changes in many other TestComplete subsystems:

The recording engine has been improved. Earlier versions of TestComplete always started test recording with script recording. After the recording started, you could then activate other types of recording and record low-level procedures or HTTP tasks. These tests were called from the recorded script code. That is, you could record several tests, but scripts always acted as the “main” test. In version 7, you can choose the “main” source, so now it can be a script routine or a keyword test. Also, TestComplete now offers two commands that start test recording: Record Keyword Test and Record Script.
The TestComplete debugger has been extended and now supports debugging of keyword tests. The keyword test debugger supports all of the features that the script debugger does. You can run keyword tests to the cursor, step over or trace into the child tests, use ordinary and conditional breakpoints and so on. All of the debugger panels - Locals, Call Stack, Watch List and Breakpoints support keyword tests. Also, the script and keyword test debuggers are tightly integrated. For instance, if you debug a keyword test that calls a script routine, you can trace into this script routine and continue debugging script code in the Code Editor. Similarly, if you debug script code that runs a keyword test, you can trace into this test and step over its operations. The integration is seamless and convenient.
Settings and dialogs that supported script recording or execution now affect keyword tests. For instance, the Always start a new script setting (it specified whether TestComplete should start a new script routine or insert the recorded script statements into the current position in a script) now supports keyword testing and has been renamed to Always start a new test. All recording and running settings now affect both script and keyword test recording and playback, the items of the Recording toolbar are applied both to keyword tests and scripts, and so on.
The new test type has also caused changes in checkpoints. In previous versions of the product, you created checkpoints at design time using special items of the Tools toolbar. These items have been moved to a new toolbar that has been added to the Code Editor. These items are only used to insert checkpoints to script code. To create checkpoints for keyword tests, you use special keyword testing operations.

Overall Improvements

Testing WinCE Applications. With TestComplete version 7 you can test applications that run on PDAs and Pocket PCs. These tests can be recorded or written from scratch in the Code Editor.

TestComplete provides an object-oriented approach to PDA testing, that is, it recognizes windows and controls as objects and provides specific methods and properties that let you simulate user actions over these windows and controls. In addition, TestComplete provides specific low-level procedures that contain specific PDA events and can run on your device. You can record these procedures and then modify them in a special editor.

TestComplete 7 includes two new project items - WinCE Low-Level Procedures Collection and WinCE Tested Applications. They are analogues to the Low-Level Procedures Collection and Tested Applications, but hold the procedures and applications to be executed on PDAs.

To explore these applications in the Object Browser and to address them from tests, a new PDA node was introduced. This node is similar to the Sys node, but its children are the processes running on a PDA device and the properties of the node describe the system of the PDA.
Automatic name mapping. TestComplete 7 includes a new Map object names automatically setting. If it is enabled by default and the test engine automatically maps the names of objects you are working with during test recording or at design time. The mapped names reflect the object’s type and contents and make the created tests much clearer and easier to understand. For instance, compare the “default” long name of the Notepad window and its mapped variant:

Default: Sys.Process("notepad").Window("Notepad", "*", 1).Window("Edit", "", 1)

Mapped: Aliases.notepad.wndNotepad.Edit

For more information about automatic name mapping, see Name Mapping - Overview.
New tool for exploring the structure of an application’s UI. TestComplete version 7 includes the GUI Explorer - a new built-in tool that was engineered to help you explore the structure of applications’ windows and controls. Using the GUI Explorer you can easily determine the parent-child relationships between controls and the layout of controls on your application’s forms.
Table variables. TestComplete version 7 introduces a new type of variable called table. These variables allow you to store a two-dimensional array of values for use in your projects, project suites and keyword tests. TestComplete includes specific editors and scripting objects that let you easily get and set values to table elements at design time and during a test run.
Testing Qt applications. TestComplete 7 includes support for 32-bit and 64-bit applications created with the Qt framework. It provides advanced recording and playback support for various Qt controls in order for you to create comprehensive functional tests. In addition, Qt applications are “open” to TestComplete, that is, internal elements of the application’s objects are also available to the test engine. So, you can test Qt applications in white-box mode as well. See Testing Qt Applications.
Support for wxWidgets. TestComplete 7 supports Visual C++ Open Applications created using the wxWidgets framework. Like MFC objects, wxWidgets objects are now “open” to TestComplete, that is, their internal methods, properties and fields are available for use in your tests. For more information, see wxWidgets Visual C++ Applications Support.
Custom controls support SDK. The TestComplete SDK now allows developers to create plugins that provide high-level support for custom .NET and WPF controls. These plugins can widen TestComplete abilities to interact with custom controls during test recording and playback and to retrieve and modify their data. For example, they will allow testers to record actions over a particular .NET or WPF control using custom methods instead of coordinate-based clicks. To learn more about creating custom control support plugins, see the TestComplete SDK documentation.
Testing console applications. TestComplete 7 adds extended support for console applications and provides special features for obtaining the console contents. See Testing Console Applications.
To Do panel. The new To Do panel displays all TODO comments found in the script code of the currently opened project suite. This way, you can now quickly locate unfinished tasks, tests scripts that need certain functionality added to them or any other type of work marked as to be done. See About the To Do Panel.
Bugzilla support. In addition to Microsoft Visual Studio Team System and AutomatedQA’s AQdevTeam, TestComplete now supports posting bug reports in Bugzilla.
Better UI. The TestComplete user interface includes a lot of improvements aimed at simplifying various tasks. You can find improvements in almost any editor or window. For example:
- Many panels now have the Quick Search box that lets you quickly find the desired item,
- Dialogs and wizards that are used to select an object from screen (such as the checkpoint wizards) now let you not only to pick the object with the target glyph (), but also to point to the object and enter the object name manually.
- New Organize Tests item on the Project Explorer’s toolbar helps you easily open the Test Items editor
- And much more.
Start Page. The new Start Page of TestComplete provides a quick way for you to access your most recently used test projects or create new ones. It also contains links to useful TestComplete resources so that they are always available. You can configure TestComplete to display the Start Page each time it is launched.
Interactive Help. TestComplete includes a new Interactive Help panel. This panel displays brief descriptions, hints and links to documentation that match the current working context. The panel changes its contents according to the working context and assists you in performing testing operations. It is a good instrument for newcomers to get acquainted with the product.
Improved optical character recognition (OCR). The OCRObject program object that is used for text recognition has a new OCRObject.DefaultOptions property. It provides access to the recognition settings’ default values. This allows you to restore the default options after using custom recognition settings.

The OCROptions object also has a number of new properties that allow you to tune the recognition procedure more precisely.

Extended Support for Third-Party Controls

Support for third-party control libraries. TestComplete 7 introduces advanced support for controls included in the following libraries:
- Windows Forms
- Developer Express XtraEditors and XtraBars
- Infragistics NetAdvantage
- Syncfusion Essential Studio
- MFC Feature Pack for Visual C++ 2008
- Qt
- Telerik RadControls for ASP.NET
TestComplete includes new, special, objects that provide access to these controls, their items and data, allows you to record and simulate high-level user actions over these controls and create checkpoints to verify their state and contents. The supported control types include ribbon controls that are used more and more often to create modern applications' UI.
Extended support for grid controls. TestComplete 7 adds support for the following popular grid controls:
- Borland TStringGrid
- Developer Express XtraVerticalGrid, PropertyGridControl and XtraTreeList
- Microsoft MFC PropertyGrid
- Rogue Wave Stingray Objective Grid .NET
- Syncfusion GridControl and ScheduleGrid
- Xceed Grid for .NET
So, you can now record and replay various actions over these grid controls, easily retrieve data from them, create checkpoints to verify their data and perform other testing operations.
New grid actions. TestComplete abilities to interact with formerly supported grid controls have been extended with new methods and actions:
- The FindRow method, which lets you locate a grid row by a cell’s value.
- The ClickNewRowCell and other actions for simulating actions over the “Add New” row.
- The HoverMouseCell and other actions for hovering various grid elements with the mouse pointer.
Support for XtraGrid Layout View. TestComplete can now record and simulate actions over Developer Express XtraGrid controls that use the layout view to display data.
Extended Object Mapping. The Object Mapping settings have been improved to allow you to map not only your custom controls (such as derived grid controls), but also the control’s child elements (for example, custom grid views) to the appropriate base types. This helps you enable advanced support for complicated custom controls. See Object Mapping and Working With Custom Child Controls.
New Text Recognition service. Previous versions of TestComplete recognized custom controls by the class name of the control’s window. A new Text Recognition subsystem can recognize the objects by their text. This technology lets you simulate user actions over those windows and controls. This was impossible in previous versions of TestComplete. For instance, TestComplete 7 can now recognize labels on a black-box VCL form as objects. These components do not have window handles and are drawn on the form’s surface, and they were not recognized as objects by earlier versions of TestComplete. Version 7 can recognize them and allows you to obtain the labels’ text and simulate user actions over them.

Similarly, using the new technology TestComplete can recognize items of the menus. So, you can simulate mouse clicks over these menu items and obtain the item’s text with ease.

Improved Recording

Adding tested applications automatically. TestComplete can now automatically adds applications that you work with during test recording to the Tested Applications collection of your project. You can enable this behavior using the Add applications to the list of tested applications and Show 'Add <ApplicationName> to the list of tested applications?' message options. See Recording Automated Tests for details.
Better recording of application launch. TestComplete now tracks if you launch the tested application from Windows Explorer (for example, via the Start menu, from the Quick Launch bar, via a desktop shortcut, and so on). When it detects a launch this way, it automatically records the Run TestedApp operation in a keyword test or the TestedApps.AppName.Run method in a script instead of recording actions over Explorer.
Meaningful variable names. When recording script code, TestComplete uses variables to store object references. In TestComplete 6 and earlier these variables were named p1, p2, w1, w2 and so on. Version 7 includes a new Smart variable names option. When it is enabled (by default, it is enabled), the script recorder generates names that match the object’s type: wndNotepad, btnOK, dlgFont and so on. These names make the recorded script easier to understand.
Recording without variables usage. A new Do not generate variables option has been added to let you prevent TestComplete from using variables during script recording and make it address processes, windows and controls in the recorded script code by full names.
Better recording of keystrokes. Now TestComplete records keystrokes in editors differently depending on an editor type. If an editor is a single-line editor, changes made in the editor are recorded by assigning a specified value to the wText property of the object that is associated with the edit control. If an editor is multiline, TestComplete records changes made in the edit control as keystrokes using the Keys action of the object associated with the edit control. See Recording Specifics.
Improved Recording toolbar. The items on the Recording toolbar were reorganized. This makes the toolbar even simpler to use.
The functionality of the Add Code to Script dialog has been changed. Previously, this dialog allowed you to insert code statements and comments into the recorded script. Now the dialog can insert only comments, but it can insert them both into the recorded script code and into keyword tests. The dialog was renamed to Add Comment to Test.

Test Log Enhancements

Quick Search box. The test log now includes the Quick Search box that helps you easily filter the log contents and view only those messages that include the entered words.
Summary panel. The test log now includes the Summary panel that displays brief results of the project or project suite test run.
Call Stack panel. Now TestComplete may trace and log information about the execution order of tests that led to posting of error, warning, informative and other types of messages to the test log. This information is displayed in a new Call Stack panel of the test log. This panel will help you better understand what happened during your project run and find the cause of the problem quickly.

By default, the call stack tracing is only enabled for error messages, but you can use a new Log.CallStackSettings object to enable it for other message types. See Collecting Call Stack Information for Log Messages.

Object Browser Improvements

The Object Browser panel includes several improvements:

New tool for exploring the structure of application’s UI. TestComplete includes a new GUI Explorer instrument that helps you visually explore the structure of controls on applications’ forms and windows. To display the GUI Explorer, right-click the desired window in the Object tree of the Object Browser and choose GUI Explorer from the context menu. See Exploring an Application’s Graphical User Interface.
Tested applications are marked out. Nodes of applications under test are now displayed in bold. This helps you find them in the Object tree faster.
Quick search in object members. The Object Browser displays the Quick Search box at the top of the Properties, Fields, Methods and Events lists. This text box helps you find the desired property, field, method or event in the list by typing its name.
Adding tested applications. The context menu of the Object Browser includes a new Add Process to TestedApps command that lets you quickly add any currently running process to the project’s Tested Applications collection.
Switching Capture mode made easier. The Object Properties window now contains the button that lets you quickly toggle the Capture mouse mode on and off.
Preview of images returned by object properties. The Object Browser shows a specific button for those properties that return images. Clicking on this button opens the Image Viewer window where you can preview the image.

Changes in Delphi and C++Builder Open Applications

In TestComplete 7, support for Delphi and C++Builder applications have been dramatically improved:

Auto-Open Delphi and C++Builder applications. In earlier versions, to create an Open Application in Delphi or C++Builder, you had to re-compile your project with special units that came with TestComplete. In TestComplete 7, Delphi and C++Builder applications are always “Open” thanks to the new Delphi and C++Builder Open Applications Support plugin. So, there is no need to compile the tested application in a special way to get access to its published members. See Testing Delphi Applications - Overview and Testing C++Builder Applications - Overview.
Support for CodeGear RAD Studio 2009 applications. TestComplete now supports Delphi and C++Builder Open Applications created in CodeGear RAD Studio 2009. So, it is now possible to test these applications in white-box mode.
TestComplete includes a new StripTDS utility that extracts internal debug information from Delphi applications and saves it into external files. This way, it allows developers to create release builds of Delphi applications with external debug information. The application’s size is not increased and the application can be delivered to customers. The debug information helps testers and TestComplete call the protected and private methods and properties from tests. In other words, the utility helps you test the release version of your application as an Open Application. For more information about the utility, see About StripTDS.
The StripTDS utility and auto-openness of Delphi and C++Builder applications make the PRegister utility obsolete. It is no longer included in TestComplete.

Improved Web Testing

Microsoft Internet Explorer ver. 8 is now supported, so that your tests can get access internal elements of the web pages shown in Internet Explorer 8.
Testing Rich Internet applications. In TestComplete 7, recognition of objects in Flash, Flex and Silverlight applications has been improved, which lets you carry out better functional testing of these applications. See Testing Flash and Flex Applications and Testing Silverlight Applications.
Support for Telerik RadControls for ASP.NET. TestComplete recognizes Telerik ASP.NET controls that reside on web pages and provide specific methods and properties that simplify the simulation of user actions over these controls. For more information, see List of Web Telerik Objects.
Now TestComplete supports processing of events of web applications’ dialog windows launched in Internet Explorer.
The object hierarchy of web pages displayed in Firefox using the Tree web model has been slightly changed to make it more like that of Internet Explorer. The changes, however, may cause object recognition issues during playback of your legacy tests that use the Tree model. To enable legacy tests to run successfully, the Use Firefox web tests compatible with TestComplete 6 option has been introduced.

Load Testing Improvements

Filtering recorded traffic. TestComplete can now filter out traffic sent and received by specific applications during traffic recording. You can specify the applications to be ignored in the Exclude Applications list.
Now it is easier and more convenient to execute load tests from scripts. In earlier versions, to execute a load test created visually, you had to write a lot of script code. Now you only have to call one program object’s method to run it.
TestComplete 7 includes predefined settings for emulating Mozilla Firefox v. 3 and Opera v. 9.5 during test playback.

Name Mapping Improvements

In addition to automatic name mapping, the Name Mapping engine includes a lot of other improvements:

Merge name mapping data. It is now possible to merge two or more name mapping schemes into one. Thus you can import an existing scheme from another project.
Re-map objects at runtime. Now if TestComplete cannot find an object corresponding to mapping criteria at runtime, it will ask the user to pick the target object and will update its mapped information. This behavior is controlled by the Automatically Update Name Mapping Items option.
Map objects by child objects. You can now use the presence of certain child objects as the recognition attributes of parent objects.
Easily change the hierarchy of mapped objects. The hierarchical level of mapped items can be modified by dragging the desired item within the tree of mapped objects. Unnecessary items can also be excluded.
Wait for objects specified by aliases. The new WaitAliasChild method allows you to wait until an object specified by an alias becomes available.
Perform search while refreshing name mapping information. In previous versions of TestComplete, the Name Mapping engine sought for a mapped object only among child objects of its parent object. Version 7 includes a new Find this node on any level of NameMapping tree option that lets you search on deeper levels. The option is object-specific. A new Extended Find column of the Name Mapping Editor indicates whether this option is enabled or not for a certain mapped object.

If the option is enabled for a certain mapped object, TestComplete will search for that object in the system starting from a certain level of the object tree down to terminal nodes. If the option is disabled, TestComplete will use the default search approach, that is, it will only search among the child objects of the parent object. The option makes your tests more flexible as it lets you map and work with objects whose position in the object tree changes.
Better name mapping performance. The overall performance of name mapping has been improved and is now a lot faster.
The automatic name mapping feature has made predefined name mapping templates obsolete. They have been removed. User-defined name mapping templates are still supported.

Improved MSAA Support

More intuitive MSAA object model. TestComplete 7 introduces a new MSAA object model that addresses objects directly by their accessible roles and names instead of the MSAAObject method and synthetical identifiers. For example: Button("Add"), List("Products") and so on. This way of addressing objects makes the tested application’s object model and the tests that use this model clearer and thus more maintainable. To learn more about the new object model, see Addressing Objects in MSAA Open Applications.

The old MSAA object model, however, is also available and can be turned on using the Work with MSAA objects in mode compatible with TestComplete 6 and earlier project property. This way, you can run your legacy tests without any changes.
Extended support for MSAA objects. The MSAA engine now adds a number of extended properties and methods to exposed objects depending on the object role. The extended members let you obtain the object state and contents, perform the default action associated with the object, and so on. See Properties Added to MSAA Objects and Methods Added to MSAA Objects.

Changes in .NET Support

More stable work with .NET assemblies. To call functions of .NET assemblies, TestComplete now loads these assemblies into an individual process (tcHostingProcess.exe). So, if any serious error occurs during the execution of a managed routine, only this process will crash and the TestComplete main process will stay alive. TestComplete supports the use of 32-bit and 64-bit .NET assemblies and can create an assembly hosting process with a corresponding architecture. You can select the preferred architecture of this hosting process in the project’s CLR Bridge options.
.NET and WPF controls SDK. TestComplete SDK includes detailed descriptions of how you can implement recording and run-time plugins for custom .NET and WPF controls. Using these plugins, you can define your own methods and properties that simplify how you work with these controls, and TestComplete will record and play back your actions over these controls using these custom methods and properties. This feature is useful, for instance, for those developers who would like to provide testing support for their controls.
TestComplete now appends a new VCLNETControlIndex property to forms and controls of .NET applications that were created with the Borland VCL.NET library. This property returns the index of the form or control in the child objects collection of its parent object.
TestComplete adds two new properties - WPFControlText and WPFControlIndex - to objects of WPF applications.

Changes in Java Support

Improved support for Swing Menu controls. Now, the Object Mapping settings allow you to define what classes TestComplete should consider as the Swing Menu items, which of them can have child menu items and which can be checked. By default objects of the javax.swing.JMenu class are interpreted by TestComplete as menu items that can have child items, the javax.swing.JCheckBoxMenuItem objects are interpreted as check box menu items, and the javax.swing.JRadioButtonMenuItem objects - as radio button items. Objects of all other classes (for instance, javax.swing.JMenuItem and all of its descendents), which names are not included in these Object Mapping settings, are interpreted by TestComplete 15 as menu items, which may not be checked and do not have child items.
Changes in working with JTree controls: in earlier versions of TestComplete the path to the tree node, over which a click should be simulated, always started with the “|” character, for instance, “|Item 1|Item 2|Desired Item”. This approach has been changed and now the leading “|” character is not needed. Compatibility with old versions has been added and old tests will run without modifications.
TestComplete now appends a new AWTComponentName property to windows and controls of Java applications. This property returns the object’s name as it is defined in the application’s source code.

Code Editing Improvements

Code Completion for applications’ objects. In addition to pre-defined scripting objects, the Code Completion window now displays all currently running processes, their windows and objects as well as methods and properties of these objects.
Code Editor toolbar. The Code Editor now has a toolbar that provides commands to run the current script routine, generate checkpoints, format and outline script lines and navigate through script routines.
Better customization of Code Completion behavior. The Code Editor’s Autocompletion option has been replaced with two new options:
- Auto Pop-Up - Specifies whether the Code Completion window should be automatically invoked while you are typing script code.
- Show full tree - Specifies whether Code Completion should list all available objects, properties, methods, script statements, routines and global variables, or only those that can be used at the current insertion point.
You can find these settings in the Code Editor - Editing options.
Adding unit references is now easier. The Add Unit References command has been added to the context menu of script units in the Project Explorer panel. It allows you to easily add references to other script units without having to write the appropriate scripting statements manually.
Improved outlining. You can now quickly view the contents of a collapsed block by placing the mouse pointer over the ellipsis icon (...) on the right of the block’s first line. See Outlining.
New code metrics. The Code Explorer now traces the number of local variables and the percent of comments in script routines to help you create better maintained test scripts. See Code Metrics.
Syntax highlighting import from development tools. TestComplete now allows you to import syntax highlighting schemes from Microsoft Visual Studio, Borland Delphi, Borland Developer Studio or CodeGear RAD Studio.
Viewing custom source files. Also, the Code Editor can now be used to view C#, C++, Visual Basic, Pascal, Java, Assembler, COBOL and Fortran source files and supports syntax highlighting for these languages.

Project Improvements

Easier management of test items. Creating and managing project’s test items has been made easier:
- You can now create test items by dragging tests from the Project Explorer and Code Explorer panels to the Test Items editor.
- Test items can now be organized into groups. Grouped test items can be enabled or disabled at once by simply checking or unchecking their parent group.
- You can quickly open the Test Items editor using the new View | Organize Tests menu command or the Organize Tests button on the Project Explorer toolbar.
- The Stop on error and Stop on exception options of the Test Items editor have the new Test Item state. If this value is chosen and an error or exception occurs, TestComplete would terminate the current test item but proceed with the execution of the remaining test items.
- The Test Items editor now has a toolbar that provides quick access to the editor’s most frequently used commands.
- The Test Items editor includes a new Jump To Test command that lets you quickly open the appropriate test.
- Test items are now copied along with their parameter values.
- To avoid confusions, the Main Script Routine property of the Script project item has been removed. When you open a project created in an earlier version of TestComplete, TestComplete 7 replaces any references to the Main Script Routine with the name of the appropriate routine.
  
  Also, earlier versions of TestComplete automatically added a test item that referred to the Main Script Routine when you created a new project. Now it does not create these test items in new projects.
Delete files from disk when removing them from a project. In previous versions, when project elements were removed, only references to them were excluded from the project or project suite, while the actual files were kept. Now you can choose whether you want to remove the project node or folder logically by removing references to it or physically by deleting the underlying files.
Log export from Project Explorer. The context menu of the Project Explorer panel now contains a command that lets you quickly export test logs.
The Advanced folder of the Project Explorer. Now the test projects that you create in TestComplete contain the Advanced folder. TestComplete leaves frequently used project items as children of the project node and moves all other nodes to the Advanced folder. That is, this folder contains the items that are used rarely or are aimed at performing advanced tasks.

TestComplete includes a new Project structure setting that allows you to specify which project items will go to the Advanced folder and which will remain as the project’s child nodes. You can find this new setting in the Project Options dialog. To invoke it, choose Tools | Options from the TestComplete main menu and then select the General | Project settings group in the ensuing Options dialog.
The Create New Project dialog now functions in two modes: Classic and Advanced. In Classic mode, the dialog lets you specify the project name, location and scripting language. You can use it to create new projects quickly. In Advanced mode you can also select the project suite name, specify project template and define project items and elements to be included into the created project.

Changes in Stores and Checkpoints

New Stores wizards. TestComplete now includes special wizards that allow you to add new items to the Objects and Regions collections easier.
New Checkpoint Selection wizard. TestComplete includes a new Checkpoint Selection wizard that helps you choose the appropriate checkpoint to perform a testing task. The wizard will especially be helpful for inexperienced users who are not aware of checkpoint types.
Improved checkpoint wizards. The Property Checkpoint, Object Checkpoint and Region Checkpoint wizards have been improved to provide better step-by-step assistance in checkpoint creation. In addition, they now allow you not only to select the target object from screen, but also to enter its name manually (for example, you could paste it from the clipboard).
The Compare methods of the WebAccessibility and WebComparison objects have been changed. Now they can use the Web Accessibility and Web Comparison source pages as the default value of the PageObject parameter. So, the script code that TestComplete generates for web checkpoints, includes a call to the Compare method without parameters.
The Web Comparison checkpoint now includes a new Read content from a server property that specifies whether the test engine will read the web page’s content from the browser’s window or from the web server. Enabling this option makes the comparison more stable.
The Web Comparison Editor now includes the Update button that lets you update the contents of the currently selected web page.
Now you can specify a new source page directly from the Web Accessibility Editor.
The Table Element Editor has been modified. Now you can update the stored data from the corresponding table object by pressing the Update button.
Quick Search feature. Now you can filter the items in the Files, Objects and Regions Editors by typing text in a new Quick Search edit box.

Script Extension Enhancements

Create custom keyword test operations. In TestComplete 7, you can create extensions that add custom keyword test operations, such as checkpoints or any other operations you need in your custom test environment. See Creating Keyword Test Operations.

TestComplete 7 includes the Log Attributes keyword test operation that was created with the script extensions technology.
Greater access to TestComplete objects. Script extensions now have access to more of TestComplete intrinsic objects. The newly available objects are: ADO, DDT, Indicator, dotNET, ManualTestBuilder, OCR and Runner. So, you can now easily create script extensions that work with databases, Excel and CSV files, make use of .NET classes, create manual tests, execute user-defined routines and perform other useful operations provided by the mentioned objects.
Determine the user’s scripting language. The Syntax object has been extended with the CurrentLanguage property that lets you determine the scripting language used in the user’s current project.
Categorize script extensions. The schema of the description.xml file has been slightly changed. Now, it includes the Category element that defines the category to which the script extension belongs. Extensions listed in the Script Extensions dialog are now grouped according to their categories.

The older description.xml scheme, however, also remains valid. In this case, the category name is taken from the Name attribute of the ScriptExtensionGroup element.

Changes in Programming Objects

New methods to shut down and reboot the computer. The Sys object has been extended with two methods: Shutdown and Restart. They allow you to shut down and reboot the computer once the tests are done. For details, see Shutting Down and Restarting Computer After Test Run.
Getting file version information. A new VersionInfo property has been added to the aqFileInfo object. This property allows you to get version information built into the file. Both single-language and multi-language version information resources are supported.
Determining Windows edition. The Sys.OSInfo contains a new property, Edition. It specifies the edition of the operating system TestComplete is running on - Standard, Professional, Enterprise and so on.
Reading from 64-bit registry. The Storages.Registry method has a new parameter, RegistryType. It lets you specify which registry version -- 32-bit or 64-bit -- should be read when TestComplete is used on a 64-bit operating system.
Retrieve and modify locale information. The GetLocaleInfo and SetLocaleInfo methods added to the aqEnvironment object enable you to obtain and change various information about the system and user locales, including regional and language options specified in the Control Panel.
Getting console window’s text. The Window object now provides the wText property for console applications. This property lets you obtain the text from the console window.
Check and unchecking tree view items. Using the new Win32TreeView.CheckItem and Win32TreeViewItem.Check actions and the Win32TreeViewItem.Checked property, you can simulate checking and unchecking of tree view items and determine the items’ checked state.
Determining system processes. The process object contains a new System property that indicates whether the process is a system process or not.
Using wildcards in file system operations. It is now possible to use wildcards (* and ?) to specify a mask of files and folders to be copied, moved or deleted by the appropriate methods of the aqFileSystem and aqFile objects.
Changing global image format settings. The new Options.Images object provides access to global image settings specified in the Engines - General Options dialog and allows you to modify these settings during the test run. This object also contains the CreatePictureConfiguration and SetDefaultPictureConfiguration methods, which are similar to the corresponding methods of the Log object. The Log.CreatePictureConfiguration and Log.SetDefaultPictureConfiguration methods became obsolete and are supported for backward compatibility only.
The Beep, IsValidIdent, SysErrorMessage and Win32Check methods were moved from the Utilities object to the aqUtils object. The Utilities object is no longer available in the Code Completion window.
The Files.Add, Regions.Add and Objects.Add methods have a new parameter that lets you specify whether to copy the file to the project folder or add a reference to the original file instead.
The ManualTesting.Resume method now has a new parameter that specifies whether to delete the information about the state of the suspended manual test after it has been resumed. You can also delete this information using the newManualTesting.ClearResumeInfo method.
Parameters of the HoverMouse action are now optional and when omitted, specify that the mouse pointer be moved to the object’s center point.
The Win32ListView.wItem property now lets you specify the target list view items and subitems not only by indexes, but also by captions and masks.
The Find, FindChild, FindAll, FindAllChildren and FindID methods now have an additional Refresh parameter. It lets you specify whether TestComplete should update the object tree to reflect the latest changes in the tested application, or perform the search in the cached copy of the object tree.
The OpenTextFile and OpenBinaryFile methods of the aqFile object now have an additional parameter that specifies whether the methods can create new files or overwrite existing files. For more information, see the method descriptions.
It is now possible to skip names of the aqConvert, aqEnvironment, aqObject and aqUtils objects when calling their members in scripts. This applies to both regular TestComplete scripts and the code of script extensions.
The aqFileSystem object now provides a number of faNNN constants corresponding to file and folder attributes, which you can use instead of the hard-coded attribute values in the aqFileSystem.CheckAttributes, aqFileSystem.ChangeAttributes and similar methods.
The aqFileInfo object contains a new CertificateInfo property that provides information about the file’s authentication certificate.

Miscellaneous

In earlier version of TestComplete, the image settings for various TestComplete subsystems, such as the test log or the Visualizer plugin, were configured separately. Now all subsystems use global image settings specified in the Engines - General Options dialog.
The TestComplete indicator now displays the progress of the currently executed operation, such as waiting for an application’s object.
The Select Test dialog, which is used to select a test from those available in a project, has been improved. Now it provides the quick search functionality and an option to show or hide test categories.
You can now specify the timeout for network suite requests using the new Timeout option.
The Variables page of the project and project suite editors have been improved. Now it contains special sections for editing stored and temporary variables.
The Watch List and Locals panels include new context menu items (Inspect, Collapse Parent, Add Watch) that make it easier to explore objects’ properties.
A new options category, Markers Options, allows you to customize the appearance of specific keyword test operations and script lines. For example, the currently executed line or operation, those that have breakpoints set on, and others.
The Object Tree performance has been improved.
The location of TestComplete samples has been changed. On Windows Vista and Windows Server 2008, the samples are installed in the <Users>\Public\Documents\TestComplete 7 Samples folder. On other operating systems, the samples can be found in the <Documents and Settings>\All Users\Documents\TestComplete 7 Samples folder.
Docking is now disabled by default. This is done to prevent accidental changes of the panels layout.

The indicator icon is displayed at the top-right corner of the screen during test playback.
See the Indicator object description for more information.

Features Added to TestComplete 7.0

Keyword Testing