What is TPT (time partition testing) test methodology?

TPT test methodology or Time Partition Testing is quite a systematic one and is used for carrying out automated testing of software systems and applications. This tool is also used to verify the data flow programs and embedded control systems as well. 

About Time Partition Testing

- Time partition testing methodology has been designed exclusively for the validation and verification of the embedded systems whose input and output data can be represented as signals. 

- Also, this tool is used for testing the continuous behavior of the software systems and applications. 

- Many of the controls systems belong to this category of software systems and applications.

- One of the characteristic feature of such systems is that they interact very well when interlinked with the real world environment. 

- There is a need for the controllers to closely observe the environment and react accordingly towards it. 

- There exists an interactive cycle within this environment in which these systems are supposed to work. 

- This cycle is subject to the temporal constraints. 

- Testing such systems means simulation and checking of their timing behavior. 

- The time partition testing makes use of model based testing rather than using scripts like the traditional functional testing methods. 

- Time portioning testing methodology makes a combination of the graphic and systematic modeling techniques for running the test cases fully in a variety of environments and need to be evaluated automatically. 

- The below mentioned 4 test activities are covered by time portioning testing methodology:

1. Test case modeling
2. Automated test documentation
3. Test management
4. Automated test execution in a number of environments
5. Automated test result analysis including automated test assessment

- In this methodology, the special state machines and time partitioning methodology is used for modeling the tests. 

- Hybrid automation can be done for all the tests belonging to an SUT (system under test).

- Tests come with a logical phase sequence. 

- The logical passes are somewhat similar for all the tests and are represented by the states of the finite state machine. 

- The transitions that occur between the phases of a test are modeled by trigger conditions. 

- Each transition is characterized by different variants. 

- These individual variants are made in to unique combinations which in turn are used for modeling individual test cases. 

- Natural language texts, since they support demonstrative as well as simple reading for programmers and non – programmers alike, are known to become a part of the graphics. 

- There are certain substantial techniques which help in modeling the complex test cases via intuitive and graphic modeling:

1. Parallel state machines
2. Hierarchical branching state machines
3. Conditional branching
4. Re-activity
5. Signal description
6. Measured signals
7. Test step list

- Graphics hide the complexity of a test. 

- Test step lists (also known as direct definitions) constitute the lowest level of the signal description. 

- The last technique i.e., the test step list implies a certain number of predefined actions which are executed sequentially and therefore are ordered chronologically. 

- This technique also holds good for the test cases which can be described normally in a sequential manner which can be chosen from the following:

1. Channel set i.e., setting a signal
2. Ramp channel or ramp signal
3. Set parameters
4. Compare
5. Wait
6. Other conditional values like if, else if, else values and so on.

- In addition to this, these sequences can be modeled in combination with the other models. 

- Direct definition method is used for specifying the test-lets which involves an ordered list of equations and signal definition. 

- Signals can be imported via a function wizard or manual signal editor. 

- However, TPT remains exclusive for testing the reactive behavior of the embedded systems. 

What is the Difference between Bitmap Check point & Image Check point in QTP?

There are two types of major check points that are provided by the quick test professional namely:

1. Bit map check point and
2. Image check point

What is Bitmap and Image Check Point?

- The expected bit map of an object is captured using the bitmap check point while the recording process is in progress. 

- While a run session is in progress and the actual bitmap matches, a pass to the test result is returned by the expected bitmap. 

- If the above is not the case, the test is said to have failed. 

- While the recording is in progress, it is better to insert the bitmap check point rather than inserting it in the active screen. 

- Inserting the check point in the active screen would pose the problem since the possibility is that the active screen may or may not have the latest bitmap updates and making changes to the screen at that time can cause the whole program to fail. 

- To know the difference in the scripts before and after inserting a check point, simply disable a button and run the script. 

- Then insert the check point, enable the button and run the script again. You would be able to see the difference for yourself. 

- For inserting the bitmap check point in to the test script open up a blank test in quick test professional and then open the application that you want to check and start recording. 

- You will get a record and run settings window, select the tab titled “windows application”, then “record and run test on any windows based application” and hit OK. 

- Go to the check point’s option in the insert menu and select the bitmap check point option and insert it where you want.  

- The bitmap check point properties can be changed. 

- Now when the test is run a pass in the test result is recorded by the quick test professional. 

- The basic use of the bitmap check points is in making comparisons between objects and images pixel by pixel. 

- The comparison is carried out for the following:

1. RGB color variations and
2. Total deviation in number of pixels.

- By matching the captured bitmaps one can the appearance of the elements in the application. 

- Bitmap check point has proved to be great help in checking bitmap of a full web page or an image. 

- On the other hand, an image check point cannot check the pixels and therefore it is basically employed in checking properties like source file location of a web site or web page. 

- The area of an application or a web page can be checked as a bitmap. 

- The area to be checked can be specified by selecting an object while creating a test. 

- The selected object is specified as a bitmap and then the check point can be inserted in the test. 

- This calls for a large disk space so in order to save space you have the option of saving only the selected area of the object.

- The bitmap check point also allows you to check the zooming property of the maps and they can be created for all supporting testing environments. 

- The results of the bit map check point may be affected by color settings, screen resolution and operating system but this is not so in the case of the image check points. 

- The properties of an image are verified by image check point under AUT whereas only an area of the AUT is verified as a bitmap by the bitmap checkpoint.  

How do you program tests with Test Script language (TSL)?

The tests that are created by the winrunner are composed of the statements that have been coded in a special language by the mercury interactive called Test Script Language or TSL in short form. 

- The tests created can be further enhanced by using the TSL language.

- Remember, this feature which allows the modification of the test scripts via the TSL language is not available in the winrunner runtime.

- The generation of TSL statement takes place whenever a test is recorded by the winrunner. 

- Each line of the test generated by the winrunner is called a TSL statement and is as usual followed by a semi colon like in many other programming languages.

- Each and every TSL statement consists of some user input like mouse click or input from key board to be fed to the software system or application that is to be tested. 

- The length of the TSL statement varies from line to line of the test script. 

- TSL can be thought of more like the C programming language that has been designed for the creation of the test scripts. 

- Some certain specific functions like those mentioned below are combined by the TSL:

1. Variables
2. Control flow statements
3. User defined functions
4. Arrays and so on.

- A recorded script can be further enhanced just by typing the programming elements in to the winrunner test window.

- However, the TSL proves to be quite useful when compared to C because in test script language there is no need of compilation of the written code. 

- The test is just written or recorded and immediately subjected to execution. 

- Four types of functions constitute the TSL:

1. Analog functions
2. Context sensitive functions
3. Customization functions and
4. Standard functions.

How TSL can aid in the creation of tests?

 

- The tests developed using TSL are basically of descriptive nature and thus this type of programming is called the descriptive programming. 

- A logical name is assigned to an object the very moment it is added to the GUI map. 

- Once a GUI object makes its place in the GUI map, it becomes quite easy for you to add any TSL statements to it. 

- The logical name that is given to the object is as such that it gives a description of the GUI object. 

- During the execution of the tests, the objects are discovered based on their logical names itself but for the identification other property values that are stored in the map are used. 

- These logical names of the GUI objects can be further modified so that it becomes quite easy for you for the identification of the tests. 

- While programming with TSL, the statements that perform functions on objects can also be added without making a reference to the GUI map. 

- But doing that requires entering some more information regarding the description of the object so that it can be uniquely identified during the test run. 

- This is the essence of the descriptive programming using TSL. 

- While doing the programming, if you forget which values and properties of the object were to be identified you can take help of the GUI spy for viewing the current properties of the object as well as its values. 

- Stress conditions can also be created while programming with TSL which are designed for the determination of the limitation of the software system or application. 

- Stress conditions can be created by creating a loop that executes a block of TSL statements for number of times specified by the user.  

What's the use of GUI Map Editor? How do you load GUI Map Editor?

First of all, for the identification of any object, all the information related to it is learnt by the winrunner software and stored in a map called GUI map. 

GUI Map

- The GUI map is an extremely important asset to the winrunner for the identification of the objects. 

- During the running of the tests the location and identification of the objects is done via this GUI map only. 

- The GUI is constituted of the descriptions of the objects that are to be identified. 

- These descriptions of the objects are read by the winrunner and the objects corresponding to the same description are matched up.

- You can even have a comprehensive view of the objects that constitute your software system or application.

- The final GUI map is actually composed of many more small GUI map files. 

In this article we are going to learn about the use of the GUI map 

editor and how it can be loaded.

GUI Map Editor

- The contents of a GUI map can be easily viewed with the help of GUI map editor. 

- You can view either the contents of the whole GUI map or the contents of those small individual GUI map files. 

- The grouping the GUI objects takes place according to the window in which they reside in the software system or application. 

- With the help of GUI map editor you can edit your GUI map at any time manually.

How do you load GUI Map Editor?

- For loading the GUI map editor you just need to go to the tools menu and select GUI map editor option. 

- The GUI map editor offers you two types of views both of which enable you to glance the contents of the either of those mentioned below:

1. The individual GUI map files or
2. The entire GUI map

- You can even load the two GUI map files simultaneously in GUI map editor.

- For viewing the contents of two individual GUI map files simultaneously, you just need to expand the GUI map editor. 

- With such a feature you are able to easily move or copy the descriptions of the objects between the files. 

- The window objects column in the GUI map editor displays all the windows and objects that are present in that particular GUI map. 

- The objects which appear in the windows are indented. 

- The GUI map editor also comes with the option of viewing the physical description of the object or window that has been selected by the user. 

- For viewing the contents of the individual GUI map files you need to go to the view menu and select the option “GUI files”. 

- The GUI file drop box lists all the GUI map files that are open at that time.

- In the GUI map editor, the display of the objects is of tree type under the icon and name of the window in which they reside or appear. 

- Double clicking the window icon gives you the view of the objects appearing in it.

- For a concurrent view of all the objects in the tree, the objects tree can be expanded by choosing the “expand objects tree” option from the view menu.

- For again going back to the windows only view, you can select the “collapse objects tree” option from the view menu.

- The display of the physical description of the contents of a single GUI map file is automatic but to view the physical description for the entire GUI map you need to select the show physical description check box. 

- However, you should be careful with the point that if the logical name of an object has been modified in the GUI map, then it has been modified in the test script as well so that there is no problem for the winrunner to locate that object.  

How do you check GUI objects? How do you check a bitmap? (In Winrunner)

In this article we discuss about how one can check the GUI objects and also how to check a bitmap. 

How to check GUI objects and Bitmap

- Checking of the GUI objects is possible by the addition of the GUI check points in the test scripts.

- Once these GUI check points have been introduced in to the test scripts, the behavior of the gui objects can be compared in different versions of the same software system or application and defects in them can also be detected. 

- For checking the GUI objects you just need to point the GUI objects that you want to examine and choose those properties which you want to be tested. 

- With Winrunner, you also have the option of checking the default properties as recommended by the winrunner itself or you can even go for the specific properties that you want to check. 

- Information regarding all the GUI objects and their corresponding properties is saved in the form of a check list. 

- The current property values are then captured by the winrunner for the GUI objects and are saved as the expected results. 

- While checking of the GUI objects, an automatic insertion of a GUI check point takes place. 

- The inserted check point appears as either of the following:

1. Win_check_gui statement or
2. Obj_check_gui statement

- A GUI check point consists of two parts one of which contains the check list listing all the objects and properties that are to be checked and the second part consists of the expected results which contains the captured property values.

- When a test is executed, the comparison of the current state of the GUI object with the expected results takes place in the software system or application that is being tested. 

- If in case, there is no matching between the current values and the expected results than that particular check point is said to have failed. 

- A GUI check point can be made a part of a loop also. 

- If you run a GUI check point in a loop then the results obtained are displayed as separate entries for every iteration of the loop. 

- All these results can be viewed in the test results window. 

- In some cases, it may also happen that the few of the GUI objects might not be there in the GUI map. 

- There is no need to worry since those GUI objects are added to a GUI map file that is temporary. 

- A GUI check point can be created either by using a regular expression on an edit object or by using a static text object having a varying name. 

- A built in support in winrunner is provided for the following:

1. Active X control
2. Visual basic
3. Power builder application development environments and so on.

- Whenever the appropriate add in support is loaded, the controls are recognized by the winrunner and are treated as standard GUI objects. 

- The GUI check points can be created for these GUI objects in a similar way the check points are created for the standard GUI objects. 

- GUI check points that could check the properties and contents of a table can also be created. 

However one should be careful about the point that the winrunner does not supports the GUI check points that were created in Xrunner. - Winrunner can be instructed to capture a bitmap of the window whenever some check point fails.

- These captured bitmaps are saved along with the test results in the test results folder whenever a test is run. 

- You can create check points either for testing single property of many objects or just for testing a single object. 

What are the two GUI Map modes available in WinRunner?

When the winrunner executes a test it actually simulates a real world human user by the means of carrying out user like interactions such as clicking GUI objects, moving cursor over the application and entering some input from the keyboard. 

- In order to work with an application, the winrunner needs to learn the graphical user interface of the application just as a human user would do. 

- This learning of the GUI is achieved by the winrunner by learning the GUI objects present in the application along with their properties. 

- The descriptions thus learnt are stored in the GUI map.

But before your winrunner starts learning about the GUI of your software system or application you must decide in what way you need to organize all your GUI map files. 

Winrunner offers two modes for organizing your GUI map files namely:

1. GUI map file per test mode
2. Global GUI map file mode

In this article we take up the talk regarding the gui map file per test mode and global gui map file mode in detail one by one. 

About Global GUI Map File Mode

- This is the default mode in winrunner. 

- This mode is quite advance from the second mode i.e., the GUI map file per test mode so it is recommended that this mode should be used by the much experienced testers. 

- Further, you must take care that you use this mode only when the tests have been created with winrunner versions 6.02 and earlier. 

- Organizing the tests in to groups while designing the test suites is perhaps the most efficient way of working with the winrunner. 

- Same GUI objects in the application should be tested by each test in the group. 

- The information regarding the GUI objects referred by those tests is stored in a common repository. 

- Whenever you have a change to be made in the object you just have to give an update of this in the GUI map as well as in the test scripts instead of making changes to each and every test. 

- It may happen in some cases that even after your winrunner has learned all about the GUI of your software system or application it may not show all the objects in its comprehensive list. 

- Therefore, it is important that the winrunner learns every about the GUI of your software system or application in a comprehensive way.

About GUI Map File per Test Mode

- This mode is especially for the ones who are new at using the winrunner since it is quite easy to be used as you do not need to know how actually the GUI map files are created, saved or loaded. 

- However, care should be taken that the tests created on winrunner versions 7.0 and above as they can only be handled using this mode.

- The plus point of this mode is that your time is saved since you don’t have to teach the winrunner regarding the GUI of your software system or application. 

- In this mode, every time you create a new test, the winrunner creates a new GUI map file.

- Similarly, whenever you save a test, the winrunner saves the test scripts.

- Whenever you open a test, the winrunner opens up the corresponding GUI map file. 

However there are some minus points also! 

- There are some features that do not work under this GUI map file per test mode.

1. The rapid test script wizard.
2. Option for reloading the temporary GUI map file.
3. Mytntt startup becomes unable to load the GUI map files.
4. Compiled modules become unable to load the GUI map files.

What is meant by Graphical User Interface (GUI) Spy?

Whenever a test is being executed by the winrunner, it is actually simulating a real world human user by the virtue of carrying out the user events like entering some input from the key board, hovering the mouse cursor over the entire application, pointing to some GUI object, clicking on some GUI object and so on. 

Just as a human user needs to learn about the graphical user interface of the software system or application, similarly it is mandatory for the winrunner to learn everything regarding the graphical user interface of the software system or application so that the application can be worked up on. 

Thus, Winrunner achieves by gaining information about the GUI objects along with their properties and side by side stores the descriptions of these objects in the GUI map file.

Later on you may require viewing the properties of the objects and how they are identified by the winrunner. 

"GUI spy is such a software that makes it possible to view the properties of all the objects as well as how the winrunner identifies them".

While learning the description of a GUI object, winrunner takes in to consideration the physical properties of the object.

Each GUI object may have many physical properties like those mentioned below:

1. Label
2. Class
3. Width
4. Handle
5. Height
6. Enabled
7. Disabled and so on

What is a GUI Spy?

- Though a GUI object may have several properties, but only a few of them are learned by the winrunner and these properties are such that can distinguish that particular object from the rest of the objects present in the software system or application. 

- It happens often that we have to view the properties of the GUI objects before adding some new object to the application or before we create a GUI map file. 

- GUI spy provides you with the properties of the GUI objects on your desk top.

- The GUI spy comes with a pointer called spy pointer which is just like a mouse pointer. 

- You point to any object with it and its properties are displayed by the GUI spy. 

- Not only the properties, you can even spy on the values of those objects and those values are displayed in the GUI spy dialogue box.

- Among all the displayed properties, you can choose to view either all the properties or a few selected of them that have been learnt by the winrunner. 

- The GUI spy window can be re-sized for viewing all of the contents at once. 

- This set of properties that has been learnt by the winrunner can be modified for specific class of objects with the help of the GUI map configuration dialogue box. 

- It is by default that the recorded tabs are displayed by the GUI spy. 

- This feature helps us in viewing all the properties of the standard GUI objects. - For viewing the properties of the standard windows and objects you need to click on the tab entitled “all standard”.

- For viewing all the methods as well as properties of the active controls, click on the tab entitled “activeX”. 

- However, this feature will work only if the ActiveX add in has been installed and fully loaded. 

- While using the GUI spy you can even hide the winrunner screen by selecting the option hide winrunner and you continue spying on the objects. 

- You need to just click on the spy option and point the pointer to an object in the window. 

- The object gets highlighted and the following are displayed in the appropriate fields:

1. Active window name
2. Object name and
3. Object description