May 28, 2019

GUI Testing Tutorial – Understanding the basics

Graphical User-interface Testing or GUI testing is a process of testing the user interface of an application. In this article, you will learn about the basics of GUI testing and how to do GUI testing and its benefits.

A graphical user interface includes all the elements such as menus, checkbox, buttons, colors, fonts, sizes, icons, content, and images. GUI testing is done to check the functionality and usability of design elements as a user for an application under test.

GUI testing

Why do you need GUI testing?

Modern applications are beyond the desktop they are either mobile based or cloud-based applications. They need to be more user-friendly as per customer demand. The application interface and user experience play a significant role in application success as it is released to the market. A GUI testing team always pays close attention to each detail in visual dynamics to ensure end-user satisfaction and ease.

It tests the various aspects of the user interface, such as:

  • Visual Design
  • Functionality
  • Security
  • Compliance
  • Usability
  • Performance

Benefits of using GUI testing are:

  • It releases an error-free application software
  • It increases the efficiency of software
  • Improves software quality

What we check in GUI Testing?

It extensively checks the user-interface of the application under test.

  • Testing the size, position, height, width of the visual elements
  • Verifying and testing the error messages are displayed or not
  • Testing different sections of the display screen
  • Verifying the usability of carousel arrows
  • Checking the navigation elements at the top of the page
  • Checking the message displayed, frequency and content
  • Verifying the functionality of proper filters and ability to retrieve results.
  • Checking alignment of radio buttons, drop downs
  • Verifying the title of each section and their correctness
  • Cross-checking the colors and its synchronization with the theme

GUI Testing Approaches

There are three approaches to GUI testing:

Manual Testing

This approach involves human tester, where each screen is manually checked to validate each functionality by creating and executing test cases. It is a useful approach when part of UI or a feature is ready, the probability of defects is more at the initial stage, and human intervention is required.

It is convenient to use where the UI is unstable and go through a lot of changes. It is viable for quick checks which can be done at any moment. Moreover, manual testing requires expertise and skills to validate design elements which are not possible without a human tester.

Record and Replay Testing

GUI record and replay tools are used to test applications for their user interface. Using such tools, testers run an application and record the user interaction with the app. A script runs to track and save the user actions, including cursor movements, which can be replayed several times to find the issues in the interface.

It also supports automated regression testing. It is can be used for cross-browser testing. It is a convenient and lightweight solution for testing. It doesn’t work well where you have lots of iterations in the GUI of the applications. Recapturing and replaying test cases to check functionality is time-consuming, and tracking their updated version is a cumbersome process.

Model-based testing

In this type of GUI testing, a model is created to understand and evaluate the system’s behavior. This approach is useful in creating accurate test cases using system requirements. It is a structured, thorough, measurable form of testing.

There are three essential aspects of model-based GUI testing:

  • Automatically generated test cases from the model
  • Manually derived test cases from the model
  • Model and requirements coverage metrics

There are tools which could automatically generate test based on the model.

Things to consider for model-based testing:

  • Create the model
  • Determine the information as inputs in the system
  • Verifying the expected output
  • Execute tests
  • Checking and validating actual vs. expected
  • Take further action on the model

You can even derive test cases for GUI in two ways:

Charts: The charts display the state of the system and check the state after some input.

Decision Tables: This helps in deciding the results for each input

Model-Based testing is preferred as the technique aligns with requirements which define even the undesirable states a GUI can attain.

An automated test case generator produces test cases to cover all the paths between start to finish stage. The number of test cases generated automatically is large and it requires a lot of time to execute.

You need to implement a test case selection algorithm to reject all inadequate scenarios for test cases. It means you need a test case filter to select the required test cases as the set is too big and will consume more time.

The above problem has one solution, opting for a manual approach to finalize test cases. The process can be integrated with the automatic generation of test scripts after tester manually shortlist the test cases.

So if we conclude saying model-based testing makes GUI testing easy then yes it does. Only when it is used for a well-designed process where it is easy to generate a test set by performing dummy testing and running test cases. But it is not appropriate where a test set consumes a lot of time in execution. Efforts are required in building a model and short listing the test cases using an algorithm and test script generation, which makes it expensive.

How to write a GUI test plan?

A test plan defines the scope of the test project. Before running test cases, it is important to create a test plan to identify the scope of the project, resources available and functionalities to be tested in the application. The entire team works on creating test scenarios, creating test cases and scripts to start with testing.

How to create a GUI test scripts?

A test script is a template which defines the standard of input/ information required to test the GUI of the application. It includes:

  • Test Script ID: It uniquely identifies the test script.
  • Title: It defines the Test Script, the part of the functionality under test.
  • Test Case ID: Unique ID which is used to link it with test cases.
  • Test Setup: Defines all the requirements of the test environment.
  • Test Data: Data values that are used to check the usability and correctness of the application.
  • Procedure: A series of steps used to define the instructions of the test. The entire process of GUI testing.
  • Priority/Risk Level: Assigning a risk level to the test case (critical, high, medium, low).
  • Description: The entire information about the test case.
  • Expected Result: It defines success as the expected result.
  • Status: It defines the status of the test case.

Creating test scripts is an important part of GUI testing. Any customization in the test scripts fields to suit business needs and demands is a great advantage of any tool. ReQtest is one such tool which allows you to customize the test scripts, manage and streamlines test cases to improve testing speed and quality of the application. It supports agile methodology and can provide great assistance to the entire team.


GUI testing is crucial to the successful release of the software as it validates the user experience. GUI testing is helps to deliver high-quality and user-friendly software. In the end, you achieve a higher level of user engagement and satisfaction.

Share article