35+ [REAL-TIME] WinRunner Interview Questions and Answers

Last updated on 04th Jul 2020, Blog, Interview Questions

WinRunner was a software testing tool developed by Mercury Interactive, used primarily for automated functional testing of GUI applications. It allowed testers to create scripts that simulated user interactions with applications, verifying functionality and identifying defects. WinRunner’s capabilities included GUI object recognition, data-driven testing, and integration with test management tools, making it a popular choice for ensuring software quality in various industries.

1. What is WinRunner?

Ans:

An automated and valuable tool for GUI testing is HP’s WinRunner.  With this tool, users may test scripts and record and playback UI interactions. It is frequently employed to find any flaws in corporate procedures. STM: As part of the Software Development Life Cycle’s Test phase, WinRunner is a functional testing tool used to work on a set of tests that are used to collaborate with HP QuickTest Professional and to serve as a supporting component for the quality assurance process.

2. Explain the WinRunner testing procedure.

Ans:

• WinRunner can be used to identify GUI items used in the application that is being tested by creating a GUI Map file.
• There are two ways to create tests: recording, programming, or combining the two.
• We may make sure that tests are conducted consistently by running test cases in debug mode. 
• Test run ease of control, flexible monitoring, and breakpoints can simplify the process of identifying flaws.
• Executing test cases in verify mode to evaluate the program and contrast its data with previously collected data.

3. Indicate which language WinRunner is using.

Ans:

WinRunner uses the TSL (Test Script Language) for scripting. TSL is a proprietary language developed by Mercury Interactive, now part of Micro Focus. It is specifically designed for automated functional and regression testing. TSL is similar to C in syntax and structure, enabling testers to write detailed test scripts. This language allows for customization and control over the test execution process.

4. Give a brief description of the test scripts you wrote using WinRunner.

Ans:

Wrote test scripts using WinRunner to automate the functional testing of our web and desktop applications. These scripts included automated login, data input validation, navigation workflows, and verification of output data accuracy. I utilized WinRunner’s TSL (Test Script Language) to create robust test scenarios, incorporating checkpoints for GUI elements, database interactions, and error handling. Additionally, the scripts were designed to run in different test environments, ensuring comprehensive coverage and reliability. 

5. Describe how WinRunner evaluates test results.

Ans:

WinRunner evaluates test results by comparing the actual outcomes of the test run against the expected outcomes predefined in the test script. It generates a test report that details the results, highlighting any discrepancies or failures. The report includes information on the test execution time, any errors encountered, and specific differences between expected and actual results. Test results are categorized as pass, fail, or warning, and testers can review detailed logs to diagnose issues. 

6. Describe the various WinRunner modes that we can use to test scripts.

Ans:

• We may execute test scripts in three distinct modes with WinRunner depending on the stage of the testing.
• Verify: This option allows us to examine the application and compare it with previously collected data. The Debug mode aids in locating errors in a test script.
• Update: Using this mode, we can create a new expected results folder or make changes to the current one.

7. What does the Wrun.ini file contain?

Ans:

• Paths: Specifies the directories for various runtime components.
• Settings: Defines runtime behavior and application preferences.
• Environment Variables: Sets necessary system variables.
• Initialization Commands: Commands executed during startup.
• Logging Configuration: Settings for logging runtime activities.
• Resource Allocation: Defines memory and resource limits for the application.

8. Describe how to utilize the set_window command.

Ans:

The focus is set via set_window in any window. The purpose of this command is to focus on the designated window prior to running any test scripts. The WebDriver API’s Set Window Rect command modifies the size and location of the operating system window linked to the active window. The command sets the value of the Get Window Rect function, whose return object you can supply as the payload of this command directly.

9. List a few situations in which WinRunner is unable to recognize GUI objects.

Ans:

• WinRunner might not be able to recognize GUI items in a few different circumstances.
• Dynamic Object Properties: Dynamic properties, like dynamic IDs or classes, are those of GUI objects that vary dynamically during runtime.
• Custom Controls: Describes the situation where an application makes use of third-party or custom controls that WinRunner’s integrated object repository is unable to identify.
• For instance, specially created input fields or buttons for a web application

10. Distinguish between GUI Maps and GUI Map Files.

Ans:

Feature	GUI Maps	GUI Map Files
Purpose	Stores information about GUI objects and their properties.	Stores collections of GUI Maps.
Content	Contains object definitions and their recognition properties.	Can contain one or more GUI Maps.
Usage	Each GUI Map is associated with a single test script or module.	Can be shared across multiple test scripts or modules.
Management	Managed within WinRunner’s GUI Map Editor.	Managed as individual files (.gui or .guit files) outside of test scripts.
Flexibility	Limited flexibility in sharing across different scripts.	Allows for easier reuse and sharing among multiple scripts.

11. What does any object’s logical name mean?

Ans:

The script’s object references are made more accessible by the logical name. Rather than utilizing intricate and comprehensive physical descriptions, testers can use easily readable names.

• Example: The sensible name can be “UsernameField” rather than a lengthy and complicated one like “input[@name=’username’].”
• Continuity: Consistency across the test script is ensured by names that make sense. Only the mapping, not the entire script, needs to be updated whenever an object’s physical properties change.
• Example: The logical name “SubmitButton” will change if a button’s ID goes from “btnSubmit1” to “btnSubmit2”.

12. How should GUI Map files be arranged?

Ans:

• Categorize Elements: Group related elements by screens, modules, or functionalities.
• Naming Conventions: Use consistent and descriptive names for easy identification.
• Hierarchy Structure: Create a folder hierarchy reflecting the application structure.
• Version Control: Maintain versions to track changes and ensure consistency.
• Documentation: Include comments and documentation for clarity and maintenance.

13. How is the GUI Map loaded?

Ans:

The GUI Map is loaded in software testing tools like QTP (QuickTest Professional) by recording user actions on the application under test. This process involves capturing the properties of the GUI elements interacted with. The recorded objects and their properties are stored in the GUI Map, allowing the tool to recognize and interact with these elements during test execution. The GUI Map can be manually edited to include additional properties or objects.

14. Can the GUI Map file be unloaded? If so, how?

Ans:

• Open the application where the GUI Map file is loaded.
• Navigate to the GUI Map Editor.
• Select the GUI Map file you want to unload.
• Click on the “File” menu.
• Choose “Unload” from the options.
• Confirm the action to unload the GUI Map file.

15. Describe GUI Spy.

Ans:

GUI Spy is a tool for inspecting graphical user interface elements within applications. It helps developers and testers identify UI components such as buttons, text fields, and windows. GUI Spy provides detailed information about these elements, including properties, events, and hierarchy, which is crucial for debugging and automation scripting. It’s commonly used in software development to ensure UI consistency and functionality across different platforms and versions.

16. Let me know the GUI Map file’s extension.

Ans:

The GUI Map file extension commonly used for storing graphical user interface (GUI) mappings is “.gui.” These files are essential for automated testing frameworks and contain detailed mappings of UI elements such as buttons, fields, and windows. They enable seamless interaction between test scripts and the application’s GUI, ensuring accurate and reliable automated testing processes.

17. Is it possible to change an object’s logical name? If so, how?

Ans:

WinRunner often assigns logical names. Typically, they are the object’s text labels. On the other hand, using the GUI Map editor, it is possible to alter any object’s logical name. Once, we cannot change the name of an entity schema. The object’s name. When punctuation is missing from a sentence, such as commas or brackets, it is a common form of error.

18. Explain the different recording modes.

Ans:

• Mono: Records audio from a single source, suitable for vocals or single instruments.
• Stereo: Captures audio from two channels, providing a spatial dimension for a richer sound experience.
• Multi-track: Allows recording of multiple audio sources separately, facilitating individual editing and mixing.
• Omni-directional: Records sound from all directions, helpful for capturing ambient noise or group discussions.

19. In the event of a missing object label, what is the logical name of the GUI object?

Ans:

If an item lacks a label or descriptive text, its connected context often serves as its logical name. This error frequently occurs when essential punctuation markers like commas or brackets are omitted from a statement. In such cases, you can resolve it by utilizing the `default(object)` method in C#. This approach instructs the compiler to insert `null,` which is the default value for objects, ensuring clarity and correctness in your code’s logic and structure.

20. List the disadvantages of utilizing startup scripts to load GUI Map files.

Ans:

• Increased RAM Usage: When an application relies on a single large GUI Map file, it can consume significant RAM resources, mainly if the GUI Map file contains extensive graphical user interface (GUI) data.
• Time-Consuming Updates: Updating and reloading the GUI Map file can be time-consuming, particularly when new objects or changes are added. If not managed efficiently, this process may lead to delays in application startup or performance degradation.
• Maintenance Overhead: Managing a single large GUI Map file requires careful maintenance. Any updates or modifications to the GUI elements often necessitate reloading the entire File, impacting operational efficiency.

21. Explain what the Temp GUI Map File is meant to accomplish.

Ans:

The Temp GUI Map File is designed to store temporary data during GUI testing processes. It helps map GUI objects to the test scripts and facilitates automated testing by providing a repository of GUI elements and their properties. This File aids in maintaining consistency and efficiency in test automation efforts, ensuring accurate interaction with graphical user interfaces without manual intervention.

22. How does WinRunner recognize items within the application?

Ans:

To recognize items within the application, WinRunner relies on the GUI Map file, which acts as a repository of object definitions and their attributes. During test execution, WinRunner utilizes the GUI map to locate and interact with objects. It reads the description of each object stored in the GUI map and compares these attributes with the actual objects in the application under test. This process enables WinRunner to accurately identify and manipulate GUI elements as specified in the test scripts, ensuring precise and reliable test execution.

23. Indicate which command was used to locate the resolution settings.

obtain_screen_res(x,y).

Ans:

The command used to locate the resolution settings is `obtain_screen_res(x, y).` This function retrieves the current screen resolution settings, returning the values of `x` and `y’, which represent the screen’s width and height, respectively. It is commonly used in scripts or applications that need to adapt their display or interface based on the user’s screen resolution, ensuring optimal user experience and interface responsiveness.

24. Where may we apply the regexp_msw_class and regexp_label Property?

Ans:

• The property regexp_label: It is limited to Windows usage. 
• It inserts a regular expression in private into the label description of a window.
• All windows and object class objects must have the regexp_msw_class property. It inserts a regular expression into the MSW_class of an object. 
• Both properties are used to deal with window labels that are continually changing.

25. Discuss the Compile Module’s shortcomings.

Ans:

There are some disadvantages to using the Compile Module in WinRunner, which are listed below. It is not possible to add checkpoints to the compile module Moreover, Sync Points cannot be positioned. It cannot be carried out. Because of its static nature, modifications made during development must be fully recompiled in order to be implemented, which might take a long time for more significant projects.

26. Explain what the Boundary test is.

Ans:

A boundary test is a type of test used to verify how well a program responds to severe inputs. It guarantees that the software can process extreme inputs and generate appropriate outputs at both extremes. Software engineers frequently utilize boundary testing, a black-box testing approach, to examine faults at the boundaries or extreme ends of a particular input domain.

27. How do you provide a command that displays the data from the status bar?

Ans:

• Right-click on the status bar.
• Select the desired fields to display.
• Customize the order and visibility of fields.
• Click OK to apply changes.
• The status bar now shows selected data.
• Hover over fields for detailed information.

28. Is there a way to deal with WinRunner’s unexpected errors?

Ans:

WinRunner offers exception handling so that users may recognize and respond to unexpected situations. WinRunner is compatible with the following exception types.

• Pop-up Exceptions: to identify and facilitate a window’s appearance
• Object Exceptions: to find and handle any modifications to a GUI Object’s property.
• TSL Exceptions: to identify and control TSL methods that return particular error codes.
• Web Exceptions: In the event that the web test add-in is loaded in the application, to identify and address any faults in the website Using UAE Exceptions, one can handle exceptions that are divided by null or zero pointers.

29. How do you run the test scripts?

Ans:

During testing in Verify mode, WinRunner evaluates your application by comparing its current state against previously gathered expected data whenever it encounters a checkpoint in the test script. If discrepancies are detected, WinRunner records these differences as actual results. This process allows testers to identify deviations from expected behavior, facilitating thorough validation and ensuring the reliability of the tested application.

30. Use WinRunner to Define Data Parameterization

Ans:

WinRunner features a feature called Data Parameterization that allows data to be recorded numerous times. WinRunner uses an iterative loop to process data that is written more than once. Test script sizes can also be lowered because of the loop. When values vary after every test run, this procedure is frequently employed. Testing the sales order application, for instance, where the order number is increased by one. The ideal approach for this kind of application is data parameterization.

31. Describe the WinRunner testing procedure.

Ans:

• Creation of the GUI Map File: This allows the WinRunner test to use the GUI object. It is creating a test script by programming, recording, or combining both methods.
• Debugging Test: To fix issues in the test script, run the tests in debug mode.
• Run Tests: To test the program, run tests in Verify mode.
• View Results: Indicates whether the test was successful or unsuccessful.
• Submit Defects: If the Test run state fails, we can submit defects immediately from the Test Results panel.

32. What does the GUI map include?

Ans:

The element identification properties that were taken from the application during recording are stored in the GUI Map File. An ID will be created for every element, and the application uses this ID to identify objects. The GUI Map file stores the application’s parts. Each object in the GUI Map file has two properties that are used for identification: The object’s physical name The object’s logical name

33. How can the scripts be debugged?

Ans:

To debug scripts effectively, start by reviewing error messages for clues, utilize logging to track program flow, employ breakpoints to pause execution for inspection, utilize print statements for variable tracking, test code in smaller segments for isolated debugging, and consider using debugging tools like IDEs or command-line debuggers for more complex issues.

34. How does WinRunner identify items within the program?

Ans:

WinRunner uses the item’s identification characteristics, which are stored in the GUI Map file, to identify the object. These characteristics are:

• Physical name: such as “OK” for an OK button or “save” for a save dialog box
• Logical name: WinRunner assigns to an item when it adds it to the repository. WinRunner often uses the text that is associated with the object as the logical name.

35. How do you report the flaws and examine the results?

Ans:

WinRunner automatically generates the results in a report following the execution of the test script. The report includes a summary of every action that took place during the test script’s execution, including error messages and checkpoints. To determine whether the expected and actual outcomes match, the tester reviewed the reports and findings. If neither of them matches, the issue is considered a bug and is closed in the bug report. By combining the mail option with WinRunner, you may email this issue report straight from the WinRunner interface to the development team.

36. In WinRunner, what is the logical name?

Ans:

In WinRunner, the logical name refers to the name assigned to an object in the GUI map. This allows scripts to identify and interact with the object regardless of its physical properties. It acts as a unique identifier, abstracting details like object properties and enabling script flexibility. Logical names are crucial for maintaining scripts across application changes, as they decouple script logic from UI changes. They ensure scripts remain robust by providing a consistent reference to UI elements.

37. How do you see the GUI map’s contents?

Ans:

• WinRunner provides the GUI Map Editor tool, which allows us to examine and modify the GUI MAP’s content. 
• The GUI Editor shows the content kept in the GUI Map. The WinRunner Tools Menu offers a GUI Map Editor that we may launch. 
• When recording, the GUI Map Editor shows the different GUI Map files and the items that have been learned into them, together with their logical name and physical description of the written work.

38. Why do WinRunner Add-Ins need to be loaded?

Ans:

Add-Ins are small applications or files that can be installed on a computer to extend its functionality within WinRunner. The primary goals of loading Add-Ins into WinRunner include enhancing system capabilities by integrating additional features, improving the communication interface for smoother interaction, optimizing visual quality for better user experience, and ensuring that only necessary functions are loaded into memory, thereby streamlining script execution efficiency.

39. Why does WinRunner not recognize a GUI object?

Ans:

The following are the reasons why WinRunner is unable to identify a GUI object: When something’s logical and physical names do not match the GUI object in the repository. The item in question is not a typical Windows object. The WinRunner version is not compatible with this browser. An incompatible browser prevents the GUI MAP from adding any objects, which makes it impossible to identify objects.

40. What kinds of WinRunner exceptions are available?

Ans:

• Pop-Up Exceptions: it manages pop-ups that appear out of the blue while the program is running.
• TSL Exceptions: it reacts to particular error codes that WinRunner returns.
• Object Exceptions: Manages unforeseen modifications made to the objects within an AUT.
• UAE Exceptions: Applying the method to handle scenarios such as division by zero or null pointers. You may find these exceptions under Tools Menu -> Exception Handling -> Choose the 41st Exception Type.

41. How many WinRunner recording methods are there?

Ans:

• Context-sensitive recording: Records user actions based on object recognition, allowing for flexible scripting.
• Analog recording: Captures mouse and keyboard actions as analog signals, helpful in precisely mimicking human interactions.
• Low-level recording: Records at the GUI level, capturing exact X and Y coordinates for actions like mouse clicks and keystrokes. These methods cater to different testing needs, ensuring comprehensive test coverage and flexibility in script creation.

42. How can I use WinRunner to test a database?

Ans:

To effectively test a database with WinRunner, start by scripting test cases that establish a connection to the database. Next, execute SQL queries to retrieve data and validate the results against expected outcomes. Verify database integrity by testing constraints, triggers, and stored procedures. Use WinRunner’s transaction handling capabilities to ensure data consistency and rollback changes after testing.

43. Describe WinRunner’s data parameterization.

Ans:

WinRunner’s data parameterization allows testers to vary input values during test execution without changing the script. It uses data files (like Excel sheets or databases) to provide different inputs dynamically. This feature enhances test coverage by testing with multiple data sets efficiently. Parameterization in WinRunner helps simulate real-world scenarios and ensures thorough testing of application functionality across various data conditions, enhancing test reliability and effectiveness.

44. When are Verify, Debug, and Update Modes used?

Ans:

• Verify: Utilise to contrast the anticipated answer with the actual outcome. A record of the discrepancy between the expected and actual results is made and stored as a verification result.
• Debug: Use the debug mode to find errors in a test script. The debug mode and verify mode are identical; however, the only things that separate these two are that only one set of debug results is stored, and that debug results are always saved in the debug folder.
• Update mode: This is utilized when we wish to modify or update the anticipated outcome.

45. How can you use WinRunner to capture an object manually?

Ans:

By manually copying the description of one object and making the necessary edits, we can manually add an object to a GUI map file. To manually include an item in a map file for a GUI. We take the following actions:

• To access the GUI Map Editor, select Tools > GUI Map Editor.
• Select GUI Files under View.
• Select File> Open to launch the relevant GUI map file.
• Decide which item will serve as the foundation for modification.
• Select “Add to the Add dialog box will open.

46. In WinRunner, what is a data-driven test?

Ans:

Data-driven testing is a type of automation testing where input or output values are tested by reading them from data files. When the values vary over time, they are executed. Excel files, CSV files, and data pools are a few examples of the various data files. Afterward, the information is entered into variables in scripts that are manually or recorded. We use WinRunner’s parameterization method to drive the test using data. When doing a data-driven test, we take two additional actions: Making the test data-driven by means of conversion and making a table of corresponding data.

47. How can TestDirector automated scripts be integrated?

Ans:

We can save tests directly to your TestDirector in WinRunner. Database. We have the option to specify whether our script is automatic or manual when we create a test case using TestDirector. TestDirector generates a script skeleton that can be altered when a script is automated. TestDirector keeps track of tests and defects inside a project. We are able to establish TestDirector projects in Microsoft SQL, Oracle, Sybase, and Access. These projects hold data on the ongoing testing project, including test results, test runs, and issues that have been reported.

48. How do GUI map files and GUI maps differ from one another?

Ans:

The group on the GUI map is of a single GUI map file or several. There are two ways we can arrange GUI map files:

• Global GUI Map file: one GUI Map file that contains all of the application’s data.
• GUI Map File per Test: When a test is created, WinRunner automatically generates a GUI Map file. The GUI Map file is a collection of windows and GUI objects that the WinRunner discovered while recording the testing script, together with the objects’ logical names and physical characteristics.

49. What distinct functions do the find and display buttons fulfill?

Ans:

• The find button is used to locate the name of the selected object, while the show button is used to display the object for the name chosen.
• Show Button to display a particular object in the program, pick it, then press the Show window button. This draws attention to the chosen object, but
• The Find button allows you to select an object. If the object is in the GUI repository when it is selected, the Button will focus on the File.

50. What is the way WinRunner handles different window labels?

Ans:

Regular expressions can be used to solve the Varying window labels problem. WinRunner can distinguish between items with different names or titles thanks to regular expressions. Regular expressions are supported in Test Script Language statements. A string is a regular expression. There’s an exclamation point after a regular expression. By utilizing special characters like a period (. ), asterisk (*), caret (^), and brackets ([ ]), we can produce the search’s parameters. The string “!hit.*,” for instance, matches both”Rohit” and”hit.”

51. Could you explain how WinRunner evaluates test results?

Ans:

WinRunner typically generates detailed test results in the Report folder following test execution. These reports comprehensively document all events throughout the test case, encompassing checkpoints, error messages, system messages, and user interactions. When discrepancies arise at checkpoint stages, it becomes essential to utilize the Test Results Window for comparing actual outcomes against expected results.

52. Could you explain how to use the set_window command?

Ans:

• The `set_window` command in Selenium WebDriver sets the dimensions (width and height) of the browser window. 
• It takes two parameters: width and height, which are integers representing the desired dimensions in pixels. 
• For example, `driver.set_window_size(1200, 800)` sets the browser window size to 1200 pixels wide and 800 pixels high. 
• This command is helpful for testing responsive designs or ensuring specific viewport dimensions for automated browser interactions.

53. Could you provide two situations in which WinRunner is unable to recognize GUI objects?

Ans:

WinRunner may struggle to recognize GUI objects with dynamically changing properties due to AJAX or JavaScript updates on web pages. Additionally, it might need help with non-standard or custom controls that do not have recognizable identifiers or properties mapped within WinRunner’s object recognition framework. These scenarios often require custom configurations or scripting workarounds to accurately identify and interact with GUI elements during automated testing processes.

54. In WinRunner, how can GUI map files be unloaded?

Ans:

• Procedures for loading the GUI map files;
• Use these techniques to unload any GUI map file (any specific file):
• GUI_Unload() or GUI_Close().You must use the GUI Close All or GUI Unload All methods to unload every GUI map file.

55. What is a GUI spy, in your opinion?

Ans:

A GUI spy is a tool used in software development and testing to inspect and interact with graphical user interfaces (GUIs) of applications. It helps developers and testers examine elements like buttons, text fields, and windows to understand their properties and behavior. By capturing details such as object hierarchy and properties, GUI spies facilitate debugging, automation scripting, and UI testing processes. They are essential for ensuring UI consistency, functionality, and performance across different platforms and devices.

56. How does WinRunner handle different window labels?

Ans:

The varying window labels problem can be solved with regular expressions. Regular expressions allow WinRunner to recognize items with different names or titles. We can use regular expressions in Test Script Language statements. A regular expression is a string. An exclamation mark follows the regular expression. We employ special characters, such as. Using a period (.), an asterisk (*), caret (^), and braces ([]), we can build search conditions. For example, “!hit.*” matches both”Rohit” and”hit. “

57. Describe two distinct kinds of recording modes.

Ans:

• Recording setting: Constant: In this setting, the recording device captures audio or video continuously without interruption until manually stopped. It’s ideal for situations where uninterrupted coverage is crucial, such as surveillance or monitoring.
• Voice-Activated Recording Mode: This mode activates the recording device only when it detects sound above a set threshold, conserving storage space and battery life. It’s commonly used in dictation devices and for recording conversations where there are significant pauses between speech.

58. Can you give an overview of checkpoints in WinRunner?

Ans:

The checkpoint is the moment at which the actual and expected data results of any test must be compared and checked. There are four sorts of checkpoints in WinRunner:

• GUI Checkpoints: Verify and ensure details about GUI items are correct. For example, the item has been crossed, or the object button is enabled.
• Text checkpoints verify graphic user interface objects’ contents.
• Checkpoints in the database ensure data accuracy.

59. Explain how WinRunner evaluates test results.

Ans:

WinRunner evaluates test results by comparing expected outcomes defined in test scripts with actual application behavior during test execution. It checks for discrepancies such as mismatches in data values, unexpected error messages, or deviations from predefined behavior. Based on these comparisons, WinRunner generates reports highlighting pass or fail status, aiding testers in identifying and addressing issues efficiently.

60. Explain how to use the set_window command.

Ans:

The `set_window` command is used in Selenium WebDriver to set the size and position of the browser window. It takes parameters for width, height, and optional x and y coordinates. For example, `driver.set_window(size=(800, 600), position=(0, 0))` sets the window size to 800×600 pixels and positions it at the top-left corner of the screen. This command helps in controlling the viewport for testing or automation purposes, ensuring consistent and predictable browser behavior across different environments.

61. Give any two circumstances in which WinRunner is unable to identify GUI objects.

Ans:

• Dynamic or Changing Object Properties: When GUI objects have dynamically changing properties such as names, labels, or positions, WinRunner may struggle to identify them consistently across different executions.
• Non-Standard or Custom Controls: WinRunner relies on standard object recognition methods for common GUI controls. If an application uses non-standard or custom controls that WinRunner does not support natively, it may fail to recognize or interact with these objects effectively.

62. How can I unload GUI map files in WinRunner?

Ans:

To unload GUI map files in WinRunner, you can follow a couple of methods. In the GUI Map Editor, navigate to the GUI map file you wish to unload, right-click on it, and select the option “Unload.” This manual approach allows testers to manage and optimize resources effectively during testing sessions. Alternatively, for automated processes or scripting needs, WinRunner provides the unload function. This function allows you to programmatically unload specific GUI map files from within your test scripts.

63. What do you mean by “GUI spy”?

Ans:

“GUI spy” typically refers to a tool or software used in graphical user interface (GUI) testing to inspect and gather information about GUI elements. It helps testers or developers analyze and interact with elements like buttons, menus, and windows during the testing process. This tool is essential for identifying properties, attributes, and behaviors of GUI components, aiding in test automation, and ensuring the functionality and usability of software applications across different platforms and environments.

64. How do I manage GUI map files?

Ans:

• Managing GUI map files involves organizing them by application module or screen and ensuring each File corresponds to specific UI elements. 
• Regularly updating and versioning these files helps track changes and maintain consistency across updates. 
• Utilizing naming conventions and clear documentation simplifies navigation and understanding. 
• Testing GUI maps thoroughly after updates ensures accuracy and functionality, optimizing UI interaction.

65. Explain the two different sorts of recording modes.

Ans:

In Salesforce, there are two primary recording modes: Insert and Edit. Insert mode allows users to create new records by filling in required fields. Edit mode enables users to modify existing records by updating their field values. These modes streamline data management, ensuring accurate and efficient record creation and editing within Salesforce’s interface.

66. How do you see the contents of the GUI map?

Ans:

WinRunner provides the GUI Map Editor tool, which allows us to edit and see the content of the GUI MAP. The GUI Editor is used to display content saved in the GUI Map. The GUI Map Editor can be launched from WinRunner’s Tools menu. The different GUI Map files are shown in the GUI Map Editor, and the items learned in them are created with their logical names and physical descriptions while the script is being recorded.

67. Where may we use the regexp_label and regexp_msw_class properties?

Ans:

The `regexp_label` property in ServiceNow is used to define labels for a regular expression pattern that can be reused across multiple configurations, such as catalog items or email notifications. It allows for consistent labeling and easier maintenance of regex patterns. The `regexp_msw_class` property is utilized to assign a regular expression pattern to a particular record within a table, enabling dynamic validation or formatting of data based on predefined regex rules. This property ensures data integrity and consistency by enforcing pattern-based validation at the database level.

68. Is there any method to encounter unexpected errors in WinRunner?

Ans:

WinRunner uses five sorts of exceptions:

• Pop-up exceptions
• Object Exceptions
• TSL exclusions.
• Web Exceptions
• UAE exceptions

69. What are the different testing stages utilized in Winrunner?

Ans:

• Test Planning: Defining the scope, objectives, and strategies for testing.
• Test Script Creation: Developing automated test scripts based on test cases.
• Test Execution: Running the computerized scripts to validate application functionality.
• Defect Reporting: Documenting and reporting any issues or bugs found during testing.
• Regression Testing: Re-running tests to ensure new code changes haven’t adversely affected existing functionality.

70. Can you tell me about the test scripts you made in WinRunner?

Ans:

WinRunner utilizes Mercury Interactive’s Test Script Language (TSL), enabling the modification of previously recorded test scripts. This flexibility is achieved through the integration of programming elements, TSL features, and function generators. As a visual programming tool, WinRunner empowers testers to enhance and customize their automated testing processes by leveraging its scripting capabilities.

71. What are the multiple modes in which we can test scripts in WinRunner?

Ans:

• Verify -> This testing mode is used to evaluate the various apps and compare them to existing data.
• Debug -> This testing option allows users to identify multiple flaws before running test scripts.
• Update -> This testing method allows the user to alter test results or create a new result expected folder.

72. What kinds of exceptions are possible in WinRunner?

Ans:

• Pop-Up Exceptions: it handles any unexpected pop-ups that appear during execution.
• TSL Exceptions: it responds to specific error codes issued by Winrunner.
• Object Exceptions: Handles any unforeseen changes to the objects in AUT.
• UAE Exceptions: Handling scenarios like division by zero or null pointers with the function.

73. How do you examine test results in WinRunner and report defects?

Ans:

When you conclude a test with WinRunner, the results appear in a report format. The report includes general information about the test run, such as the date, operator mode, and total run time. In addition, the report contains all of the critical events that occurred throughout the run, such as checkpoints, error messages, system messages, and user messages. Mismatches can be identified in the report panel by comparing the actual and projected results. If a test run fails, you can report it immediately from the Test Results panel if you find a flaw in the application being tested. 

74. Can you describe any two circumstances in which WinRunner is unable to identify GUI objects?

Ans:

WinRunner may fail to identify GUI objects due to dynamic attributes that change each time the application is run, such as dynamically generated object names or IDs. Another common scenario is when objects are embedded within non-standard controls or custom controls that WinRunner does not support out-of-the-box. These situations often require custom programming or scripting within WinRunner to identify and interact with these objects correctly during automated testing.

75. What is the purpose of the Test Director testing tool?

Ans:

TestDirector is Mercury Interactive’s software test management application. It enables quality assurance workers to plan and coordinate the testing procedure. TestDirector allows you to create a database of manual and automated tests, design test cycles, run tests, and report and track failures. Additionally, you may create graphs and reports to monitor the progress of test planning, execution, and defect tracking prior to a product release.

76. How many recording methods are there in WinRunner?

Ans:

• Context Sensitive: Context-sensitive mode records actions made in terms of GUI elements such as windows and buttons on the application being tested. In this recording mode, the object’s location on the screen has no influence. When we conduct an operation on the application being tested, we generate a script known as Test Script Language (TSL). 
• Analog Context Sensitive: Analog recording mode allows us to record mouse clicks and movement. It is used when the application window’s position changes. When the test script runs, WinRunner retraces the mouse movements. We use Analog recording mode when mouse movement is critical, such as when testing a drawing application or verifying digital signatures.

77. Explain WinRunner’s data parameterization.

Ans:

It is the process of replacing recorded values with variables containing various values that can be used during script execution. It also decreases the size of the scripts. Parameterization is utilized when the values and labels of the window change with every execution, as we wish. Test the application where the order number is involved, which is always incremented by one. Then, we employ data parameterization.

78. When do you use Verify, Debug, and Update Modes?

Ans:

• Verify: Used to compare the actual and predicted responses. If the actual result differs from the intended outcome, it is recorded and preserved as a verification result.
• Debug: Use the Debug mode to help you find flaws in test scripts. The verify and debug modes are identical, with the exception that debug results are always saved in the debug folder, and only one set of debug results is stored.
• Update mode: It is used to update or Change the intended outcome.

79. Define Conditional Statements and Loops in Winrunner.

Ans:

In WinRunner, conditional statements are used to execute code based on specified conditions, like in other programming languages. They typically include if, else, and else if constructs to control the flow of execution based on the evaluation of Boolean expressions. Loops, such as for and while loops, Permit the repeated execution of a programming block. Until a condition is met or for a specified number of iterations.

80. What is the reason for loading WinRunner Add-Ins?

Ans:

• Add-ins are little programs or files that can be added to your computer in order to Enhance the system’s capabilities. The purposes of loading Add-Ins into WinRunner are as follows:
• Increase the system’s capability.
• To increase graphic quality and communication interface.
• To load a specific function into memory.
• Excess just functions essential for script execution.

81. In WinRunner, how are mistakes and exceptions handled?

Ans:

• Manager of Recovery: With WinRunner’s Recovery Manager, you can create recovery scenarios to address unforeseen circumstances or mistakes that arise while running tests. The steps to be taken and the circumstances that set off the recovery scenario are both customizable.
• Applying res_test_end Callback: At the conclusion of a test run, WinRunner offers a callback function called res_test_end. This can be utilized for any last-minute error reporting or cleanup tasks.

82. Define Data Parameterization.

Ans:

Data parameterization is the process of replacing recorded data with variables that hold a variety of values, which are then used during the script’s execution. It also reduces the script’s size. The process of data parameterization occurs when the values change after each test is run; it is commonly used. For example, we’d like to test a sales order application in which the application number grows by one. The data parameterization procedure is best suited for this type of testing.

83. Define a virtual object in WinRunner.

Ans:

A virtual object in WinRunner instructs the tool to treat any bitmap within a window as a graphical user interface (GUI) object. This capability allows WinRunner to interact with graphical elements that may not be standard controls recognized by default. By observing the behavior and properties of a bitmap within an application, virtual objects can be configured to represent various GUI components such as push buttons, lists, tables, and checkboxes. 

84. What are the disadvantages of importing GUI Map files using Startup scripts?

Ans:

• Importing GUI Map files using Startup scripts can lead to dependencies on specific file paths and configurations, making maintenance and portability challenging. 
• It may also increase startup time due to additional file processing overhead. Moreover, changes to GUI Map files might require script modifications, impacting agility. 
• Security risks can arise if paths are hardcoded or if sensitive information is exposed. 
• Lastly, troubleshooting issues related to GUI Map imports during startup can be complex, affecting overall system reliability and performance.

85. How do you incorporate automated scripts from TestDirector?

Ans:

When creating a test script with WinRunner and saving it directly to the TestDirector database, TestDirector will indeed make a framework or structure for the script. This skeleton can serve as a foundational template that you can later customize to suit specific application functionalities and test scenarios. This approach streamlines the initial setup process by providing a starting point that aligns with your automation goals, allowing for more accessible adaptation and enhancement as testing requirements evolve.

86. Can you explain the WinRunner testing process?

Ans:

• Creating a GUI Map File: This creates a GUI object that can be tested with WinRunner.
• Creating a test script: by recording, scripting, or a combination of the two.
• Debugging Test: Run tests in Debug mode to fix issues in the Test Script. Run tests in Verify mode to verify the application.

87. What is included in the GUI map?

Ans:

The GUI Map File retains the element identification properties obtained from the program during recording. Each element is assigned a unique ID, which is used to identify objects throughout the application. GUI Map files serve as a storehouse for application elements. The GUI Map file includes two properties for each object. Identification consists of the physical and logical names of the thing.

88. How does WinRunner define a data-driven test?

Ans:

Data-Driven is an automation testing component that tests input or output values obtained from data files. It is conducted when the values change with time. Data pools, CSV files, and Excel files are among the several types of data files. The data is subsequently entered into variables in recorded or manually programmed scripts. To drive the test using data in WinRunner, we employ the parameterization process.

89. How do you configure the GUI map?

Ans:

• When WinRunner understands the description of a GUI item, it does not understand all of its qualities. 
• Instead, it learns the bare minimum of properties required to produce an object’s unique identification.
• Many apps include bespoke GUI components. A custom object is defined as any object that does not belong to one of WinRunner’s standard classes. 
• These objects are consequently assigned to the generic “object” class. When WinRunner records an operation on a custom object, it inserts obj_mouse_ statements into the test script.

90. What is the objective of GUI Spy?

Ans:

GUI Spy’s primary objective is to inspect and analyze graphical user interface (GUI) elements within software applications. It enables developers and testers to identify properties and attributes of GUI components such as windows, buttons, menus, and input fields. This tool aids in understanding the structure and behavior of the UI, facilitating UI automation and testing processes. GUI Spy provides insights into how elements interact with the underlying code, helping in debugging, performance optimization, and ensuring UI consistency across different platforms and devices.