Quick Test Professional

QTP Developed by Mercury InteractiveIt is a Functionality Testing ToolVersions of QTP are 6.0, 6.5, 8.0, 8.2

It supports Client server, web, ERP and Multimedia technologies such as VB, VC++, Java, Power Builder, Delphi, Dot Net, Flash, SAP, Seibel, Oracle Apps, People Soft, Terminal Emulator,HTML and XML. It records our business operations in VB Script.

Note: The Multimedia Add-in is not supported in QuickTest Professional 8.2.

Supported Environment:

Operating System: Windows 98 SE, Windows 2000-Service Pack 3 or Service Pack4, Windows XP-Service Pack 1 or Service Pack 2, or Windows 2003 Server.

Memory: 128 MB of RAM For 8.0 and above 256 MB of RAM

Free Hard Disk Space: 200 MB of free disk space for 8.0 and above 250 MB of free disk space for application files and folders, and an additional 120 MB of free disk space on the system disk (the disk on which the operating system is installed).After QuickTest Professional is installed, it is recommended to have at least 150 MB free disk space on the system disk for the operating system and QuickTest Professional to run correctly.

Browser: Microsoft Internet Explorer 5.5 Service Pack 2-6.0.Netscape 6.1, Netscape 6.22, Netscape 6.23, Netscape 7.02, and Netscape 7.1 .AOL 8.0 and 9.0 .

QTP Testing Process: It Consists of Seven main phases.1. Preparing to record2. Recording a session on your application3. Enhancing your test4. Debugging your test5. Running your test6. Analyzing the test results7. Reporting the Defects.

New Features in 8.2 Unicode Support for Multilingual Application Testing —

Enables you to test applications that use values containing characters from almost any language, for example, Japanese, Arabic, and Hindi.

Advanced Keyword-Driven Testing —Helps you design your tests and components quickly and easily, in a self-documenting tabular user interface that requires no programming knowledge.

Auto-Documentation —Displays a summary of what each step does, in an easy-to-understand sentence. The Documentation Only option enables you to automatically hide the other columns in the Keyword View and display only the auto-documentation (for tests) or the auto-documentation and any comments (for components).

Business Process Testing —Uses the intuitive, keyword-driven Business Component Keyword View to enable Subject Matter Experts and QuickTest Engineers to work together to build business process tests and business components that evaluate real business processes.

Passing Data in Tests Using Parameters —Streamlines the passing of values into and from your tests and actions.

Passing Data in Components Using Parameters —Enables the passing of values into and from your business components.

Multiple Application Areas for Components —Enables you to create and use a different application area for each part of your application. Each application area specifies the resources and settings that can be used by a component.

Step Generator for Test Steps —Replaces the Method Wizard with a dialog box that helps you quickly and easily add methods, reserved objects, and function statements to your test.

Function Definition Generator —Enables you to quickly document and register new user-defined functions for tests and components.

Highlight Repository Object in Application —Quickly locates a selected repository object in your application. For use with tests and components.

Sample Resource Files for Use With Components —Provides you with a set of predefined resource files that you can associate with an application area or a specific component.

Open XML Report Format for Test Results —Provides results for tests or components in an open, XML format.

Active screen:- The Active screen provides a snapshot of your application, as it

appeared when you performed a certain step while recording your test. This enables you to easily parameterize object values and insert checkpoints, methods and output values for any object in the page, even if your application is not available or you do not have step in your test corresponding to the selected object .

Active screen capture level:- Complete:- Captures all properties of all objects in the active screen of each step. Saves all web pages after any dynamic changes. Partial:- Captures only properties related to the recorded object for other steps in the same parent object. Saves all web pages after any dynamic changes and saves active screen files in a compressed format Minimum:- Captures a minimal set of properties in each step. None:-Disable capturing of active screen files for all applications and web pages. Change Active Screen:- As the content of your application or website changes, you can continue to use tests you developed previously . You simply update the selected. Active screen display so that you can use the Active Screen to add new steps to your test rather than re-recording steps on new or modified objects. Note:- When recording on Win menu objects the active screen is not captured. you cannot insert an XML check point from the active screen. You cannot insert a checkpoint on a win menu object.

Data Table:

Global Sheet: This enables you to share information from one action to another action. Action Sheet: Each action has its own sheet in the data table. So that you can insert data that applies to only that action. Note: You cannot select current action sheet (Local) when parameterizing the value of an object repository if your test uses a shared object repository file.

Debug viewer pane:- The debug viewer pane contains three tabs to assist you in debugging your test. Watch Expressions, Variables and Command tabs.

Using the debug viewer:- when a test stops at a break point , you use the debug viewer pane to view , set or modify the current value of objects or variables in your test.

Watch Expressions tab: - The watch Expressions tab enables you to view the current value of any variable or other VBScript expressions.Variables tab:- The variables tab enables you to view the current value of all variables that have been recognized up to the last step performed in the test run.Command Tab:- The command tab enables you to execute a line of script in order to set or modify the current value of a variable or VB script object in your test. When you continue running the test, quick test uses the new value that was set in the command.

Choosing Recording Mode:

Normal recording Mode: By default Quick test records in the Normal recording mode. Quick test’s normal recording mode records the objects in your application and the operations performed on them.Analog recording mode: Use analog recording for applications in which the actual movement of the mouse is what you want to record. These can include drawing a mouse signature or working with drawing applications that create images by drawing mouse.a) Record relative to a specified window:- If the operations you perform on objects located with in one window and that window does not move during the analog recording session. Quick test does not record any click or mouse movement performed outside the specified window.b) Record Relative to the screen:- If the window on which you are recording your analog steps moves during recording or if the operations you perform are on objects located with in more than one window. This can include dragging and dropping of an object from window to another.Note: - a) The steps recorded using analog recoding are saved in a separate data file. This file is stored with the action in which the analog steps are recorded.b) When you record in analog recording mode, quick test adds to your test a “Run analog” statement that calls the recorded analog file.Low-Level Recording Mode: -1) Use Low-Level recording for recording on environments or objects not supported by quick test. 2) Use Low-Level recording for when you need to record the exact location of the object on your application screen. If the location of the object is important to your test switch to Low-Level recording to enable quick test to record the object in terms of its x and y coordinates on the screen. This way the step will pass only if the object is in the correct position.Each step recorded in Low-Level recording mode is shown in the test tree and test script.Note: - a). Analog recording records only the one-Step in the test tree that calls the external analog data file.b). Low-Level recording, Analog recording option is not available while editing a test.Note: - To step an analog step in the middle of a test run, click CTR+ESC, then click stop in the test toolbar.c). This mode records at the object level and records all run time objects as window or win object test objects.

Note: QuickTest does not support virtual objects for analog or low-level recording.Report:- Insert->step->report You can define a message in your test that quick test sends to your test results. Select the status that will result from this step from the status list.Passed:- Causes this step to pass. Sends the specified message to the report.Failed:- Causes this step to fail. Sends the specified message to the reportDone:- Sends a message to the report with out affecting the pass/fail status of the step.

Warning:- sends a warning status for the step but does not cause the test to stop running and does not affect the pass/fail status of the test.

Note: - A share object repository file created in QTP6.5 cannot be opened and saved in QTP 6.0. Saving the shared object repository file in QTP 6.0 will destroy the file.

Object identification: Quick test has a predefined set of properties that it learns for each test object. If these mandatory property values are not sufficient to uniquely identify an object you record, quick test can add some assistive properties and/or an ordinal identifier in order to create a unique description.

Mandatory Properties: Mandatory properties are properties that quick test always learns for a particular test object class.Assistive Properties: Assistive properties are properties that quick test learns only if the mandatory properties that quick test learns for a particular object in your application are not sufficient to create a unique description. If several assistive properties are defined for an object class, then quick test learns one assistive property at a time and steps as soon as it creates a unique description for the object. If quick test does learn assistive properties, those properties are added to the test object description.Note: If the combination all defined mandatory and assistive properties is not sufficient to create a unique test object description, quick test also records the value for the selected ordinal identifier.

When you run a test or component, quick test searches for the object that matches the description it learned (with out the ordinal identifier). If it cannot find any object that matches the description or if it finds more than one object that matches, quick test uses the smart identification mechanism (if enabled) to identify the object. In many cases, a smart identification description can help quick test to identify an object, if it is present, even when the recorded description fails due to changes in one or more property values. The test object description is used together with the ordinal identifier only in cases where the smart identification mechanism does not succeed in narrowing down the object candidates to a single object.

Ordinal Identifier: The ordinal identifier assigns the object numerical values that indicate its order relative to other objects with an otherwise identical description. (Objects that have the same values for all properties specified in the mandatory and assistive property lists).

These are 3 types of ordinal identifiers that quick test can use to identify an object.Index: Indicates the order in with the object appears in the application code relative to other objects with an otherwise identical description.

Location: Indicates the order in which the object appears with in the parent window, frame, or dialog box relative to other objects with an otherwise identical description.Creation time: (Browser object only) indicates the order in which the browser was opened relative to other open browsers with an otherwise identical description.

Smart identification: - Selecting the Enable Smart identification check box for a particular test object class instructs quick test to record the property values of all properties specified as the object’s base filter or optional filter properties in the smart identification properties dialog box. You should enable the smart identification mechanism only for test object classes with smart identification configuration defined.

Configuring smart identification: -Configuring smart identification properties helps quick test to identify objects in your application even if some of the properties in the objects recorded description have changed. If quick test is unable to find any object that matches the recorded object description or if it finds more than one object that fits the description, then quick test ignores the recorded description, and uses the smart identification mechanism to try to identify the object.

It uses two types of properties.Base filter properties: -The most fundamental properties of a particular test object class, those whose values cannot be changed with out changing the essence of the original object.Optional filter properties: - Other properties that can help identify objects of a particular class as they are unlikely to change on a regular basics but which can be ignored if they are no longer applicable.

Disable smart identification during the test run: - Instructs quick test not to use smart identification mechanism during the test run.Note:- Even if you choose to record smart identification properties for an object, you can disable use of the smart identification mechanism for a specific object in the object properties or object repository dialog box or you can disable the smart identification for an entire test run in Test ->Settings -> Run tab. Analyzing Smart identification information in the test results: - If quick test successfully uses smart identification to find an object after no object matches the recorded description the test results receive a warning status and include the following information.

In the result tree: - A smart identification for missing objectFor example: “User name”- smart identification

In the results details: - Information about the properties used to find the object, you can use this information to modify the recorded test object description, so that quick test can find the object using description future test runs.

Object repository Mode: There are two types of Object repository Modes.

Per action: Quick test creates a new object repository for each action. As you record operations on objects in your application, quick test automatically stores the information about those objects in the appropriate action object repository. You also can use the export option to save your object repository as a shared object repository file to use with other tests.

Shared object repository: This enables you to

1) Easily maintain your tests or components when an object in your application changes.

2) Manage all the objects for a suite of tests or components in one central location.

Choosing Object repository Mode:The object repository per-action mode is easiest to use when you are creating simple record and run tests, especially under the following conditions.

1) You have only one or very few tests that correspond to a given application interface or set of objects

2) You do not expect to frequently modify test object properties3) Generally create single action test.

The shared object repository mode is generally the preferred mode when1) You have several tests that test elements of the same application interface or set of

objects.2) You expect the object properties in your application to change from time to time

and/or you regularly need to update or modify test object properties.3) You often work with multi action test and regularly use the largest copy of action

and insert all to action options.

Recovery Scenarios: You can instruct quick test to recover from unexpected events and errors that occur in your testing environment during a run session. In this 4 types are there.

Pop-up window, object state, Test run error, application crash.

Pop-up window: quick test detects a pop-up window and identifies it according to the window title and textual content.Object State: Quick test detects a specific test object state and identifies it according to its property values and the property values of all its ancestors.Note that an object is identified only by its property values and not by its class.Test run error: Quick test detects a run error and identifies it by a failed return value from method.

Application crash: Quick test detects an application crash and identifies it according to a predefined list of applications.

Run Modes:

Normal (displays execution marker): - Runs your test with the execution arrow to the left of the test tree, marking each step or statement as it is performed. If the test contains multiple actions, the tree view expands to display the steps and the expert view displays the script of the currently running action. This option requires more system resources.

Fast: Runs your test with out the execution arrow to the left of the test tree and does not show the tree view or expert view of each action as it runs. This option requires fewer system resources.

Update Run: - This enables you to run through your test to update the test object descriptions, the expected checkpoint values and/or the active screen images and values. After you save the test, the results of the updated test are used for sub sequent test runs.Update options: -Update test object descriptions—QuickTest updates the test object description according to the properties currently defined in the Object Identification dialog box for each object class. You can use this option to modify the set of properties used to identify an object.Update checkpoint properties—QuickTest updates the expected checkpoint values to reflect any changes that may have occurred in your application since you recorded the test or component. For example, suppose you had defined a text checkpoint as part of your test, and the text in your application has changed since you recorded your test. You can update the test to update the checkpoint properties to reflect the new text.

E.g: - you had defined a text checkpoint as part of your test and the text in your application has changed since you recorded your test. You can update a test to update the checkpoint properties to reflect the new text.Update Active Screen images and values—QuickTest updates images and property values in the Active Screen to reflect any changes that may have occurred in your application since you recorded the test or component or if the Active Screen does not appear as it should.

E.g: -suppose a dialog box in your application has changed since you recorded your test or component. You can update the test or component to update the dialog box appearance and its properties in the Active Screen.

About Debugging Tests and ComponentsAfter you create a test or component, you should check that it runs smoothly, without errors in syntax or logic. In order to detect and isolate defects in a test or component, you can use step commands and the Pause command to control the run session. You can also do this by setting breakpoints. When the test or component stops at a breakpoint, you can use the Debug Viewer to check and modify the values of VBScript objects and variables. Also, if QuickTest displays a run-error message during a run session, you can click the Debug button on the error message to suspend the test or component and debug it.

Note: You can also use the Run from Step feature to debug your test or component. This runs your test or component from a selected step to the end.

Using the Step CommandsYou can run a single step of a test or component using the Step Into, Step Out, and Step Over commands.Tip: To display the Debug toolbar, choose View > Toolbars > Debug.

Step IntoChoose Debug > Step Into, click the Step Into button, or press F11 to run only the current line of the active test or component. If the current line of the active test or component calls another action or a function, the called action/function is displayed in the QuickTest window, and the test or component pauses at the first line of the called action/function.Step OutChoose Debug > Step Out or click the Step Out button, or press SHIFT+F11 only after using Step Into to enter a action or a user-defined function. Step Out runs to the end of the called action or user-defined function, then returns to the calling action and pauses the run session.Step OverChoose Debug > Step Over or click the Step Over button, or press F10 to run only the current step in the active test or component. When the current step calls another action or a user-defined function, the called action or function is executed in its entirety, but the called action script is not displayed in the QuickTest window.

Using the Step Commands - An ExampleFollow the instructions below to create a simple test and run it using theStep Into, Step Out, and Step Over commands.To create the sample test:1 Choose File > New to open a new test.2 Click the Expert View tab to display the Expert View.3 Enter the following lines exactly:

public Function myfunc()msgbox "one"msgbox "two"msgbox "three"End Function

myfuncmyfuncmyfunc

To run the test using the Step Into, Step Out, and Step Over commands:

1 Press F9 (Insert/Remove Breakpoint) to add a breakpoint on the seventh line of the test (the first call to the myfunc function). The Expert View breakpoint symbol is displayed in the left margin. 2 Run the test. The test pauses at the breakpoint.3 Press F11 (Step Into). The execution arrow points to the first line within thefunction (msgbox "one").4 Press F11 (Step Into) again. A message box displays the text one.

5 Click OK to close the message box. The execution arrow moves to the nextline in the function.

6 Continue pressing F11 (Step Into) until the execution arrow leaves thefunction and is pointing to the eighth line in the script (the second call tothe myfunc function).

7 Press F11 (Step Into) to enter the function again. The execution arrowpoints to the first msgbox line within the function.

8 Press SHIFT+F11 (Step Out). Three message boxes open. The execution arrowcontinues to point to the first line in the function until you close the last ofthe three message boxes. After you close the third message box, theexecution arrow points to the last line in the test.

9 Press F10 (Step Over.) The three message boxes open again. The executionarrow remains on the last line in the test.

Pausing a Run SessionYou can temporarily suspend a run session by choosing Debug > Pause orclicking the Pause button. A paused test or component stops running whenall previously interpreted steps have been run.To resume running a paused test or component, click the Run button orchoose Test > Run or Component > Run. The run continues from the point itwas suspended.

Step Generator:

Specifying a Function for the StepIf you select Functions in the Category box list, you can choose one of the following options from the Library box list:All—Enables you to select a function from all the available functions andtypes. Library functions—Enables you to select a function from any library fileassociated with your test or component. For more information aboutdefining and using associated function libraries, see “Working withAssociated Library Files” on page 882. Built-in functions—Enables you to select any standard VBScript functionsupported by QuickTest. For more information about working withVBScript, you can open the VBScript documentation from the QuickTestHelp menu (Help > QuickTest Professional Help > VBScript Reference).Local script functions—Enables you to select any local function defineddirectly in the current action or component.

You can select the required function from the Operation box list, whichdisplays the functions available for the selected function type inalphabetical order.

Using Conditional StatementsYou can control the flow of your test or component with conditional statements. Using conditional If...Then...Else statements, you can incorporate decision-making into your tests and components.

The If...Then...Else statement is used to evaluate whether a condition is true or false and, depending on the result, to specify one or more statements to run. Usually the condition is an expression that uses a comparison operator to compare one value or variable with another. The following comparison operators are available: less than <, less than or equal to <=, greater than >, greater than or equal to >=, not equal <>, and equal =.

Your If...Then...Else statement can be nested to as many levels as you need. Ithas the following syntax:If condition Then statements [Else elsestatements] End IfOr, you can use the block form syntax:If condition Then[statements][ElseIf condition-n Then[elseifstatements] . . .[Else[elsestatements]End If

Using Loop StatementsYou can control the flow of your test or component with loop statements. Using loop statements, you can run a group of steps repeatedly, either while or until a condition is True. You can also use loop statements to repeat a group of steps a specific number of times.The following loop statements are available in the Keyword View:

For...Next StatementA For...Next loop instructs QuickTest to execute one or more statements a specified number of times. It has the following syntax:For counter = start to end [Step step]statementNext

Item Descriptioncounter The variable used as a counter for the number of iterations.start The start number of the counter.end The last number of the counter.step The number to increment at the end of each loop.Default = 1.Optional.statement A statement, or series of statements, to be executed during the loop.

For...Each StatementA For...Each loop instructs QuickTest to execute one or more statements for each element in an array or an object collection. It has the following syntax:For Each item In arraystatementNextItem Descriptionitem A variable representing the element in the array.array The name of the array.statement A statement, or series of statements, to be executed during the loop.

The following example uses a For...Each loop to display each of the valuesin an array.MyArray = Array("one","two","three","four","five")For Each element In MyArraymsgbox elementNext

Do...While—Performs a series of statements indefinitely, as long as a specified condition is True.Do...Until—Performs a series of statements indefinitely, until a specified condition becomes True.

Do...Loop StatementThe Do...Loop statement instructs QuickTest to execute a statement or series of statements while a condition is true or until a condition becomes true. It has the following syntax:Do [{while} {until} condition]statementLoopcondition A condition to be fulfilled.statement A statement or series of statements to be executed duringthe loop.

While...Wend—Performs a series of statements as long as a specified condition is True.While StatementA While statement instructs QuickTest to execute a statement or series of statements while a condition is true. It has the following syntax:

While conditionstatementWend

Item Descriptioncondition A condition to be fulfilled.statement A statement or series of statements to be executed during the loop.

Adding CommentsWhile programming, you can add comments to your test or component. A comment is an explanatory remark in a program. When you run a test or component, QuickTest does not process comments. You can use comments to explain sections of your tests and components to improve readability and to make them easier to update.

Inserting CommentsA comment is a line or part of a line in a script that is preceded by an apostrophe ('). When you run a test, QuickTest does not process comments. Use comments to explain sections of a script in order to improve readability and to make tests easier to update.Measuring TransactionsYou can measure how long it takes to run a section of your test by defining transactions. A transaction represents the process in your application that you are interested in measuring. You define transactions within your test by enclosing the appropriate sections of the test with start and end transaction statements.

A transaction can be inserted anywhere in your test, but must start and end within the same action. During the test run, the Start Transaction signals the beginning of the timemeasurement. The time measurement continues until the End Transaction is encountered. The test report displays the time it took to perform the transaction. There is no limit to the number of transactions that can be added to a test. You can also insert a transaction within a transaction.

Retrieving and Setting Test Object Property ValuesTest object properties are the set of properties defined by QuickTest for each object. You can set and retrieve a test object’s property values, and you can retrieve the values of test object properties from a run-time object. When you run your test, QuickTest creates a temporary version of the test object that is stored in the test object repository. You use theGetTOProperty, GetTOProperties, and SetTOProperty methods to set and retrieve the test object property values of the test object.The GetTOProperty and GetTOProperties methods enable you to retrieve a specific property value or all the properties and values that QuickTest uses to identify an object.The SetTOProperty method enables you to modify a property value that QuickTest uses to identify an object.Note: Because QuickTest refers to the temporary version of the test object during the test run, any changes you make using the SetTOProperty method apply only during the course of the test run, and do not affect the values stored in the test object repository.For example, the following statements would set the Submit button’s name value to my button, and then retrieve the value my button to the ButtonName variable:Browser("QA Home Page").Page("QA Home Page").WebButton("Submit").SetTOProperty "Name", "my button"

ButtonName=Browser("QA Home Page").Page("QA Home Page").WebButton("Submit").GetTOProperty("Name")You use the GetROProperty method to retrieve the current value of a testobject property from a run-time object in your application.For example, you can retrieve the target value of a link during the test run as follows:link_href = Browser("Mercury Technologies").Page("Mercury Technologies").Link("Jobs").GetROProperty("href")

Running DOS CommandsYou can run standard DOS commands in your QuickTest test using the VBScript Windows Scripting Host Shell object (WSCript.shell). For example, you can open a DOS command window, change the path to C:\, andexecute the DIR command using the following statements:

Dim oShellSet oShell = CreateObject ("WSCript.shell")oShell.run "cmd /K CD C:\ & Dir"Set oShell = Nothing

Save step screen capture to test results:Note: Test->setting->Run tab Instructs quick test when to capture and save images of the application during the test run to display them in the test results.

Always: capture images of each step whether the step fails or passes.

On errors: capture images only if the step fails. If we select this no screen captures (including errors) are saved to the test results for non-web based applications.

On errors and warnings: captures images only if the step returns a failed or warning status. This is when testing standard windows applications.

Never: Never capture images.

Note: The first time quick test is started by default, the Active and web add-inns are selected. If the beginning of each subsequent quick test session your selection from the previous session is the default setting.

Apply “with “ to script:

Edit->Apply “with “ to script You can improve the readability of your test using “with” statements. You can instruct quick test to automatically generate with statements as you record. But even after your basic test is recorded, you can convert its statements, in the expert view to with statements-by selecting a menu command.Note that generating with statements for your test does not affect the tree view in any way.

Synchronization point: -To solves the anticipated timing problems between the application and the tool we can go for synchronization.For e.g.: - It might take a few seconds

For a progress bar to reach100%. For a status message to appear. For a button to become enabled For a window or pop-up message to open

Regular expressions:- Regular expressions enable quick test to identify objects and text strings with varying values. You can use Regular Expressions when

Defining the property values of an object Parameterize a step Creating checkpoints with varying values

Note:- you can use regular expressions only for values of type string.

Check Pont: A checkpoint is a verification point that compares a current value for a specified property with the expected value for that property. This enables you to identifywhether your Web site or application is functioning correctly.

You can add checkpoints during a recording session or while editing your test or component. It is generally more convenient to define checks once the initial test or component has been recorded.

Standard Checkpoint checks the property value of an object in your application or Web page. The standard checkpoint checks a variety of objects such as buttons, radio buttons, combo boxes, lists, and so forth.

For example, you can check that a radio button is activated after it is selected or you can check the value of an edit field.Image Checkpoint checks the value of an image in your application or Web page. For example, you can check that a selected image’s source file is correct.Note: You create an image checkpoint by inserting a standard checkpoint onan image object.Image checkpoints are supported for the Web environment

Bitmap Checkpoint checks an area of your Web page or application as a bitmap. For example, suppose you have a Web site that can display a map of a city the user specifies. The map has control keys for zooming. You can record the new map that is displayed after one click on the control key that zooms in the map. Using the bitmap checkpoint, you can check that the map zooms in correctly.Bitmap checkpoints are supported for all add-in environments

Table Checkpoint checks information within a table. For example, suppose your application or Web site contains a table listing all available flights from New York to San Francisco. You can add a table checkpoint to check that the time of the first flight in the table is correct.Note: You create a table checkpoint by inserting a standard checkpoint on atable object.Table checkpoints are supported for Web and ActiveX environments

Text Checkpoint checks that a text string is displayed in the appropriate place in your application or on a Web page. For example, suppose your application or Web page displays the sentence Flight departing from New York to San Francisco. You can create a text checkpoint that checks that the words “New York” are displayed between “Flight departing from” and “to San Francisco”.Text checkpoints are supported for all add-in environments

Text Area Checkpoint checks that a text string is displayed within a defined area in a Windows application, according to specified criteria. For example, suppose your Visual Basic application has a button that says View Doc<Num>, where <Num> is replaced by the four digit code entered in a form elsewhere in the application. You can create a text area checkpoint to confirm that the number displayed on the button is the same as the number entered in the form.Text area checkpoints are supported for Standard Windows, Visual Basic,and ActiveX add-in environments

Accessibility Checkpoint identifies areas of your Web site that may not conform to the World Wide Web Consortium (W3C) Web Content Accessibility Guidelines. For example, guideline 1.1 of the W3C Web Content Accessibility Guidelines requires you to provide a text equivalent for every non-text element. You can add an Alt property check to check whether objects that require the Alt property under this guideline, do in fact have this tag.Accessibility checkpoints are supported for the Web environment

Page Checkpoint checks the characteristics of a Web page. For example, you can check how long a Web page takes to load or whether a Web pagecontains broken links.Note: You create a page checkpoint by inserting a standard checkpoint on a page object.Page checkpoints are supported for the Web environment

Database Checkpoint checks the contents of a database accessed by your application. For example, you can use a database checkpoint to check the contents of a database containing flight information for your Web site.Database checkpoints are supported by all environments

XML Checkpoint checks the data content of XML documents in XML files or XML documents in Web pages and frames. For more information on XML checkpoints, see Chapter 11, “Checking XML.”XML checkpoints (Web page/frame) are supported for the Web environment; XML checkpoints (file) are supported by all environments

Supported CheckpointsThe following table shows the types of checkpoints supported for eachenvironment that is supported by default with the QuickTest Professionalinstallation.

Web Std VB ActiveXOther Object

Standard S S S S NA

Image S NS NS NS NA

Table S NS NS S NA

Text S S S S NA

Text Area NS S S S NA

Bitmap S S S S NA

Accessibility S NS NS NS NA

XML S NS NS NS S (File)

Page S NA NA

NA NA

Database NA NA NA

NA S

(DbTable)

S—SupportedNS—Not SupportedNA—Not ApplicableParameterization:QuickTest enables you to expand the scope of a basic test or component by replacing fixed values with parameters. This process, known as parameterization, greatly increases the power and flexibility of your test or component.About Parameterizing Values: You can use the parameter feature in QuickTest to enhance your test or component by parameterizing the values that it uses. A parameter is a variable that is assigned a value from an external data source or generator.You can parameterize values in steps and checkpoints in your test or component. You can also parameterize the values of action parameters.

If you wish to parameterize the same value in several steps in your test or component, you may want to consider using the Data Driver rather than adding parameters manually.

There are four types of parameters:➤ Test, action or component parameters enable you to use values passed from your test or component, or values from other actions in your test. In order to use a value within a specific action, you must pass the value down through the action hierarchy of your test to the required action. You can then use that parameter value to parameterize a step in your test or component.For example, suppose that you want to parameterize a step in Action3 using a value that is passed into your test from the external application that runs (calls) your test. You can pass the value from the test level to Action1 (a top level action) to Action3 (a child action of Action1), and then parameterize the required step using this Action input parameter value (that was passed through from the external application).➤ Data Table parameters enable you to create a data-driven test (or action) that runs several times using the data you supply. In each repetition, or iteration, QuickTest uses a different value from the Data Table. For example, suppose your application or Web site includes a feature that enables users to search for contact information from a membershipdatabase. When the user enters a member’s name, the member’s contact information is displayed, together with a button labelled View <MemName>’s Picture, where <MemName> is the name of the member.You can parameterize the name property of the button so that during each iteration of the run session, QuickTest can identify the different picture buttons.➤ Environment variable parameters enable you to use variable values from other sources during the run session. These may be values you supply, or values that QuickTest generates for you based on conditions and options you choose.For example, you can have QuickTest read all the values for filling in a Web form from an external file, or you can use one of QuickTest’s built-in environment variables to insert current information about the machine running the test or component.➤ Random number parameters enable you to insert random numbers as values in your test or component. For example, to check how your application handles small and large ticket orders, you can have QuickTest generate a random number and insert it in a number of tickets edit field.

Output Value: An output value is a step in which one or more values are captured at a specific point in your test or component and stored for the duration of the run session. The values can later be used as input at a different point in the run session.

When you create output value steps, you can determine where the values are stored during the run session and how they can be used. During the run session, QuickTest retrieves each value at the specified point and stores it in the specified location. When the value is needed later in the run session, QuickTest retrieves it from this location and uses it as required. Output values are stored only for the duration of the run session. When therun session is repeated, the output values are reset.Creating Output ValuesWhen you add an output value step to your test or component, you first select the category of values to output, for example, property values, text values, or XML element values. You can then determine which values to output and the storage location for each value.

Standard Output ValuesYou can use standard output values to output the property values of most objects. For example, in a Web-based application, the number of links on a Web page may vary based on the selections a user makes on a form on the previous page. You could create an output value in your test to store the number of links on the page. You can also use standard output values to output the contents of table cells.

Tip: You can use standard output values to output text strings by specifying the text property of the object as an output value. This is the preferred way of outputting the text displayed in many Windows applications.

Text and Text Area Output ValuesYou can use text output values to output text strings displayed in a screen or Web page. When creating a text output value, you can output a part of the object’s text. You can also specify the text before and after the output text. You can use text area output values to output text strings displayed within a defined area of a screen in a Windows application.

For example, suppose that you want to store the text of any error message that appears after a specific step in the application you are testing. Inside the If statement you check whether a window exists with a known title bar value, for example Error. If it exists, you output the text in this window (assuming that the window size is the same for all possible error messages).

Considerations for Using a Text Output Value for Windows-Based ApplicationsThe text-recognition mechanism used when you create a text or text area output value on a Windows-based application may occasionally retrieve unwanted text information (such as hidden text and shadowed text, which appears as multiple copies of the same string).Additionally, text (and text area) output values may behave differently in different run sessions depending on the operating system version you are using, service packs you have installed, other installed toolkits, the APIs used in your application, and so forth.Therefore, when possible, it is highly recommended to retrieve text from your application window by using a standard output value step to output the value of the object’s text (or similar) property. Note that the above issues do not apply when working with Web-basedapplications.

Database Output ValuesYou can use database output values to output the value of the contents of database cells, based on the results of a query (result set) that you define on a database. You can create output values from the entire contents of the result set, or from a part of it. During the run session, QuickTest retrieves the current data from the database and outputs the values according to the settings that you specified.

XML Output ValuesYou can use XML output values to output the values of XML elements and attributes in XML documents. After the run session has finished, you can view summary results of the XML output values in the Test Results window. You can also view detailed resultsby opening the XML Output Value Results window.

For example, assume that an XML document in a Web page contains a price list for new cars. You can output the price of a particular car by selecting the appropriate XML element value to output.Output Value Categories and EnvironmentsThe following table shows the categories of output values that are supportedby each environment.

Output Value Category

Web Standard Windows

VB ActiveX Other Environment

Standard S S S S NA

Page (Standard) S NA NA NA NA

Table (Standard) S NA NA S NA

Text S S S S NA

Text area NS S S S NA

Database NS NA NA NA S (DbTable)

XML S NA NA NA XML file

S—SupportedNS—Not SupportedNA—Not Applicable

Web event Recording Configuration:- Quick test creates your test by recording the events you perform on your web based application. An event is a notification that occurs in response to an operation. The web event Recording configuration offers three standard event configuration levels.Basic:- Records click events on all standard objects and mouse over events on Image maps.Medium:- Records click events on several additional HTML tag objects in addition to those recorded in the standard level.High:- Records all click, mouse over , mouse down and double click events on Standard objects with handlers or behaviors attached.

Creating an Action Template: If you want to include one or more statements in every new action in your test, you can create an action template. For example, if you always enter your name as the author of an action, you can add this comment line to your action template. An action template applies only to actions created on your computer.To create an action template:1 Create a text file containing the comments, function calls, and other statements that you want to include in your action template. The text file must be in the structure and format used in the Expert View.2 Save the text file as ActionTemplate.mst in your <QuickTest installationFolder>\dat folder. All new actions you create contain the script lines from the action template.

Note: Only the file name ActionTemplate.mst is recognized as an action

About Working with User-Defined FunctionsIf you have large segments of code that you need to use several times in one test or component or in several different tests or components, you may want to create a user-defined function in order to make your tests or components easier to design and to read.You can define these functions within an individual test or component, or you can create one or more external VBScript library files containing your functions, so that you can access them from any test or component.Note: If you define a function directly in an action, the function can be called only in that action. If you want the function to be available for the entire test, save it in a .vbs file and specify it as an associated library file in the Test > Settings > Resources tab. For more information about specifying associated library files,Working with Associated Library FilesYou can create VBScript library files containing VBScript functions, subroutines, classes, modules, and so forth, and then associate the files with your test or component. You can call any VBScript function, subroutine, and so forth, contained within any library file that is associated with your test or component.

Any text file written in standard VBScript syntax can act as a library file. Note that the functions within library files can call QuickTest reserved objects, the objects that QuickTest supplies for enhancement purposes, such as utility objects.Note: In addition to the functions available in the associated library files, you can also call a function contained in a VBScript file directly from any action or component using the ExecuteFile function. You can also insert ExecuteFile statements within an associated library file.You can specify the default library files for all new tests in the Test Settingsdialog box (Test > Settings > Resources tab).

Note: After a test is created, the list of files specified in the Test Settings dialog box is independent of the files set as default in the Test Settings dialog box. Changes to the default library files list in the Test Settings dialog box do not affect existing tests.

Executing Externally-Defined Functions from Your Test or ComponentYou can create a VBScript file and call its functions, subroutines, classes, and so forth, from an action in your test, from a component, or from an associated library file, by inserting an ExecuteFile statement in your action, component, or library file.When you run your test or component, the ExecuteFile statement executes all global code in the specified file in order to make all definitions in the file available from the global scope of the action’s, component’s, or library file’s script.

To execute an externally-defined function:Create a VBScript file using standard VBScript syntax. Store the file in any folder that you can access from the machine running your test or component.Add an ExecuteFile statement to a component, to an action in your test, or in an associated library file using the following syntax:ExecuteFile FileNamewhere FileName is the absolute or relative path of your VBScript file.Use the functions, subroutines, classes, and so forth, from the specified VBScript file as necessary in your action or component, or within other functions in an associated library file.Notes: The ExecuteFile statement utilizes the VBScript ExecuteGlobal statement.

When you run an ExecuteFile statement within an action, you can call the functions in the file only from the current action. To make the functions in a VBScript file available to your entire test, add the file name to the associated library files list in the Resources tab of the Test Settings dialog boxRegistering User-Defined Functions as Test Object MethodsYou can use the RegisterUserFunc method to add new methods to test objects or to change the behavior of an existing test object method during a run session.You use the UnregisterUserFunc statements to disable new methods or to return existing methods to their original QuickTest behavior.

To register a user-defined function as a test object method, use thefollowing syntax:RegisterUserFunc TOClass, MethodName, FunctionName

To unregister a user-defined method, use the following syntax:UnRegisterUserFunc TOClass, MethodName

Object SpyYou can view or modify the test object property values that are stored withyour test or component in the Object Properties or Object Repository dialogbox. You can view the current test object property values of any object onyour desktop using the Properties tab of the Object Spy.

You can view the syntax of the test object methods as well as the run-timemethods of any object on your desktop using the Methods tab of the ObjectSpy.

Choose Tools > Object Spy or click the Object Spy toolbar button to openthe Object Spy dialog box and display the Properties tab. Alternatively, clickthe Object Spy button from the Object Repository dialog box.

If the object on which you want to spy can only be displayed by performingan event (such as a right-click or a mouse-over to display a context menu),hold the CTRL key. The pointing hand temporarily turns into a standardarrow and you can perform the event. When the object on which you wantto spy is displayed, release the CTRL key. The arrow becomes a pointing handagain.Note: Pressing the CTRL key does not enable you to select an applicationfrom the Windows taskbar, therefore you must make sure that the windowyou want to access is not minimized.

Notes: You can use virtual objects only when recording and running a testor component. You cannot insert any type of checkpoint on a virtual object,or use the Object Spy to view its properties.