QTP - Kurzanleitung

QTP steht für QuickTEuropäische Sommerzeit Professional, ein Produkt von Hewlett Packard (HP). Mit diesem Tool können Tester nach Abschluss der Skriptentwicklung nahtlos und ohne Überwachung automatisierte Funktionstests durchführen.

HP QTP verwendet Visual Basic Scripting (VBScript)zur Automatisierung der Anwendungen. Die Scripting Engine muss nicht ausschließlich installiert werden, da sie als Teil des Windows-Betriebssystems verfügbar ist. Die aktuelle Version von VBScript ist 5.8, die als Teil von Win 7 verfügbar ist. VBScript ist KEINE objektorientierte Sprache, sondern eine objektbasierte Sprache.

Testwerkzeuge

Tools aus einem Softwaretestkontext können als ein Produkt definiert werden, das eine oder mehrere Testaktivitäten unterstützt, angefangen bei Planung, Anforderungen, Erstellung eines Builds, Testausführung, Fehlerprotokollierung und Testanalyse.

Klassifizierung von Werkzeugen

Werkzeuge können anhand mehrerer Parameter klassifiziert werden. Es beinhaltet -

• Der Zweck des Werkzeugs
• Die Aktivitäten, die im Tool unterstützt werden
• Die Art / Stufe der unterstützten Tests.
• Die Art der Lizenzierung (Open Source, Freeware, Werbung)
• Die verwendete Technologie

Arten von Werkzeugen

Sr.Nr.	Werkzeugtyp	Benutzt für	Benutzt von
1	Test Management Tool	Testverwaltung, Planung, Fehlerprotokollierung, Nachverfolgung und Analyse.	Tester
2	Konfigurationsverwaltungstool	Für die Implementierung, Ausführung und Verfolgung von Änderungen	Alle Teammitglieder
3	Statische Analysewerkzeuge	Statische Prüfung	Entwickler
4	Testdaten-Vorbereitungstools	Analyse und Design, Testdatengenerierung	Tester
5	Testausführungstools	Implementierung, Ausführung	Tester
6	Testkomparatoren	Vergleich der erwarteten und tatsächlichen Ergebnisse	Alle Teammitglieder
7	Tools zur Messung der Abdeckung	Bietet strukturelle Abdeckung	Entwickler
8	Tools für Leistungstests	Überwachung der Leistung, Reaktionszeit	Tester
9	Tools für Projektplanung und -verfolgung	Für die Planung	Projektmanager
10	Incident Management Tools	Zur Verwaltung der Tests	Tester

Wo passt QTP hin?

QTP ist ein Funktionstest-Tool, das sich am besten für Regressionstests der Anwendungen eignet. QTP ist ein lizenziertes / kommerzielles Tool von HP, eines der beliebtesten Tools auf dem Markt. Es vergleicht das tatsächliche und das erwartete Ergebnis und meldet die Ergebnisse in der Ausführungszusammenfassung.

QTP - Geschichte und Evolution

HP Quick Test Professional war ursprünglich im Besitz von Mercury Interactive und wurde von HP übernommen. Der ursprüngliche Name war Astra Quick Test und wurde später als Quick Test Professional bezeichnet. Die neueste Version ist jedoch als Unified Functional Tester (UFT) bekannt.

Versionsgeschichte

Schauen wir uns nun den Versionsverlauf von QTP an.

Versionen	Zeitleisten
Astra Quick Test v1.0 bis v5.5 - Mercury Interactive	Mai 1998 bis August 2001
QuickTest Professional v6.5 bis v9.0 - Mercury Interactive	September 2003 bis April 2006
Hp-QuickTest Professional v9.1 bis v11.0 - Von HP erworben und freigegeben	Februar 2007 bis September 2010
HP-Unified Functional Testing v11.5 bis v11.53	2012 bis November 2013

Vorteile

• Die Entwicklung automatisierter Tests mit VBScript erfordert keinen hochqualifizierten Codierer und ist im Vergleich zu anderen objektorientierten Programmiersprachen relativ einfach.

• Einfach zu bedienen, einfache Navigation, Ergebnisvalidierung und Berichterstellung.

• Leicht in das Test Management Tool (Hp-Quality Center) integriert, das eine einfache Planung und Überwachung ermöglicht.

• Kann auch zum Testen mobiler Anwendungen verwendet werden.

• Da es sich um ein HP Produkt handelt, wird der vollständige Support von HP und seinen Foren zur Behebung technischer Probleme bereitgestellt.

Nachteile

• Im Gegensatz zu Selen funktioniert QTP nur unter Windows.

• Nicht alle Versionen von Browsern werden unterstützt, und die Tester müssen warten, bis der Patch für jede der Hauptversionen veröffentlicht wird.

• Obwohl es sich um ein kommerzielles Tool handelt, sind die Lizenzkosten sehr hoch.

• Obwohl die Skriptzeit kürzer ist, ist die Ausführungszeit relativ höher, da sie die CPU und den RAM belastet.

Für jede automatisierte Tool-Implementierung sind die folgenden Phasen / Phasen aufgeführt. Jede der Stufen entspricht einer bestimmten Aktivität und jede Phase hat ein bestimmtes Ergebnis.

• Test Automation Feasibility Analysis- Der erste Schritt besteht darin, zu überprüfen, ob die Anwendung automatisiert werden kann oder nicht. Aufgrund seiner Einschränkungen können nicht alle Anwendungen automatisiert werden.

• Appropriate Tool Selection- Der nächstwichtigste Schritt ist die Auswahl der Werkzeuge. Dies hängt von der Technologie, in der die Anwendung erstellt wurde, ihren Funktionen und ihrer Verwendung ab.

• Evaluate the suitable framework- Nach Auswahl des Werkzeugs besteht die nächste Aktivität darin, ein geeignetes Framework auszuwählen. Es gibt verschiedene Arten von Frameworks und jedes Framework hat seine eigene Bedeutung. Wir werden uns später in diesem Tutorial ausführlich mit Frameworks befassen.

• Build Proof of Concept- Proof of Concept (POC) wird mit einem End-to-End-Szenario entwickelt, um zu bewerten, ob das Tool die Automatisierung der Anwendung unterstützen kann. Es wird mit einem End-to-End-Szenario durchgeführt, das sicherstellt, dass die wichtigsten Funktionen automatisiert werden können.

• Develop Automation Framework- Nach dem Aufbau des POC wird die Framework-Entwicklung durchgeführt. Dies ist ein entscheidender Schritt für den Erfolg eines Testautomatisierungsprojekts. Das Framework sollte nach sorgfältiger Analyse der von der Anwendung verwendeten Technologie und ihrer Hauptmerkmale erstellt werden.

• Develop Test Script, Execute, and Analyze- Sobald die Skriptentwicklung abgeschlossen ist, werden die Skripte ausgeführt, die Ergebnisse analysiert und etwaige Fehler protokolliert. Die Testskripte sind normalerweise versioniert.

QTP ist ein kommerzielles Tool und die Testversion kann direkt von der HP Website heruntergeladen werden. Nur die aktuelle Version, Unified Functional Testing (11.5x), steht zum Download zur Verfügung. Im Folgenden finden Sie die URL, von der die Testversion heruntergeladen werden kann.

Die Download-URL - QTP

Installationsverfahren

Step 1 - Klicken Sie auf den Link "Testversionen und Demos" und wählen Sie "HP Unified Functional Testing 11.50 CC Englisch SW E-Media Evaluation" (siehe unten).

Step 2- Nach Auswahl von "HP Unified Functional Testing 11.50" wird der Download-Assistent geöffnet. Geben Sie die persönlichen Daten ein und klicken Sie auf Weiter.

Step 3 - Lesen Sie die 'Nutzungsbedingungen' und klicken Sie auf "WEITER".

Step 4- Das Download-Fenster wird geöffnet. Klicken Sie nun auf die Schaltfläche "Herunterladen".

Step 5- Die heruntergeladene Datei hat das Format .RAR. Jetzt müssen Sie das Archiv entpacken und den Ordnerinhalt wie unten gezeigt anzeigen und die Datei Setup.exe ausführen.

Step 6 - Wählen Sie beim Ausführen der Setup-Datei zur Installation "Unified Functional Testing Setup" aus der Liste aus, wie unten gezeigt. -

Step 7 - Klicken Sie anschließend auf Weiter, um fortzufahren.

Step 8- Wählen Sie im Fenster Benutzerdefinierte Einrichtung die Plugins aus, die für Ihre Automatisierung erforderlich sind. Wählen Sie die Plugins also basierend auf der Technologie Ihrer zu testenden Anwendung aus. Wenn Ihre Anwendung beispielsweise auf .NET basiert, sollten Sie sicherstellen, dass Sie .NET auswählen.

Step 9- Nachdem Sie die erforderlichen Plugins für die Installation ausgewählt haben, klicken Sie auf Weiter. Nach Abschluss der Installation wird ein Fenster mit der Schaltfläche "Fertig stellen" angezeigt.

Step 10- Sobald Sie Ihre Installation abgeschlossen haben, wird das Dialogfeld "Zusätzliche Installationsanforderungen" geöffnet. Wählen Sie alles in der Liste außer "Lizenzinstallationsassistent ausführen" aus und klicken Sie auf "AUSFÜHREN". Wir müssen NICHT "Lizenzinstallations-Assistenten ausführen" auswählen, da wir die Testversion installieren, die standardmäßig eine Lizenz für 30 Tage gewährt.

Step 11- Nach Abschluss der zusätzlichen Installationsanforderungen wird ein Häkchen angezeigt, das wiederum anzeigt, dass die Komponenten erfolgreich installiert wurden. Klicken Sie nun auf Schließen.

Starten der UFT- und Add-Ins-Seite

Step 1 - Nach der Installation kann die Anwendung über das Startmenü gestartet werden (siehe Abbildung).

Step 2- Die Lizenzseite wird angezeigt. Sie können auf Weiter klicken, da wir die Testlizenz installiert haben.

Step 3 - Das Dialogfeld Add-Ins wird geöffnet, in dem der Benutzer die erforderlichen Add-Ins auswählen kann.

Note - Laden Sie nicht alle Add-Ins, sondern nur die erforderlichen Add-Ins und klicken Sie auf OK.

Step 4 - Nach dem Laden der erforderlichen Add-Ins wird das UFT 11.5-Tool für den Benutzer geöffnet und der erste Blick auf die UFT sieht aus, wie unten gezeigt. -

Das Aufzeichnen eines Tests entspricht dem Aufzeichnen der Benutzeraktionen der zu testenden Anwendung, sodass UFT automatisch die Skripte generiert, die wiedergegeben werden können. Aufnahme und Wiedergabe können uns einen ersten Eindruck vom Tool vermitteln, unabhängig davon, ob es die Technologie unterstützt oder nicht, wenn die anfänglichen Einstellungen korrekt vorgenommen wurden.

Die Schritte für Aufnahme und Wiedergabe sind wie folgt:

Step 1 - Klicken Sie auf der Startseite wie unten gezeigt auf "Neu". -

Step 2- Wenn Sie auf den Link "Neu" klicken, wird ein neues Testfenster geöffnet und der Benutzer muss den Testtyp auswählen. Wählen Sie "GUI-Test", geben Sie einen Namen für den Test und den Speicherort an, an dem er gespeichert werden soll.

Step 3- Sobald ein neuer Test erstellt wurde, wird der neue Testbildschirm wie unten gezeigt geöffnet. Klicken Sie nun auf die Registerkarte "Aktion1", die standardmäßig mit 1 Aktion erstellt wird.

Step 4 - Klicken Sie auf das Menü "Aufnahme" und wählen Sie "Aufnahme- und Ausführungseinstellungen" wie unten gezeigt -

Step 5- Das Dialogfeld Aufnahme- und Ausführungseinstellungen wird geöffnet. Je nach Anwendungstyp können Sie Web-, Java- oder Windows-Anwendungen auswählen. Zum Beispiel werden wir hier eine webbasierte Anwendung (http://easycalculation.com/) aufzeichnen.

Step 6- Klicken Sie auf Aufzeichnen. Der Internet Explorer wird automatisch mit der Webadresse geöffnethttps://www.easycalculation.com/gemäß den Einstellungen. Klicken Sie unter "Algebra" auf den Link "Zahlen", geben Sie eine Zahl ein und klicken Sie auf "Berechnen". Klicken Sie nach Abschluss der Aktion im Aufnahmefenster auf die Schaltfläche "Stopp". Sie werden feststellen, dass das Skript wie unten gezeigt generiert wird -

Step 7- Spielen Sie nun das Skript ab, indem Sie auf die Wiedergabetaste klicken. Das Skript wird wiederholt und das Ergebnis wird angezeigt.

Step 8 - Standardmäßig wird das Ergebnisfenster geöffnet, in dem der Zeitstempel für die Ausführung, das Bestehen und die fehlgeschlagenen Schritte genau angezeigt wird.

Bedeutung von Aufnahme und Wiedergabe

• Es wird als vorläufige Untersuchungsmethode verwendet, um zu überprüfen, ob UFT die Technologie / Anwendung unterstützen kann.

• Wird verwendet, um einen Test einer grundlegenden Funktionalität einer Anwendung oder Funktion zu erstellen, für die keine langfristige Wartung erforderlich ist.

• Es kann sowohl zum Aufzeichnen von Mausbewegungen als auch von Tastatureingaben verwendet werden.

Aufnahmemodi

• Normal Recording - Dies ist der Standardaufzeichnungsmodus, in dem die Objekte und die an der zu testenden Anwendung ausgeführten Vorgänge aufgezeichnet werden.

• Analog Recording - Hier werden nicht nur die Tastaturaktionen, sondern auch die Mausbewegungen relativ zum Bildschirm oder zum Anwendungsfenster aufgezeichnet.

• Low-Level Recording- Hier werden die genauen Koordinaten der Objekte aufgezeichnet, unabhängig davon, ob UFT das Objekt erkennt oder nicht. Es zeichnet nur die Koordinaten auf und zeichnet daher KEINE Mausbewegungen auf.

• Insight Recording - UFT zeichnet Operationen basierend auf ihrem Erscheinungsbild und nicht basierend auf seinen nativen Eigenschaften auf.

So wählen Sie Aufnahmemodi aus

Nach dem Klicken auf die Schaltfläche Aufnahme kann der Benutzer den Aufnahmemodus aus dem Aufnahmebereich auswählen, der nach dem Start der Aufnahme auf dem Bildschirm angezeigt wird. Die Auswahl kann aus einer der oben diskutierten getroffen werden.

Sie werden sehen, dass das folgende Szenario in allen Modi aufgezeichnet wurde und dieselbe Aktion unter verschiedenen Umständen aufgezeichnet wurde.

• Starten Sie IE - https://www.easycalculation.com/
• Klicken Sie unter "Algebra" auf "Zahlen".
• Klicken Sie auf den Link "Quadratwurzel"
• Geben Sie einen Wert ein, um die Quadratwurzel zu berechnen. Sagen wir 10
• Klicken Sie auf Berechnen

Das im Standard-, Analog- und Low-Level-Aufnahmemodus aufgezeichnete Skript ist unten angegeben:

' DEFAULT RECORDING MODE 
Browser("Free Online Math Calculator").Page("Free Online Math 
Calculator").Link("Numbers").Click 

Browser("Free Online Math Calculator").Page("Numbers Calculator - 
Math").Link("Square Root").Click 

Browser("Free Online Math Calculator").Page("Square Root 
Calculator").WebEdit("n").Set "10" 

Browser("Free Online Math Calculator").Page("Square Root 
Calculator").WebButton("calculate").Click 

' ANALOG RECORDING MODE 
Desktop.RunAnalog "Track1" 

' LOW LEVEL RECORDING MODE 
Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click 
235,395 

Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click 
509,391 

Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click 
780,631 

Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Type 
"10" 

Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click 
757,666

Die Aufnahmen im Insight-Aufnahmemodus sind wie folgt:

Objekt-Repository

Das Objekt-Repository ist eine Sammlung von Objekten und Eigenschaften, mit denen QTP die Objekte erkennen und darauf reagieren kann. Wenn ein Benutzer einen Test aufzeichnet, werden die Objekte und ihre Eigenschaften standardmäßig erfasst. Ohne das Verständnis der Objekte und ihrer Eigenschaften kann QTP die Skripte NICHT wiedergeben.

Klicken Sie auf eines der folgenden Themen, um mehr über das Objekt-Repository und die zugehörigen Funktionen zu erfahren.

Sr.Nr.	Themenbeschreibung
1	Object Spy und seine Funktionen Um die Verwendung von Objektspion und die damit verbundenen Funktionen zu verstehen.
2	Arbeiten mit dem Objekt-Repository Hinzufügen, Bearbeiten und Löschen von Objekten aus einem Objekt-Repository und den zugehörigen Funktionen.
3	Arten von Objekt-Repository Beschäftigt sich mit gemeinsam genutzten Objekten und lokalen Objekt-Repositorys und deren Kontext in Bezug auf Skripte.
4	Benutzerdefinierte Objekte Befasst sich mit den Umständen zur Verwendung der benutzerdefinierten Objekte.
5	Objekt-Repository in XML Beschäftigt sich mit der Konvertierung von ORs in XML und der Verwendung des Objekt-Repositorys als XML.
6	Vergleichen und Zusammenführen von OR Vorgänge wie OR vergleichen, ORs zusammenführen, um effektiv mit dem Objekt-Repository zu arbeiten.
7	Ordnungszahlen Umstände, unter denen die Ordnungszahlen verwendet werden, und ihre Vorteile.
8	Untergeordnete Objekte Verwenden von untergeordneten Objekten für effektives Scripting

Mit Aktionen können Tester Skripte in Gruppen von QTP-Anweisungen unterteilen. Aktionen ähneln Funktionen in VBScript. Es gibt jedoch einige Unterschiede. Standardmäßig erstellt QTP einen Test mit einer Aktion.

Aktionen	Funktionen
Aktion ist eine integrierte Funktion von QTP.	VBScript-Funktionen werden sowohl von VBScript als auch von QTP unterstützt.
Aktionsparameter werden nur als Wert übergeben.	Funktionsparameter werden entweder als Wert oder als Referenz übergeben.
Aktionen haben die Erweiterung .mts	Funktionen werden als .vbs oder .qfl gespeichert
Aktionen können wiederverwendbar sein oder nicht.	Funktionen sind immer wiederverwendbar.

Sie können auf die Eigenschaften der Aktion zugreifen, indem Sie mit der rechten Maustaste auf das Skripteditorfenster klicken und "Eigenschaften" auswählen.

Aktionseigenschaften enthalten die folgenden Informationen:

• Aktionsname
• Location
• Wiederverwendbare Flagge
• Eingabeparameter
• Ausgabeparameter

Arten von Aktionen

Es gibt drei Arten von Aktionen:

• Non-reusable action - Eine Aktion, die nur in dem spezifischen Test aufgerufen werden kann, in dem sie entworfen wurde, und der nur einmal aufgerufen werden kann.

• Reusable action - Eine Aktion, die mehrfach aufgerufen werden kann, jeder Test, in dem sie sich befindet, und auch von anderen Tests verwendet werden kann.

• External Reusable action- Es handelt sich um eine wiederverwendbare Aktion, die in einem anderen Test gespeichert wurde. Externe Aktionen sind im aufrufenden Test schreibgeschützt, können jedoch lokal mit der bearbeitbaren Kopie der Datentabelleninformationen für die externe Aktion verwendet werden.

Arbeiten mit Aktionen

Es gibt drei Möglichkeiten, eine Aktion einzufügen. Klicken Sie auf jede dieser Aktionen, um mehr über die ausgewählte Art der Aktion zu erfahren.

Sr.Nr.	Aktionstyp und Beschreibung
1	Aufruf zur neuen Aktion einfügen Fügt eine neue Aktion aus der vorhandenen Aktion ein
2	Aufruf zur Kopie der Aktion einfügen Fügt eine Kopie einer vorhandenen Aktion ein
3	Aufruf zur vorhandenen Aktion einfügen Fügt einen Aufruf einer vorhandenen wiederverwendbaren Aktion ein

Eine DataTable, ähnlich wie Microsoft Excel, hilft den Testern beim Erstellen datengesteuerter Testfälle, mit denen eine Aktion mehrmals ausgeführt werden kann. Es gibt zwei Arten von Datentabellen:

• Local DataTable - Jede Aktion verfügt über eine eigene private Datentabelle, die auch als lokale Datentabelle bezeichnet wird und auf die auch über mehrere Aktionen hinweg zugegriffen werden kann.

• Global DataTable - Jeder Test verfügt über ein globales Datenblatt, auf das über alle Aktionen hinweg zugegriffen werden kann.

Auf das Datenblatt kann über die Registerkarte "Daten" von QTP zugegriffen werden, wie unten gezeigt -

Um einen Testfall für eine bestimmte Anzahl von Iterationen auszuführen, können Sie die Iterationen globaler Daten im Dialogfeld "Testeinstellungen" festlegen, auf die Sie über Datei → Einstellungen → Ausführen (Registerkarte) zugreifen können (siehe unten).

Beispiel

Zum Beispiel, wenn ein Benutzer "Zinseszins" von parametrisieren möchte http://easycalculation.com/ darauf kann mit zugegriffen werden http://easycalculation.com/compound-interest.php. Die Parameter können wie unten gezeigt erstellt werden. Die meisten Funktionen von Excel können auch in der Datentabelle verwendet werden.

DataTable Operations

There are three types of objects to access DataTable. DataTable operations can be well understood by traversing through the following −

Sr.No.	Object Type & Description
1	Data Table Methods Gives detailed information about the data table methods.
2	DTParameter Object Methods Gives detailed information about the DTParameter methods.
3	DTSheet Object Methods Gives detailed information about the DTSheet methods.

Checkpoints, as the name says it all, refer to a validation point that compares the current value of specified properties or current state of an object with the expected value, which can be inserted at any point of time in the script.

Types of Checkpoints

Sr.No.	Type & Description
1	Standard Checkpoint Verifies the property values of an object in application under test and supported by all add-in environments.
2	Bitmap Checkpoint Verifies an area of your application as a bitmap
3	File Content Checkpoint Verifies the text in a dynamically generated or accessed file such as .txt,.pdf
4	Table Checkpoint Verifies the information within a table. Not all environments are supported.
5	Text Checkpoint Verify if the text that is displayed within a defined area in a Windows-based application, according to specified criteria.
6	Text Area Checkpoint Verifies if the text string is displayed within a defined area in a Windows-based application, according to specified criteria.
7	Accessibility Checkpoint Verifies the page and reports the areas of the Web site that may not conform to the World Wide Web Consortium (W3C) Web Content Accessibility Guidelines
8	Page Checkpoint Verifies the characteristics of a Web page. It can also check for broken links.
9	Database Checkpoint Verifies the contents of a database accessed by the application under test.
10	XML Checkpoint Verifies the content of the .xml documents or .xml documents in Web pages and frames.

Inserting CheckPoint

When the user wants to insert a checkpoint, one has to ensure that most of the checkpoints are supported during the recording sessions only. Once the user stops recording, checkpoints are not enabled.

Given below is the checkpoint menu, when the user is NOT in the recording mode.

Given below is the checkpoint menu, when the user is in the recording mode.

Example

The checkpoints are added for the application under test - "http://easycalculation.com/"

' 1. Inserted Standard Checkpoint
Status = Browser("Math Calculator").Page("Math 
   Calculator").Link("Numbers").Check CheckPoint("Numbers")

If Status Then
   print "Checkpoint Passed"
Else
   Print "Checkpoint Failed"
End if

' 2. Inserted BitMap Checkpoint
imgchkpoint = Browser("Math Calculator").Page("Math 
   Calculator").Image("French").Check CheckPoint("French")

If imgchkpoint Then
   print "Checkpoint Passed"
Else
   Print "Checkpoint Failed"
End if

Viewing Checkpoint Properties

After inserting, in case a tester want to change the values, we can do so by right clicking on the keyword 'checkpoint' of the script and navigating to "Checkpoint Properties" as shown below −

You can locate the same checkpoints in object repository, as well, as shown below. It exactly shows what type of checkpoint is used and what are the expected values, and time out values.

Synchronization point is the time interface between Tool and Application under test. Synchronization point is a feature to specify the delay time between two steps of the test script.

For example, clicking on a link may load the page is 1 second, sometimes 5 seconds or even it may take 10 seconds to load it completely. It depends on various factors such as the application-server response time, network bandwidth, and client system capabilities.

If the time is varying then the script will fail, unless the tester handles these time differences intelligently.

Ways to Insert Sync Point

• WaitProperty
• Exist
• Wait
• Sync(only for web based apps)
• Inserting QTP Inbuilt Synchronization points.

Let us say, we need to insert a sync point between clicking on "numbers" link and clicking on "simple Interest" calculator in "www.easycalculation.com". We will now take a look at all the five ways to insert sync point for the above scenario.

Method 1 − WaitProperty

WaitProperty is a method that takes the property name, Value and Timeout value as input to perform the sync. It is a dynamic wait and hence, this option is encouraged.

' Method 1 - WaitProperty with 25 seconds
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click

obj.Link("Simple Interest").WaitProperty "text", "Simple Interest",25000
obj.Link("Simple Interest").Click

Method 2 − Exist

Exist is a method that takes the Timeout value as input to perform the sync. Again, it is a dynamic wait and hence this option is encouraged.

' Method 2 : Exist Timeout - 30 Seconds
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click

If obj.Link("Simple Interest").Exist(30) Then
   obj.Link("Simple Interest").Click

Else
   Print "Link NOT Available"
End IF

Method 3 − Wait

Wait is a hardcoded sync point, which waits independent of the event happened or NOT. Hence, usage of Wait is discouraged and can be used for shorter wait time such as 1 or 2 seconds.

' Method 3 : Wait Timeout - 30 Seconds
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click
wait(30)
Browser("Math Calculator").Page("Math Calculator").Link("Simple Interest").Click

Method 4 − Sync Method

Sync Method can be used only for web applications where there is always a lag between page loads.

' Method 4 : 
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click

Browser("Math Calculator").Sync
Browser("Math Calculator").Page("Math Calculator").Link("Simple Interest").Click

Method 5 − Inserting QTP Inbuilt Synchronization points

Step 1 − Get into Recording Mode. This option would be disabled if the user is NOT in Recording Mode.

Step 2 − Go to "Design" → "Synchronization Point".

Step 3 − We need to select the object, which we want to be the Sync Point. After selecting the object, object window opens as shown below −

Step 4 − Click OK; the "Add Synchronization Window" opens. Select the Property, Value and Time out value and click OK as shown below −

Step 5 − The script would be generated as shown below, which is the same as that of the WaitProperty(Method 1) that we had already discussed −

Browser("Math Calculator").Page("Math Calculator").Link("Numbers").Click

Browser("Math Calculator").Page("Math Calculator").Link("Simple 
   Interest").WaitProperty "text", "Simple Interest", 10000

Default Synchronization

When the user has not used any of the above sync methods, still QTP has an in-built Object synchronization timeout which can be adjusted by the user.

Navigate to "File" >> "Settings" >> Run Tab >> Object Synchronization Time out as shown below.

Sometimes, QTP is unable to find any object that matches the recognized object description or it may find more than one object that fits the description, then QTP ignores the recognized description and uses the Smart Identification mechanism to recognize the object.

QTP's Smart Identification uses two types of properties −

• Base Filter Properties − The basic properties of a particular test object class whose values cannot be changed without changing the essence of the original object.

• Optional Filter Properties − Other properties also assist in identifying the objects of a particular class whose properties are unlikely to change often but can be ignored if they are no longer applicable.

Enabling Smart Identification for an Object

Step 1 − Navigate to "Tools" → "Object Identification". Object Identification dialog opens.

Step 2 − Choose the Environment, Object Class and Turn ON "Enable Smart Identification" as shown below −

Step 3 − Click Configure and choose the base and Optional Filter Properties.

Step 4 − Add Properties in Base Properties apart from the default one and also add/remove Optional Filter Properties. Please note that same properties cannot be a part of both Mandatory and Assistive Properties and click "OK".

Step 5 − Verify if the Smart Identification is enabled after adding object of that type in the Object Repository. Smart Identification is set to TRUE. We can also make it False in case we do not want to enable Smart Identification.

Step 6 − We can even disable a test Level by applying at test script level under "Settings" of "File" Menu as shown below −

Step 7 − If the Smart Identification is disabled as per Step# 6 then it will not apply smart identification for any object during the script execution.

Step 8 − In case the objects are added with Smart Identification as Off, QTP will not use Smart Identification for recognizing in future, even though we have enabled it later.

Debugging, in automation testing context, is a systematic process of spotting and fixing the coding issues in the automation script so that the script will be more robust and can spot the defects in the application.

There are various ways to perform debugging using break points in QTP. Break points can be inserted just by pressing "F9" or by using the Menu option "Run" → "Inserting/Removing Break Point".

After Inserting the Break point, the "Red Colored" Dot and the line will be highlighted in RED as shown below −

Method	ShortCut	Description
Step Into	F11	Used to execute each and every Step. Steps into the Function/Action and executes line by line. It pauses on each line after execution.
Step Over	F10	Used to Step over the Function. Step Over runs only the current step in the active document.
Step Out	Shift+F11	After Step Into the function, you can use the Step Out command. Step Out continues the run to the end of the function and then pauses the run session at the next line.

Options in Break Point

Various Options in Break Point can be accessed by Navigating through the 'Run' Menu.

Sr.No.	ShortCut & Description
1	F9 Insert/Remove BreakPoint
2	Ctrl+F9 Enable/Disable BreakPoint
3	Ctrl+Shift+F9 Clear All BreakPoint
4	Use Only Menu Enable/Disable All BreakPoints

Debugging Pane

The following are the panes in the debugging window −

• Output − This Tab displays all the Output of the Print Statements.

• Watch − This Tab displays the Boolean output of the Given Expression.

• LocalVariables − This Tab displays the Output of the Local Variables.

Example

The Watch Pane shows the output expression as shown below −

The Local Variables Pane shows the values held by the local variables as shown below −

There are various ways of handling errors in QTP. There are three possible types of errors, one would encounter, while working with QTP. They are −

• Syntax Errors
• Logical Errors
• Run Time Errors

Error Types

Syntax Errors

Syntax errors are the typos or a piece of the code that does not confirm with the VBscripting language grammar. Syntax errors occur at the time of compilation of code and cannot be executed until the errors are fixed.

To verify the syntax, use the keyboard shortcut Ctrl+F7 and the result is displayed as shown below. If the window is not displayed one can navigate to "View" → "Errors".

Logical Errors

If the script is syntactically correct but it produces unexpected results, then it is known as a Logical error. Logical error usually does not interrupt the execution but produces incorrect results. Logical errors could occur due to variety of reasons, viz- wrong assumptions or misunderstandings of the requirement and sometimes incorrect program logics (using do-while instead of do-Until) or Infinite Loops.

One of the ways to detect a logical error is to perform peer reviews and also verify the QTP output file/result file to ensure that the tool has performed the way it was supposed to do.

RunTime Errors

As the name states, this kind of error happens during Run Time. The reason for such kind of errors is that the script trying to perform something is unable to do so and the script usually stops, as it is unable to continue with the execution. Classic examples for Run Time Errors are −

• File NOT found but the script trying to read the file
• Object NOT found but the script is trying to act on that particular object
• Dividing a number by Zero
• Array Index out of bounds while accessing array elements

Handling Run-Time Errors

There are various ways to handle errors in the code.

1. Using Test Settings − Error handling can be defined the Test Settings by Navigating to "File" >> "Settings" >> "Run" Tab as shown below. We can select any of the specified settings and click "OK".

2. Using On Error Statement − The ‘On Error’ statement is used to notify the VBScript engine of intentions to handle the run-time errors by a tester, rather than allowing the VBScript engine to display error messages that are not user-friendly.

• On Error Resume Next − On Error Resume Next informs the VBScript engine to process executing the next line of code when an error is encountered.

• On error Goto 0 − This helps the testers to turn off the error handling.

3. Using Err Object − Error object is an in-built object within VBScript that captures the run-time error number and error description with which we are able to debug the code easily.

• Err.Number − The Number property returns or sets a numeric value specifying an error. If Err.Number value is 0 then No error has occurred.

• Err.Description − The Description property returns or sets a brief description about an error.

• Err.Clear − The Clear method resets the Err object and clears all the previous values associated with it.

Example

'Call  the function to Add two Numbers Call Addition(num1,num2) 

Function Addition(a,b)  
   On error resume next  
      If NOT IsNumeric(a) or IsNumeric(b) Then 
         Print "Error number is  " &  err.number & " and description is : 
            " &  err.description 
         Err.Clear 
         Exit Function 
      End If 
   Addition = a+b 

   'disables error handling  
   On Error Goto 0 
End function

4. Using Exit Statement − Exit Statements can be used along with Err object to exit from a test or action or iteration based on the Err.Number value. Let us see each one of those Exit statements in detail.

• ExitTest − Exits from the entire QTP test, no matter what the run-time iteration settings are.

• ExitAction − Exits the current action.

• ExitActionIteration − Exits the current iteration of the action.

• ExitTestIteration − Exits the current iteration of the QTP test and proceeds to the next iteration.

5. Recovery Scenarios − Upon encountering an error, recovery scenarios are triggered based on certain conditions and it is dealt in detail in a separate chapter.

6. Reporter Object − Reporter Object helps us to report an event to the run results. It helps us to identify if the concerned action/step is pass/fail.

'Syntax: Reporter.ReportEventEventStatus, ReportStepName, Details, 
[ImageFilePath] 

'Example 
Reporter.ReportEvent micFail, "Login", "User is unable to Login."

Recovery Scenarios

While executing the QTP scripts, we might get some unexpected errors. In order to recover the tests and continue executing the rest of the script from these unexpected errors, Recovery Scenarios are used. The Recovery Scenario Manager can be accessed by Navigating to "Resources" → Recovery Scenario Manager as shown below −

Steps to Create Recovery Scenario

Step 1 − Click "New" Recovery Scenario button; the Recovery Scenario Wizard opens as shown below −

Step 2 − Choose the Trigger Event. It corresponds to event, which can arise in any of the following four events −

• Pop-Up Window
• Object State
• Test Run Error
• Application Crash

Step 3 − The Recovery Operations Window opens. Recovery Operation can perform any of the following Operation as shown in the screenshot below −

Step 4 − After specifying the appropriate Recovery Operation, we need to specify the Post Recovery Operation as well, as shown below −

Step 5 − After specifying the Post Recovery Operation, the recovery scenario should be named and added to the Test so that it can be activated.

Step 6 − The Recovery Scenario creation is complete and needs to be mapped to the current Test by checking the option "Add Scenario to the current Test" and click "Finish".

Step 7 − The Added Recovery Scenario will be as shown below and click the "Close" Button to continue.

Step 8 − After clicking the Close button, QTP would prompt the user to save the created Recovery scenario. It will be saved with the extension .qrs and the wizard would close.

Verification

The Created Recovery Scenario should be a part of the test now and can be verified by navigating to "File" → "Settings" → "Recovery" Tab.

QTP environment variables are special types of variables that can be accessed by all actions, function libraries, and recovery scenarios. There are in-built environment variables for Windows that are available to all the applications running on that particular system, but QTP environment variables are only available to that particular test script during run-time.

Types of Environment Variables

Built-in Environment Variables − provides a range of environment parameters that can provide information such as test name, action name, the test path, local host name, the operating system name, type and its version. The Environment Variable names can be accessed by navigating to "File" → "Test Settings" → "Environment" Tab.

User defined Internal − User defined variables can be saved by selecting "User Defined" in the Environment Tab Window. The "+" button is clicked to enter Parameter Name and Value as shown below −

User Defined External − User Defined Variables can be stored in an external file as a .xml file and can be loaded into the test as shown in the figure given below. It can also be loaded dynamically during run-time as explained below in one of the examples.

Environment Variables – Supported Methods

1. ExternalFileName Property − Returns the name of the loaded external environment variable file specified in the Environment tab of the Test Settings dialog box. If no external environment variable file is loaded, this property returns an empty string.

x = Environment.ExternalFileName 
print x

2. LoadFromFile Method − Loads the specified environment variable file (.xml) dynamically during run time. When using this method, the environment variables need not be added manually into the Environment Tab.

Environment.LoadFromFile "D:\config.xml"
b = Environment.Value("Browser")
print b

3. Value Property − Retrieves the value of environment variables. We can also set the value of user-defined internal environment variables using this property.

' Get the Value of the InBuilt Environment Variables
a = Environment.Value("OS")
print a
b = Environment.Value("ActionName")
print b
  
'Loaded from External File
Environment.LoadFromFile "D:\config.xml"
c = Environment.Value("Browser")
print c

In order to modularize the script, library files are added to the QTP Script. It contains variable declaration, Functions, Classes etc. They enable reusability that can be shared across test scripts. They are saved with an extenstion .vbs or .qfl

A new Library file can be created by navigating to "File" >> "Function Library".

Associating Function Libraries

Method 1 − By using "File" > "Settings" > Resources > Associate Function Library option. Click the "+" button to add Function Library file and add it using the actual path or relative path as shown below −

Method 2 − Using ExecuteFile method.

'Syntax : ExecuteFile(Filepath)
ExecuteFile "C:\lib1.vbs" 
ExecuteFile "C:\lib2.vbs"

Method 3 − Using LoadFunctionLibrary Method.

'Syntax : LoadFunctionLibrary(Filepath)
LoadFunctionLibrary "C:\lib1.vbs" 
LoadFunctionLibrary "C:\lib2.vbs"

Method 4 − Automation Object Model(AOM) - It is a mechanism, using which, we can control various QTP operations outside QTP. Using AOM, we can launch QTP, Open the Test, Associate Function Libraries etc. The following VbScript should be saved with Extension .vbs and upon executing the same, QTP will be launched and test would start executing. AOM will be discussed in detail in the later chapters.

'Launch QTP
Set objQTP = CreateObject("QuickTest.Application")
objQTP.Launch
objQTP.Visible = True
  
'Open the test
objQTP.Open "D:\GUITest2", False, False
Set objLib = objQTP.Test.Settings.Resources.Libraries
  
'Associate Function Library if NOT associated already.
If objLib.Find("C:\lib1.vbs") = -1 Then 
  objLib.Add "C:\lib1.vbs", 1 
End

Test Results

The Test Results Window gives us sufficient information to show the steps passed, failed etc. Results window opens automatically after the execution of the test (as per default settings). The following information is displayed −

• Steps Passed
• Steps Failed
• Environment Parameters
• Graphical Statistics

Operations performed in Test Results

Converting Results to HTML

In the Results Viewer window, navigate to "File" → "Export to File". Export Run Results dialog box opens as shown below −

We can choose what type of report is to be exported. It can be short results, detailed results or even, we can select nodes. After selecting the File Name and exporting it, the file is saved as .HTML File

Filtering the Results

Results can be filtered based on Status, Node Type, and Iterations. It can be accessed by using the Filter button in the "Test Results Window".

Raising Defects

Defects can be logged into QC directly from the Test Results Window pane by accessing "Tools" → "Add Defect" which open's the connection to ALM as shown below −

Test Results

The Automatic Test Results Window can be configured under "Tools" → "Options" → "Run Sessions" Tab. We can turn it OFF, if required, and also, we can switch ON "Automatically Export Results when session Ends".

The screenshot or the movie can be recorded based on the settings. The same can be configured under "Tools" → "Options" → "Screen Capture" Tab. We can save the screenshot or movies based on the following three conditions −

• For Errors
• Always
• For Errors and Warnings

There are various GUI objects, with which QTP interacts, during the script execution. Hence, it is important to know the basic methods for the key GUI objects using which we will be able to work on it effectively.

Working with Text Box

Following are the methods using which we access text box during Run Time −

• Set − Helps the tester to Set Values into the Text Box

• Click − Clicks on the Text Box

• SetSecure − Used to set the text in the password boxes securely

• WaitProperty − Waits Till the Property value becomes true

• Exist − Checks for the existence of the Text Box

• GetROProperty("text") − Gets the Value of the Text Box

• GetROProperty("Visible") − Returns a Boolean value if visible

Example

Browser("Math Calculator").Sync
Set Obj = Browser("Math Calculator").Page("SQR Calc").WebEdit("n")

'Clicks on the Text Box
Obj.Click

'Verify if the Object Exist - Returns Boolean value
a = obj.Exist
print a

'Set the value
obj.Set "10000" : wait(2)

'Get the Runtime Object Property - Value of the Text Box
val = obj.GetROProperty("value")
print val

'Get the Run Time Object Property - Visiblility - Returns Boolean Value
x = Obj.GetROProperty("visible")
print x

Arbeiten mit Kontrollkästchen

Im Folgenden sind einige der wichtigsten Methoden aufgeführt, mit denen mit Checkbox gearbeitet werden kann:

• Set - Hilft dem Tester, den Kontrollkästchenwert auf "EIN" oder "AUS" zu setzen.

• Click- Klicken Sie auf das Kontrollkästchen. Auch prüft EIN oder AUS, aber der Benutzer ist sich über den Status nicht sicher

• WaitProperty - Wartet, bis der Eigenschaftswert wahr wird

• Exist - Überprüft, ob das Kontrollkästchen vorhanden ist

• GetROProperty("name") - Ruft den Namen des Kontrollkästchens ab

• GetROProperty("Visible") - Gibt einen Booleschen Wert zurück, falls sichtbar

Beispiel

'To Check the Check Box
Set Obj = Browser("Calculator").Page("Gmail").WebCheckBox("PersistentCookie")
Obj.Set "ON"

'To UnCheck the Check Box
Obj.Set "OFF"

'Verifies the Existance of the Check box and returns Boolean Value
val = Obj.Exist
print val

'Fetches the Name of the CheckBox
a = Obj.GetROProperty("name")
print a

'Verifies the visible property and returns the boolean value.
x = Obj.GetROProperty("visible")
print x

Arbeiten mit Optionsfeld

Im Folgenden sind einige der wichtigsten Methoden aufgeführt, mit denen mit Radio Button gearbeitet werden kann:

• Select(RadioButtonName) - Hilft dem Tester, die Radio Box auf "ON" zu stellen.

• Click- Klicken Sie auf das Optionsfeld. Sogar das Optionsfeld EIN oder AUS, aber der Tester kann den Status nicht erhalten

• WaitProperty - Wartet, bis der Eigenschaftswert wahr wird

• Exist - Überprüft, ob das Optionsfeld vorhanden ist

• GetROProperty("name") - Ruft den Namen des Optionsfelds ab

• GetROProperty("Visible") - Gibt einen Booleschen Wert zurück, falls sichtbar

Beispiel

'Select the Radio Button by name "YES"
Set Obj = Browser("Calculator").Page("Forms").WebRadioGroup("group1")
Obj.Select("Yes")

'Verifies the Existance of the Radio Button and returns Boolean Value
val = Obj.Exist
print val

'Returns the Outerhtml of the Radio Button
txt = Obj.GetROProperty("outerhtml")
print text

'Returns the boolean value if Radio button is Visible.
vis = Obj.GetROProperty("visible")
print vis

Arbeiten mit Combo Box

Im Folgenden sind einige der wichtigsten Methoden aufgeführt, mit denen mit Combo Box gearbeitet werden kann:

• Select(Value) - Hilft dem Tester, den Wert aus der ComboBox auszuwählen

• Click - Klickt auf das Objekt

• WaitProperty - Wartet, bis der Eigenschaftswert wahr wird

• Exist - Überprüft, ob das Kombinationsfeld vorhanden ist

• GetROProperty("Text") - Ruft den ausgewählten Wert des Kombinationsfelds ab

• GetROProperty("all items") - Gibt alle Elemente im Kombinationsfeld zurück

• GetROProperty("items count") - Gibt die Anzahl der Elemente im Kombinationsfeld zurück

Beispiel

'Get the List of all the Items from the ComboBox
Set ObjList = Browser("Math Calculator").Page("Statistics").WebList("class")
x = ObjList.GetROProperty("all items")
print x

'Get the Number of Items from the Combo Box
y = ObjList.GetROProperty("items count")
print y

'Get the text value of the Selected Item
z = ObjList.GetROProperty("text")
print z

Arbeiten mit Knöpfen

Im Folgenden sind einige der wichtigsten Methoden aufgeführt, mit denen mit Schaltflächen gearbeitet werden kann:

• Click - Klickt auf den Button

• WaitProperty - Wartet, bis der Eigenschaftswert wahr wird

• Exist - Überprüft die Existenz des Buttons

• GetROProperty("Name") - Ruft den Namen der Schaltfläche ab

• GetROProperty("Disabled") - Gibt einen booleschen Wert zurück, wenn aktiviert / deaktiviert

Beispiel

'To Perform a Click on the Button
Set obj_Button = Browser("Math Calculator").Page("SQR").WebButton("Calc")
obj_Button.Click

'To Perform a Middle Click on the Button
obj_Button.MiddleClick

'To check if the button is enabled or disabled.Returns Boolean Value
x = obj_Button.GetROProperty("disabled")
print x

'To fetch the Name of the Button
y = obj_Button.GetROProperty("name")
print y

Arbeiten mit webTables

In der heutigen webbasierten Anwendung sind webTables weit verbreitet, und Tester müssen verstehen, wie WebTables funktionieren und wie eine Aktion für webTables ausgeführt wird. Dieses Thema hilft Ihnen dabei, effektiv mit den webTables zu arbeiten.

Sr.Nr.	Aussage & Beschreibung
1	if statement Ein if Anweisung besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
2	if...else statement Ein if elseAnweisung besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen. Wenn die Bedingung wahr ist. Die Aussagen unterifAnweisungen werden ausgeführt. Wenn die Bedingung falsch ist.Else Ein Teil des Skripts wird ausgeführt
3	if..elseif...else statement Eine if-Anweisung, gefolgt von einer oder mehreren Elseif Anweisungen, die aus booleschen Ausdrücken bestehen, gefolgt von einem optionalen else statement, wird ausgeführt, wenn alle Bedingungen falsch sind.
4	nested if statements Ein wenn oder elseif Aussage in einem anderen if oder elseif Aussage (n).
5	switch statement EIN switch Mit der Anweisung kann eine Variable auf eine Liste von Werten getestet werden.

• html id - Wenn die Tabelle ein ID-Tag hat, ist es am besten, diese Eigenschaft zu verwenden.

• innerText - Überschrift der Tabelle.

• sourceIndex - Ruft den Quellindex der Tabelle ab

• ChildItemCount - Ruft die Anzahl der in der angegebenen Zeile vorhandenen ChildItems ab

• RowCount - Ruft die Anzahl der Zeilen in der Tabelle ab

• ColumnCount - Ruft die Anzahl der Spalten in der Tabelle ab

• GetcellData - Ruft den Wert der Zelle basierend auf der Spalte und dem Zeilenindex ab

Beispiel

Browser("Tutorials Point").Sync
' WebTable 
Obj = Browser("Tutorials Point").Page("VBScript Decisions").WebTable("Statement")
' Fetch RowCount
x = Obj.RowCount
print x

' Fetch ColumnCount
y = Obj.ColumnCount(1)
print y

' Print the Cell Data of the Table
For i = 1 To x Step 1
   
   For j = 1 To y Step 1
      z = Obj.GetCellData(i,j)
      print "Row ID : " & i & " Column ID : " & j & " Value : " & z
   Next
Next

'Fetch the Child Item count of Type Link in a particular Cell
z = Obj.ChildItemCount(2,1,"Link")
print z

Was sind virtuelle Objekte?

Manchmal enthält eine zu testende Anwendung ein Standardfensterobjekt, wird jedoch von QTP nicht erkannt. Unter diesen Umständen können Objekte als virtuelle Objekte (VO) vom Typ Schaltfläche, Verknüpfung usw. definiert werden, sodass Benutzeraktionen während der Ausführung auf den virtuellen Objekten simuliert werden können.

Beispiel

Angenommen, wir automatisieren ein Szenario in Microsoft Word. Ich habe die MS Word-Anwendung aktiviert und klicke auf ein Symbol im Menüband. Auf der Multifunktionsleiste wird beispielsweise auf die Registerkarte Einfügen geklickt, und der Benutzer klickt dann auf die Schaltfläche "Bild". Eine Schaltfläche wird als WinObject erkannt. Daher ist die Bedeutung virtueller Objekte ausgeprägt.

Window("Microsoft Word").WinObject("Ribbon").Click 145,45
Window("Microsoft Word").WinObject("Ribbon").WinObject("Picture...").Click 
170,104

Erstellen eines virtuellen Objekts

Step 1 - In solchen Szenarien werden virtuelle Objekte mit dem Virtual Object Manager oder New Virtual Object unter "Tools" >> "Virtual Object" >> "New Virtual Object" erstellt und auf die Schaltfläche "Next" geklickt.

Step 2 - Ordnen Sie das Objekt dem Klassentyp zu und klicken Sie auf "Weiter".

Step 3- Klicken Sie auf die Schaltfläche "Objekt markieren". Ein Fadenkreuz-Cursor erscheint und markiert das Objekt, das Sie zuordnen möchten, und klickt auf "Weiter".

Step 4 - Wählen Sie das übergeordnete Objekt des virtuellen Objekts aus und klicken Sie auf "Weiter".

Step 5 - Benennen Sie die Sammlung, in der Sie das virtuelle Objekt speichern möchten, und klicken Sie auf "Fertig stellen".

Virtual Object Manager

Der Virtual Object Manager verwaltet die Sammlungen von Virtual Objects. Tester können die virtuellen Objekte im Virtual Object Manager hinzufügen oder löschen.

Navigation zum Virtual Object Manager: "Tools" >> "Virtual Object Manager" wie unten gezeigt -

Virtuelle Objekte verwenden

Nach dem Erstellen der virtuellen Objekte kann das erstellte Objekt wie folgt verwendet werden:

Window("Microsoft Word").WinObject("Ribbon").VirtualButton("button").Click

Einschränkungen für virtuelle Objekte

• QTP unterstützt keine virtuellen Objekte für analoge oder Low-Level-Aufnahmen.

• Checkpoints können nicht zu virtuellen Objekten hinzugefügt werden.

• Virtuelle Objekte werden nicht vom Objekt-Repository gesteuert.

• Obwohl wir ein Objekt einer bestimmten Klasse (Schaltfläche oder Liste) zuordnen, werden nicht alle Methoden der nativen Objekte von virtuellen Objekten unterstützt.

• Object Spy kann nicht für virtuelle Objekte verwendet werden.

• Die Testausführung schlägt fehl, wenn sich die Bildschirmauflösung ändert, wenn sich die Koordinaten ändern.

• Das Anwendungsfenster sollte dieselbe Bildschirmgröße haben, damit virtuelle Objekte korrekt erfasst werden.

Aus diesem Grund bietet QTP keine integrierte Unterstützung für die Verbindung zur Datenbank. Mit VBScript-Testern können jedoch Datenbanken mithilfe von ADODB-Objekten verbunden und mit diesen interagiert werden.

ADODB verfügt über 4 Eigenschaften oder Methoden, mit denen wir mit den Datenbanken arbeiten können. Sie sind -

• ADODB.Connection - Wird verwendet, um eine Verbindung zur Datenbank herzustellen

• ADODB.Command - Wird verwendet, um einen SQL-Befehl auszuführen (Abfragen oder gespeicherte Prozeduren).

• ADODB.Fields - Dient zum Abrufen einer bestimmten Spalte aus einem Datensatz nach dem Ausführen einer Abfrage / eines gespeicherten Prozesses

• ADODB.Recordset - Wird zum Abrufen von Daten aus einer Datenbank verwendet

Wie verbinde ich mich mit der Datenbank?

Datenbanken können mithilfe von Verbindungszeichenfolgen verbunden werden. Jede Datenbank unterscheidet sich in der Art und Weise, wie wir uns mit ihnen verbinden. Die Verbindungszeichenfolgen können jedoch mithilfe von www.connectionstrings.com erstellt werden

Lassen Sie uns sehen, wie Sie mit den folgenden Parametern eine Verbindung zur Datenbank herstellen:

• Database Type - MSSQL-Server

• Server Name - SQLEXPRESS

• Database Name - Prozess

• User Id - sa

• password - Passwort123

Die Ausgabe der Abfrage wird im SQL Server Management Studio wie folgt angezeigt:

Dim objConnection 
'Set Adodb Connection Object
Set objConnection = CreateObject("ADODB.Connection")     
Dim objRecordSet 
 
'Create RecordSet Object
Set objRecordSet = CreateObject("ADODB.Recordset")     
 
Dim DBQuery 'Query to be Executed
DBQuery = "Select NAME from dbo.EMPLOYEE where AGE = 29"
 
'Connecting using SQL OLEDB Driver
objConnection.Open "Provider = sqloledb.1;Server =.\SQLEXPRESS;
User Id = sa;Password=Password123;Database = Trial"
 
'Execute the Query
objRecordSet.Open DBQuery,objConnection
 
'Return the Result Set
Value = objRecordSet.fields.item(0)				
msgbox Value
 
' Release the Resources
objRecordSet.Close        
objConnection.Close		
 
Set objConnection = Nothing
Set objRecordSet = Nothing

Ergebnis

Bei Ausführung des obigen Skripts wird die Ausgabe im Meldungsfeld wie folgt angezeigt:

XML ist eine Auszeichnungssprache zum Speichern von Daten in einem Format, das sowohl von Mensch als auch von Maschine gelesen werden kann. Mit XML können Daten auch problemlos zwischen Computer- und Datenbanksystemen ausgetauscht werden.

Beispiel-XML und ihre Schlüsselelemente sind unten dargestellt -

Zugriff auf XML

Const XMLDataFile = "C:\TestData.xml"
Set xmlDoc = CreateObject("Microsoft.XMLDOM")
xmlDoc.Async = False
xmlDoc.Load(XMLDataFile)

' Getting the number of Nodes (books)
Set nodes = xmlDoc.SelectNodes("/bookstore/book")
Print "Total books: " & nodes.Length    ' Displays 2

' get all titles
Set nodes = xmlDoc.SelectNodes("/Booklib/book/value/text()")

' get their values
For i = 0 To (nodes.Length - 1)
   Title = nodes(i).NodeValue
   Print "Title is" & (i + 1) & ": " & Title
Next

XML vergleichen

Wir können zwei gegebene XMLs vergleichen -

Dim xmlDoc1
Dim xmlDoc2

' Load the XML Files
Set xmlDoc1 = XMLUtil.CreateXMLFromFile ("C:\File1.xml")
Set xmlDoc2 = XMLUtil.CreateXMLFromFile ("C:\File2.xml")

'Use the compare method of the XML to check if they are equivalent
Comp = xmlDoc1.Compare (xmlDoc1, xmlDoc2)

'Returns 1 if the two files are the same
If Comp = 1 Then
   Msgbox "XML Files are the Same"
Else
   Msgbox "XML Files are Different"
End if

QTP-Skripte können nur ausgeführt werden, wenn die Objekte im Objekt-Repository vorhanden sind. Die Beschreibungen der Objekte werden mit der beschreibenden Programmierung erstellt -

• Wenn die Tester eine Operation für ein Objekt ausführen möchten, das nicht im Objektrepository vorhanden ist

• Wenn Objekte in der Anwendung sehr dynamisch sind.

• Wenn das Objekt-Repository groß wird, führt dies zu einer schlechten Leistung, wenn die Größe des Objekt-Repositorys zunimmt.

• Wenn das Framework erstellt wird, wurde entschieden, das Objekt-Repository überhaupt nicht zu verwenden.

• Wenn Tester zur Laufzeit eine Aktion für die Anwendung ausführen möchten, ohne die eindeutigen Eigenschaften des Objekts zu kennen.

Syntax

Es gibt zwei Möglichkeiten zum Erstellen von Skripten mithilfe der Descriptive Programming-Technik. Sie sind -

• Beschreibung Objekte
• Beschreibung Strings

Beschreibung Objekte

Das Skript wird mithilfe von Beschreibungsobjekten entwickelt, die von den verwendeten Eigenschaften und ihren entsprechenden Werten abhängen. Diese Beschreibungen werden dann zum Erstellen des Skripts verwendet.

'Creating a description object
Set btncalc = Description.Create()

'Add descriptions and properties
btncalc("type").value = "Button"
btncalc("name").value = "calculate"
btncalc("html tag").value = "INPUT"

' Use the same to script it
Browser("Math Calc").Page("Num Calculator").WebButton(btncalc).Click

Beschreibung Strings

Die Beschreibung der Objekte wird unter Verwendung der Eigenschaften und Werte als Zeichenfolgen wie unten gezeigt entwickelt.

Browser("Math Calc").Page("Num Calculator").WebButton("html 
tag:=INPUT","type:=Button","name:=calculate").Click

Untergeordnete Objekte

QTP bietet die ChildObjects-Methode, mit der wir eine Sammlung von Objekten erstellen können. Die übergeordneten Objekte stehen vor ChildObjects.

Dim oDesc
Set oDesc = Description.Create
oDesc("micclass").value = "Link"

'Find all the Links
Set obj = Browser("Math Calc").Page("Math Calc").ChildObjects(oDesc)

Dim i
'obj.Count value has the number of links in the page

For i = 0 to obj.Count - 1	 
   'get the name of all the links in the page			
   x = obj(i).GetROProperty("innerhtml") 
   print x 
Next

Ordnungszahlen

Beschreibende Programmierung wird verwendet, um das Skript basierend auf Ordnungskennungen zu schreiben, wodurch QTP auf diese Objekte einwirken kann, wenn zwei oder mehr Objekte dieselben Eigenschaften haben.

' Using Location
Dim Obj
Set Obj = Browser("title:=.*google.*").Page("micclass:=Page")
Obj.WebEdit("name:=Test","location:=0").Set "ABC"
Obj.WebEdit("name:=Test","location:=1").Set "123"
 
' Index
Obj.WebEdit("name:=Test","index:=0").Set "1123"
Obj.WebEdit("name:=Test","index:=1").Set "2222"
 
' Creation Time
Browser("creationtime:=0").Sync
Browser("creationtime:=1").Sync
Browser("creationtime:=2").Sync

QTP selbst kann über die von HP-QTP bereitgestellte COM-Schnittstelle automatisiert werden. Das Automatisierungsobjektmodell besteht aus einer Reihe von Objekten, Methoden und Eigenschaften, mit denen die Tester die Konfigurationseinstellungen steuern und die Skripts über die QTP-Schnittstelle ausführen können. Die Schlüsselkonfigurationen / -aktionen, die gesteuert werden können (aber nicht darauf beschränkt sind), sind unten aufgeführt -

• Lädt alle erforderlichen Add-Ins für einen Test
• Macht QTP während der Ausführung sichtbar
• Öffnet den Test an der angegebenen Stelle
• Assoziiert Funktionsbibliotheken
• Gibt das Zeitlimit für die Synchronisierung gemeinsamer Objekte an
• Iteration starten und beenden
• Aktivieren / Deaktivieren der intelligenten Identifizierung
• Bei Fehlereinstellungen
• Datentabellenpfad
• Einstellungen für das Wiederherstellungsszenario
• Protokollverfolgungseinstellungen

QTP 11.5x bietet eine exklusive Dokumentation zum Automatisierungsobjektmodell, auf die durch Navigieren zu "Start" >> "Alle Programme" >> "HP Software" >> "HP Unified Functional Testing" >> "Dokumentation" >> "Unified" verwiesen werden kann Referenz zur Automatisierung von Funktionstests ".

AOM-Skript generieren

Ein Tester kann mit der Option "Skript generieren" ein AOM-Skript aus QTP selbst generieren. Navigieren Sie zu "Ausführen" >> "Einstellungen" >> Registerkarte "Eigenschaften" >> "Skript generieren" wie unten gezeigt -

Beispiel

' A Sample Script to Demostrate AOM
Dim App 'As Application
Set App = CreateObject("QuickTest.Application")
App.Launch
App.Visible = True

App.Test.Settings.Launchers("Web").Active = False
App.Test.Settings.Launchers("Web").Browser = "IE"
App.Test.Settings.Launchers("Web").Address = "http://easycalculation.com/"
App.Test.Settings.Launchers("Web").CloseOnExit = True

App.Test.Settings.Launchers("Windows Applications").Active = False
App.Test.Settings.Launchers("Windows Applications").Applications.RemoveAll
App.Test.Settings.Launchers("Windows Applications").RecordOnQTDescendants = True
App.Test.Settings.Launchers("Windows Applications").RecordOnExplorerDescendants = False
App.Test.Settings.Launchers("Windows Applications").RecordOnSpecifiedApplications = True

App.Test.Settings.Run.IterationMode = "rngAll"
App.Test.Settings.Run.StartIteration = 1
App.Test.Settings.Run.EndIteration = 1
App.Test.Settings.Run.ObjectSyncTimeOut = 20000
App.Test.Settings.Run.DisableSmartIdentification = False
App.Test.Settings.Run.OnError = "Dialog"

App.Test.Settings.Resources.DataTablePath = "<Default>"
App.Test.Settings.Resources.Libraries.RemoveAll

App.Test.Settings.Web.BrowserNavigationTimeout = 60000
App.Test.Settings.Web.ActiveScreenAccess.UserName = ""
App.Test.Settings.Web.ActiveScreenAccess.Password = ""

App.Test.Settings.Recovery.Enabled = True
App.Test.Settings.Recovery.SetActivationMode "OnError"
App.Test.Settings.Recovery.Add "D:\GUITest2\recover_app_crash.qrs", 
   "Recover_Application_Crash", 1
App.Test.Settings.Recovery.Item(1).Enabled = True 

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' System Local Monitoring settings
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
App.Test.Settings.LocalSystemMonitor.Enable = false
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Log Tracking settings
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
With App.Test.Settings.LogTracking
   .IncludeInResults = False
   .Port = 18081 
   .IP = "127.0.0.1"
   .MinTriggerLevel = "ERROR"
   .EnableAutoConfig = False
   .RecoverConfigAfterRun = False
   .ConfigFile = ""
   .MinConfigLevel = "WARN" 
End With

Ein Framework definiert eine Reihe von Richtlinien / Best Practices, die eine Reihe von Standards durchsetzen, die es den Endbenutzern erleichtern, mit ihnen zu arbeiten. Es gibt verschiedene Arten von Automatisierungs-Frameworks und die häufigsten sind unten aufgeführt -

• Keyword-gesteuertes Framework
• Datengesteuertes Framework
• Hybrid Framework

Keyword-gesteuertes Framework

Keyword-gesteuertes Testen ist eine Art funktionales Automatisierungstest-Framework, das auch als tabellengesteuertes Testen oder aktionswortbasiertes Testen bezeichnet wird.

Beim schlüsselwortgesteuerten Testen verwenden wir ein Tabellenformat, normalerweise eine Tabelle, um Schlüsselwörter oder Aktionswörter für jede Funktion zu definieren, die wir ausführen möchten.

Vorteile

• Es ist am besten für Anfänger oder nicht-technische Tester geeignet.

• Ermöglicht das Schreiben von Tests auf abstraktere Weise mit diesem Ansatz.

• Durch das schlüsselwortgesteuerte Testen kann die Automatisierung früher im SDLC gestartet werden, noch bevor ein stabiler Build zum Testen bereitgestellt wird.

• Es besteht ein hohes Maß an Wiederverwendbarkeit.

Nachteile

• Die anfängliche Investition in die Entwicklung der Schlüsselwörter und der damit verbundenen Funktionen kann länger dauern.

• Dies kann eine Einschränkung für technisch versierte Tester darstellen.

Datengesteuertes Framework

Datengesteuertes Testen ist die Erstellung von Testskripten, bei denen Testdaten und / oder Ausgabewerte aus Datendateien gelesen werden, anstatt bei jedem Testlauf dieselben fest codierten Werte zu verwenden. Auf diese Weise können die Tester testen, wie die Anwendung verschiedene Eingaben effektiv verarbeitet. Es kann sich um eine der folgenden Datendateien handeln:

• datapools
• Excel-Dateien
• ADO-Objekte
• CSV-Dateien
• ODBC-Quellen

Flussdiagramm

Datengesteuertes Testen lässt sich am besten anhand des folgenden Diagramms verstehen:

Vorteile

• Datengesteuertes Framework führt zu weniger Code
• Bietet mehr Flexibilität beim Verwalten und Beheben von Skriptproblemen
• Testdaten können entwickelt werden

Nachteile

• Jedes Skript muss anders sein, um unterschiedliche Datensätze zu verstehen.

Hybrid Framework

Hybrid Framework ist eine Kombination aus Keyword-gesteuertem und datengesteuertem Framework, die am besten anhand des folgenden Flussdiagramms beschrieben werden kann.

Einflussfaktoren

Im Folgenden sind die Parameter aufgeführt, die bei der Entwicklung des Frameworks berücksichtigt werden sollten. Die Einflussfaktoren sind unten aufgeführt -

• Framework-Dateien sollten Versionskontrollsoftware wie SVN, CVS und MS Source Control unterstützen

• Das Framework sollte die Ausführung der Skripte in verschiedenen Umgebungen unterstützen, nämlich QA, SAT, DEV

• Bei Objektänderungen sollten Skripte mit minimalen Änderungen ausgeführt werden.

• Framework sollte sich selbst konfigurieren und sich um Voraussetzungen wie das Erstellen von Ordnern / Datenbanken kümmern.

• Das Framework sollte über eine robuste Berichtsstruktur verfügen, damit Probleme im Skript / in der Anwendung leicht erkannt werden können

• Das Framework sollte flexibler sein, damit es einfach zu verwenden ist

• Das Framework sollte den Codierungsstandards folgen, damit Dateien, Funktionen und Änderungsverlauf korrekt verwaltet werden.

Im nächsten Kapitel erfahren Sie, wie Sie ein einfaches Framework entwerfen.

Lassen Sie uns ein einfaches Framework entwerfen, indem wir eine Beispielanwendung nehmen. Wir werden einige Szenarien der zu testenden Anwendung automatisieren und wiederverwendbare Funktionen schreiben.

Die zu testende Beispielanwendung ist "Calculator", eine Standardanwendung, die als Teil von Windows verfügbar ist. Lassen Sie uns nun verschiedene Komponenten eines Frameworks erstellen. Hier werden wir ein hybrides Framework entwickeln und Object Repository verwenden, da es eine ziemlich einfache Anwendung ist. Dieses Framework kann jedoch skaliert werden, um auch eine komplexe Anwendung zu unterstützen.

Die Ordnerstruktur des Frameworks ist wie folgt:

Erläuterung der Ordnerstruktur -

• Master Driver Script- Das Skript, das die gesamte Ausführung steuert. Es führt die für die Ausführung erforderlichen Voraussetzungen und Anfangseinstellungen durch.

• Library Files - Die zugehörigen Funktionen, die die Funktionsbibliothek bilden.

• Data Table - Die Testdaten, die für die Ausführung benötigt werden.

• Object Repository - Die Objekte und ihre Eigenschaften, mit denen QTP die Objekte nahtlos erkennen kann.

• Execution Logs - Der Ordner enthält die Ausführungsprotokolldatei mit Benutzerfunktionen und Funktionsausführungsverlauf.

Master Driver Script

'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 
' MASTER DRIVER SCRIPT NAME    : Calculator 
' DESCRIPTION                  : Drivers Script to Execute Automated Test for 
   the Calculator  
' AUTHOR                       : Tutorials Point 
' DATE CREATED                 : 30-Dec-2013 
' OBJECT REPOSITORY ASSOCIATED : Calc.tsr 
' LIBRARY FILES ASSOCIATED     : calculator.qfl, Common.qfl 
' MODIFICATION LOG

' ---------------------------------------------------- 
' First Version       Tutorials point 
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =  
Option Explicit  

Public ExecDrive  

' Get the Root folder of the Test  so that we can make use of relative paths. 
Dim x : x = Instr(Environment.Value("TestDir"),"Driver")-2 
ExecDrive = mid(Environment.Value("TestDir"),1,x)  

' Get the path of Libraries using relative to the current Drive 
Dim LibPath : LibPath = ExecDrive+"\Libraries\"  

' Dynamically Load the Function Libraries 
LoadFunctionLibrary LibPath + "Calculator.qfl", LibPath + "common_utils.qfl"   

' Capturing the Start Time 
' clscommon is the class object created in common.qfl library file 
clscommon.StartTime = Time()  

' Launching the Application 
SystemUtil.Run "C:\Windows\System32\Calc.exe" : wait (2)  

' Initialize the Data Table Path  
Dim FileName : FileName  = ExecDrive+"\TestData\Calculator.xls" 
Dim SheetSource : SheetSource  = "Calc_test" 
Dim SheetDest : SheetDest = "Global"  

' Import the DataTable into the QTP Script 
DataTable.ImportSheet  FileName , SheetSource , SheetDest   

' Object Repository Path 
Dim RepPath : RepPath = ExecDrive+"\Object_Repository\Calc.tsr" 
RepositoriesCollection.RemoveAll()  
RepositoriesCollection.Add(RepPath)   

' To Keep a Count on iteration 
Dim InttestIteration                   
Dim InttestRows : InttestRows = datatable.GetRowCount   

'  Fetching Date-TimeStamp which will be unique for Naming the Execution Log File 
clscommon.StrDateFormatted = day(date()) & "_" &  MonthName(Month(date()),true) &  
 "_" & YEAR(date())& "_"&hour(now)&"_"&minute(now)  

 ' Name the LogFile  
clscommon.StrLogFile = ExecDrive & "\Execution Logs\" &  
clscommon.StrDateFormatted & ".txt"   

' Create the Execution LogFile which captures the result 
clscommon.Fn_FileCreate(clscommon.StrLogFile)  

' Iniitialize the Parameters and all the relevant Test Details 
Call Fn_InitializeLogFile()  

' Kill all the previous calculator process  
Call fn_Kill_Process("calc.exe")  

For InttestIteration = 1 to InttestRows 
   datatable.SetCurrentRow InttestIteration  
   Dim StrExecute : StrExecute = Ucase(Trim(datatable.Value("Run","Global"))) 
   If StrExecute = "Y" Then  
      clscommon.Number1 = Trim(datatable.Value("Number_1","Global"))  
      clscommon.Number2 = Trim(datatable.Value("Number_2","Global"))  
      clscommon.Number3 = Trim(datatable.Value("Number_3","Global"))  
   
      clscommon.Number4 = Trim(datatable.Value("Number_4","Global"))  
      clscommon.Number5 = Trim(datatable.Value("Number_5","Global"))  
      clscommon.Number6 = Trim(datatable.Value("Number_6","Global"))  
   
      clscommon.Test_Case_ID  = 
         Trim(datatable.Value("Test_Case_ID","Global"))' 
            : clscommon.LogWrite "The Test Case Data is Located at :: " & tcDataPath 
      clscommon.tcScenario = 
         Trim(datatable.Value("Scenario","Global"))' 
            : clscommon.LogWrite "The Test Case Data is Located at :: " & tcDataPath 
      Dim  Expected_Val :  Expected_Val = 
         Trim(datatable.Value("Expected_Val","Global"))'                        
            :  clscommon.LogWrite "The Test Case Data is Located at :: " & tcDataPath 
   
      Select case clscommon.tcScenario  
         Case "Add" 
            clscommon.LogWrite "=== Inside the Test Set :: " & 
               clscommon.tcScenario & " ===" 
                  Call fnCalculate("+",Expected_Val) 
    
         Case "Subtract"   
            clscommon.LogWrite "=== Inside the Test Set :: " & 
               clscommon.tcScenario & " ===" 
                  Call fnCalculate("-",Expected_Val) 
    
         Case "Multiply"   
            clscommon.LogWrite "=== Inside the Test Set :: " & 
               clscommon.tcScenario & " ===" 
                  Call fnCalculate("*",Expected_Val) 
    
         Case "Divide"   
            clscommon.LogWrite "=== Inside the Test Set :: " & 
               clscommon.tcScenario & " ===" 
                  Call fnCalculate("/",Expected_Val) 
    
         Case "Sqrt"   
            clscommon.LogWrite "=== Inside the Test Set :: " & 
               clscommon.tcScenario & " ===" 
                  Call fnCalculate("sqt",Expected_Val) 
      End Select 
   End If  
Next  

' Calling the End Test to Add the result Footer in exec log file. 
Call fn_End_test()  

'  =====================  End of Master Driver Script =====================

Bibliotheksdateien

Die Taschenrechnerfunktionen werden in eine separate Funktionsdatei geschrieben, die mit der Erweiterung .qfl oder .vbs gespeichert ist. Diese Funktionen können für alle Aktionen wiederverwendet werden.

'  Calculator. Qfl File :: Associated Function Library for Calculator Master Driver  

'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =  
' FUNCTION NAME     : Fn_InitializeLogFile 
' DESCRIPTION       : Function to Write the Initial Values in the Log File 
' INPUT PARAMETERS  : varExecDrive,StrDB,StrUId,Strpwd,StrNewDB 
' OUTPUT PARAMETERS : NIL 
' RETURN VALUE      : Pass or Fail message 
' DATE CREATED      : 30-Dec-2013 
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =  
Public Function Fn_InitializeLogFile() 
   clscommon.LogWrite "********************************************" 
   clscommon.LogWrite "Calc Automation Started" 
End Function 
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =  
' FUNCTION NAME     : fnCalculate 
' DESCRIPTION       : Function to perform Arithmetic Calculations 
' INPUT PARAMETERS  : operator,Expected_Val 
' OUTPUT PARAMETERS : NIL 
' RETURN VALUE      : Pass or Fail message 
' DATE CREATED      : 30-Dec-2013 
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =    
Function fnCalculate(operator,Expected_Val) 
   clscommon.LogWrite "Executing the Function 'fnCalculate' " 

   Window("Calculator").Activate 
    
   If Trim(clscommon.Number1) <> ""  Then
      Window("Calculator").WinButton(clscommon.Number1).Click 
   If Trim(clscommon.Number2) <> ""  Then 
      Window("Calculator").WinButton(clscommon.Number2).Click 
   If Trim(clscommon.Number3) <> ""  Then 
      Window("Calculator").WinButton(clscommon.Number3).Click 

   Window("Calculator").WinButton(operator).Click 
   If Trim(clscommon.Number4) <> ""  Then 
      Window("Calculator").WinButton(clscommon.Number4).Click 
   If Trim(clscommon.Number5) <> ""  Then 
      Window("Calculator").WinButton(clscommon.Number5).Click 
   If Trim(clscommon.Number6) <> ""  Then 
      Window("Calculator").WinButton(clscommon.Number6).Click 

   Window("Calculator").WinButton("=").Click 
   Dim ActualVal : ActualVal  = 
      Window("Calculator").WinEdit("Edit").GetROProperty("text") 
   clscommon.LogWrite "The Actual Value after the Math Operation is "& ActualVal 
  
   If Trim(ActualVal) = Trim(Expected_Val) Then 
      clscommon.WriteResult "Pass",  clscommon.Test_Case_ID , 
         clscommon.tcScenario , " Expected Value matches with Actual Value :: " 
            & ActualVal 
    
   Else 
      clscommon.WriteResult "Fail",  clscommon.Test_Case_ID , 
         clscommon.tcScenario , " Expected Value - " & Expected_Val & " Does NOT matches 
            with Actual Value :: " & ActualVal 
   End If 
    
   Window("Calculator").WinButton("C").Click 
    
   If Err.Number <> 0  Then 
      clscommon.LogWrite  "Execution Error : The Error Number is ::  " & 
         Err.Number & " The Error Description is " & Err.Description 
      Err.Clear 
   End If 
    
   clscommon.LogWrite "Exiting the Function 'fnCalculate' " 
End Function  

'= = = = = = = = = = = = = = = = = = = = = = = = = = = 
' FUNCTION NAME     : fn_Kill_Process 
' DESCRIPTION       : Function to Kill the process by name 
' INPUT PARAMETERS  : Application name to be killed 
' OUTPUT PARAMETERS : NIL 
' RETURN VALUE      : NIL 
' DATE CREATED      : 30-Dec-2013 
'= = = = = = = = = = = = = = = = = = = = = = = = = = =  
Function fn_Kill_Process(process) 
   Dim strComputer ,  strProcessToKill , objWMIService , colProcessstrComputer = "." 
   strProcessToKill = process 
    
   Set objWMIService = GetObject("winmgmts:" _& 
      "{impersonationLevel=impersonate}!\\" _& strComputer & "\root\cimv2") 
    
   Set colProcess = objWMIService.ExecQuery _("Select * from Win32_Process 
      Where Name = '" & strProcessToKill & "'") 
    
   count = 0 
   For Each objProcess in colProcess 
      objProcess.Terminate() 
      count = count + 1 
   Next 
End Function  

'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =  
' FUNCTION NAME     : fn_End_test 
' DESCRIPTION       : Function to finish the test Execution process 
' INPUT PARAMETERS  : Application name to be killed 
' OUTPUT PARAMETERS : NIL 
' RETURN VALUE      : NIL 
' DATE CREATED      : 20/Dec/2013 
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 
Function fn_End_test() 
   clscommon.LogWrite "Status Message - Executing the Function 'fn_End_test' " 
    
   Window("Calculator").Close 
   On Error Resume Next 
    
   clscommon.StopTime = Time() 
   clscommon.ElapsedTime = DateDiff("n",clscommon.StartTime,clscommon.StopTime) 
   Dim Totaltests  
   Totaltests = clscommon.gintPassCount+ clscommon.gintFailCount
   clscommon.LogWrite "## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
   clscommon.LogWrite "##  The Execution Start Time  ::  " & clscommon.StartTime 
   clscommon.LogWrite "##  The Execution End Time   ::  " & clscommon.StopTime 
   clscommon.LogWrite "##  The Time Elapsed ::   " & clscommon.ElapsedTime & " Minutes " 
   clscommon.LogWrite "##  The OS ::  " & Environment.Value("OS") 
   clscommon.LogWrite "##  The Total No of Test Cases Executed  ::  " & Totaltests 
   clscommon.LogWrite "##  The No. of Test Case Passed ::  " & clscommon.gintPassCount 
   clscommon.LogWrite "##  The No. of Test Case Failed ::  " & clscommon.gintFailCount 
   clscommon.LogWrite "## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
   SystemUtil.CloseDescendentProcesses 
End Function  
'  ===============   End of Calculator. Qfl   ============================= '

Die andere Bibliotheksdatei, 'common_utils.qfl', die die Funktionen enthält, ermöglicht es uns, die Ausgabe in eine Textdatei zu schreiben.

Set clscommon = New OS_clsUtils  

'Creating a class file to handle global variables. 
Class OS_clsUtils 
   Dim StrLogFile 
   Dim StrDateFormatted 
   Dim Result 
    
   Dim  Number1, Number2 , Number3  
   Dim  Number4, Number5 , Number6  
   Dim Test_Case_ID , tcScenario 
   Dim StartTime, StopTime, ElapsedTime 
   
   Dim gintPassCount , gintFailCount , gintWarningCount ,  gintdoneCount,  
      gintinfoCount 
    
   Function Fn_FileCreate(strFileName) 
      Dim objFSO:  Set objFSO = CreateObject("Scripting.FileSystemObject") 
      On Error Resume Next 
      
      Dim objTextFile : Set objTextFile = objFSO.CreateTextFile(strFileName) 
      objTextFile.Close 
       
      Set objTextFile = Nothing 
      Set objFSO = Nothing 
   End Function 
    
   Function LogWrite(sMsg) 
      Const ForAppending = 8 
       
      Dim objFSO : Set objFSO = CreateObject("scripting.FileSystemObject") 
      
      Dim objTextFile : Set objTextFile = objFSO.OpenTextFile 
         (clscommon.StrLogFile, ForAppending, True) 
       
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & sMsg 
      objTextFile.Close 
       
      Set objTextFile = Nothing 
      Set objFSO = Nothing 
   End Function 
    
   Function WriteResult(strStatus,functionName,functionDescription,Result) 
      Const ForAppending = 8 
      Dim objFSO : Set objFSO = CreateObject("scripting.FileSystemObject") 
      Dim objTextFile : Set objTextFile = objFSO.OpenTextFile 
         (clscommon.StrLogFile, ForAppending, True) 
       
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & "  
            * * * * * * Test Case Exec Details  * * * * * " 
      
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & " Test staus :: " & strStatus 
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & " Tese ID ::  " & functionName 
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & " Test Description :: " 
            & functionDescription 
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & " Test Result Details :: " & Result 
      objTextFile.WriteLine day(date()) & "/" &  MonthName(Month(date()),true) 
         &  "/" & YEAR(date()) & " " & time & ": " & "  
            * * * * * * * * * * * * * * * * * * * * * * * *  * * * * * * * * * * * " 
      objTextFile.Close 
       
      Set objTextFile = Nothing  
      Set objFSO = Nothing 
       
      Select Case Lcase(strStatus) 
         Case "pass" 
            gintPassCount = gintPassCount + 1 
          
         Case "fail" 
            gintFailCount = gintFailCount+1 
      End Select 
   End Function 
End Class 
'   =====================   End of common_Utils.qfl =====================

Objekt-Repository

Das Objekt-Repository verfügt über alle Objekte, auf die der Benutzer reagieren würde. Das folgende Bild zeigt die Liste aller Objekte, die dem Repository mit dem Namen calc.tsr hinzugefügt wurden

Datentabelle

DataTable enthält die Schlüsselwörter, die die Tests steuern, sowie die Daten, mit denen QTP auf die Objekte einwirkt.

Das Ausführungsprotokoll

Die Ausführungsprotokolldatei oder Ausgabedatei enthält Benutzeraktionen und ein Funktionsprotokoll, mit denen die Tester bei Skriptfehlern debuggen können.

8/Jan/2014 5:09:16 PM: ************************************************* 
8/Jan/2014 5:09:16 PM: Calc Automation Started 
8/Jan/2014 5:09:16 PM: === Inside the Test Set  ::   Add  === 
8/Jan/2014 5:09:16 PM: Executing the Function 'fnCalculate'  
8/Jan/2014 5:09:17 PM: The Actual Value after the Math Operation is 949.  
8/Jan/2014 5:09:17 PM:  * * * * * * Test Case Exec Details  * * * * *  
8/Jan/2014 5:09:17 PM: Test staus :: Pass 
8/Jan/2014 5:09:17 PM: Tese ID ::  TC_001 
8/Jan/2014 5:09:17 PM: Test Description :: Add 
8/Jan/2014 5:09:17 PM: Test Result Details ::  Expected Value matches with Actual 
   Value :: 949.  
8/Jan/2014 5:09:17 PM: * * * * * * * * * * * * * * * * * * * * * * * *  * * 
* * * * * * * * * 
  
8/Jan/2014 5:09:17 PM: Exiting the Function 'fnCalculate'  
8/Jan/2014 5:09:17 PM: === Inside the Test Set  ::   Subtract  === 
8/Jan/2014 5:09:17 PM: Executing the Function 'fnCalculate'  
8/Jan/2014 5:09:17 PM: The Actual Value after the Math Operation is 415.  
8/Jan/2014 5:09:17 PM: * * * * * * Test Case Exec Details  * * * * *  
8/Jan/2014 5:09:17 PM: Test staus :: Pass 
8/Jan/2014 5:09:17 PM: Tese ID ::  TC_002 
8/Jan/2014 5:09:17 PM: Test Description :: Subtract 
8/Jan/2014 5:09:17 PM: Test Result Details ::  Expected Value matches with Actual 
   Value :: 415.  
8/Jan/2014 5:09:17 PM: * * * * * * * * * * * * * * * * * * * * * * * *  * * * 
* * * * * * * *

8/Jan/2014 5:09:17 PM: Exiting the Function 'fnCalculate'  
8/Jan/2014 5:09:17 PM: === Inside the Test Set  ::   Multiply  === 
8/Jan/2014 5:09:17 PM: Executing the Function 'fnCalculate'  
8/Jan/2014 5:09:18 PM: The Actual Value after the Math Operation is 278883.  
8/Jan/2014 5:09:18 PM: * * * * * * Test Case Exec Details  * * * * *  
8/Jan/2014 5:09:18 PM: Test staus :: Pass 
8/Jan/2014 5:09:18 PM: Tese ID ::  TC_003 
8/Jan/2014 5:09:18 PM: Test Description :: Multiply 
8/Jan/2014 5:09:18 PM:  Test Result Details ::  Expected Value matches with 
   Actual Value :: 278883.  
8/Jan/2014 5:09:18 PM: * * * * * * * * * * * * * * * * * * * * * * * *  * * * 
* * * * * * * *   

8/Jan/2014 5:09:18 PM: Exiting the Function 'fnCalculate'  
8/Jan/2014 5:09:18 PM: === Inside the Test Set  ::   Divide  === 
8/Jan/2014 5:09:18 PM: Executing the Function 'fnCalculate'  
8/Jan/2014 5:09:19 PM: The Actual Value after the Math Operation is 3.  
8/Jan/2014 5:09:19 PM: * * * * * * Test Case Exec Details  * * * * *  
8/Jan/2014 5:09:19 PM: Test staus :: Pass 
8/Jan/2014 5:09:19 PM: Tese ID ::  TC_004 
8/Jan/2014 5:09:19 PM: Test Description :: Divide 
8/Jan/2014 5:09:19 PM: Test Result Details ::  Expected Value matches with Actual 
   Value :: 3.  
8/Jan/2014 5:09:19 PM: * * * * * * * * * * * * * * * * * * * * * * * *  * * * 
* * * * * * * * 
  
8/Jan/2014 5:09:19 PM: Exiting the Function 'fnCalculate'  
8/Jan/2014 5:09:19 PM: === Inside the Test Set  ::   Sqrt  === 
8/Jan/2014 5:09:19 PM: Executing the Function 'fnCalculate'  
8/Jan/2014 5:09:20 PM: The Actual Value after the Math Operation is 10.  
8/Jan/2014 5:09:20 PM: * * * * * * Test Case Exec Details  * * * * *  
8/Jan/2014 5:09:20 PM: Test staus :: Pass 
8/Jan/2014 5:09:20 PM: Tese ID ::  TC_005 
8/Jan/2014 5:09:20 PM: Test Description :: Sqrt 
8/Jan/2014 5:09:20 PM: Test Result Details ::  Expected Value matches with Actual 
   Value :: 10.  
8/Jan/2014 5:09:20 PM: * * * * * * * * * * * * * * * * * * * * * * * *  * * * * 
* * * * * * * 

8/Jan/2014 5:09:20 PM: Exiting the Function 'fnCalculate'  
8/Jan/2014 5:09:20 PM: Status Message - Executing the Function 'fn_Finish_test'  
8/Jan/2014 5:09:20 PM: ## # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # #  
8/Jan/2014 5:09:20 PM: ##  The Execution Start Time  ::  5:09:14 PM 
8/Jan/2014 5:09:20 PM: ##  The Execution End Time   ::  5:09:20 PM 
8/Jan/2014 5:09:20 PM: ##  The Time Elapsed ::   0 Minutes  
8/Jan/2014 5:09:20 PM: ##  The OS ::  Microsoft Windows Vista Server 
8/Jan/2014 5:09:20 PM: ##  The Total No of Test Cases Executed  ::  25 
8/Jan/2014 5:09:20 PM: ##  The No. of Test Case Passed ::  25 
8/Jan/2014 5:09:20 PM: ##  The No. of Test Case Failed ::   
8/Jan/2014 5:09:20 PM: ## # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # #