GUI Inspection from Source Code Analysis

2015 IEEE 8th International Conference on Software Testing, Verification and Validation (ICST), 2015

Graphical user interfaces (GUIs) are integral parts of software systems that require interactions from their users. Software testers have paid special attention to GUI testing in the last decade, and have devised techniques that are effective in finding several kinds of GUI errors. However, the introduction of new types of interactions in GUIs presents new kinds of errors that are not targeted by current testing techniques. We believe that to advance GUI testing, the community needs a comprehensive and high level GUI fault model, which incorporates all types of interactions. The work detailed in this paper establishes 4 contributions: 1) A GUI fault model designed to identify and classify GUI faults. 2) An empirical analysis for assessing the relevance of the proposed fault model against failures found in real GUIs. 3) An empirical assessment of two GUI testing tools (i.e. GUITAR and Jubula) against those failures. 4) GUI mutants we've developed according to our fault model. These mutants are freely available and can be reused by developers for benchmarking their GUI testing tools.

Lecture Notes in Computer Science

Graphical user interfaces (GUIs) make software easy to use by providing the user with visual controls. Therefore, correctness of GUI's code is essential to the correct execution of the overall software. Models can help in the evaluation of interactive applications by allowing designers to concentrate on its more important aspects. This paper describes our approach to reverse engineer an abstract model of a user interface directly from the GUI's legacy code. We also present results from a case study. These results are encouraging and give evidence that the goal of reverse engineering user interfaces can be met with more work on this technique.

2010

Abstract The incorrect behaviour of Graphical User Interfaces (GUIs) can compromise the effective use of the overall software application. One way to discover defects and increase the quality of GUIs is through testing. Test cases can be created manually or produced automatically from a model of the GUI. The size and complexity of GUIs makes it unpractical to do extensive manual testing. However, creating a model of the GUI in order to generate automatically test cases is also a laborious task.

Proceedings of the 2009 ACM symposium on Applied Computing, 2009

Graphical user interfaces (GUIs) make software easy to use by providing the user with visual controls. Therefore, correctness of GUI's code is essential to the correct execution of the overall software. Models can help in the evaluation of interactive applications by allowing designers to concentrate on its more important aspects. This paper presents a generic model for language-independent reverse engineering of graphical user interface based applications, and we explore the integration of model-based testing techniques in our approach, thus allowing us to perform fault detection. A prototype tool has been constructed, which is already capable of deriving and testing a user interface behavioral model of applications written in Java/Swing.

ArXiv, 2020

Ensuring the correct visual appearance of graphical user interfaces (GUIs) is important because visual bugs can cause substantial losses for businesses. An application might behave functionally correct in an automated test, but visual bugs can make the GUI effectively unusable for the user. Most of today's approaches for visual testing are pixel-based and tend to have flaws that are characteristic for image differencing. For instance, minor and unimportant visual changes often cause false positives, which confuse the user with unnecessary error reports. Our idea is to introduce an abstract GUI state (AGS), where we define structural relations to identify relevant GUI changes and ignore those that are unimportant from the user's point of view. In addition, we explore several strategies to address the GUI element identification problem in terms of AGS. This allows us to provide rich diagnostic information that help the user to better interpret changes. Based on the principles ...

The International Arab Journal of Information Technology, 2011

User interfaces have special characteristics that differentiate them from the rest of the software code. Typical software metrics that indicate its complexity and quality may not be able to distinguish a complex GUI or a high quality one from another that is not. This paper is about suggesting and introducing some GUI structural metrics that can be gathered dynamically using a test automation tool. Rather than measuring quality or usability, the goal of those developed metrics is to measure the GUI testability, or how much it is hard, or easy to test a particular user interface. We evaluate GUIs for several reasons such as usability and testability. In usability, users evaluate a particular user interface for how much easy, convenient, and fast it is to deal with it. In our testability evaluation, we want to automate the process of measuring the complexity of the user interface from testing perspectives. Such metrics can be used as a tool to estimate required resources to test a particular application.

2009 International Conference on Software Testing Verification and Validation, 2009

To date we have developed and applied numerous model-based GUI testing techniques; however, we are unable to provide definitive improvement schemes to real-world GUI test planners, as our data was derived from open source applications, small compared to industrial systems. This paper presents a study of three industrial GUI-based software systems developed at ABB, including data on classified defects detected during late-phase testing and customer usage, test suites, and source code change metrics. The results show that (1) 50% of the defects found through the GUI are categorized as data access and handling, control flow and sequencing, correctness, and processing defects, (2) system crashes exposed defects 12-19% of the time, and (3) GUI and non-GUI components are constructed differently, in terms of source code metrics.

2003

In this paper we present a "lightweight" visual formalism that can be used to examine the state space complexity of an interface. The method can form a basis for designing, testing and documenting the 'front-end' component of a typical GUI forms based interface. The standard is intended to be free standing and seeks to address issues specific to forms based GUI interfaces. The method is based on a State Transition Diagram (STD) notation that is used to model the GUI component. STDs can be used at an early stage in the design of an interface to quantify and control surface level complexity. Further to allowing a visualisation of the complexity of an interface, techniques used in graph theory are applied to determine a novel measure of complexity that can then be used to better usability.

ACM SIGPLAN Notices, 2010

User interfaces for modern applications must support a rich set of interactive features. It is commonplace to find applications with dependencies between values manipulated by user interface elements, conditionally enabled controls, and script record-ability and playback against different documents. A significant fraction of the application programming effort is devoted to implementing such functionality, and the resulting code is typically not reusable. This paper extends our "property models" approach to programming user interfaces. Property models allow a large part of the functionality of a user interface to be implemented in reusable libraries, reducing application specific code to a set of declarative rules. We describe how, as a by-product of computations that maintain the values of user interface elements, property models obtain accurate information of the currently active dependencies among those elements. This information enables further expanding the class of user interface functionality that we can encode as generic algorithms. In particular, we describe automating the decisions for the enablement of user interface widgets and activation of command widgets. Failing to disable or deactivate widgets correctly is a common source of user-interface defects, which our approach largely removes. We report on the increased reuse, reduced defect rates, and improved user interface design turnarounds in a commercial software development effort as a result of adopting our approach.

10th Working Conference on Reverse Engineering, 2003. WCRE 2003. Proceedings.

Graphical user interfaces (GUIs) are important parts of today's software and their correct execution is required to ensure the correctness of the overall software. A popular technique to detect defects in GUIs is to test them by executing test cases and checking the execution results. Test cases may either be created manually or generated automatically from a model of the GUI. While manual testing is unacceptably slow for many applications, our experience with GUI testing has shown that creating a model that can be used for automated test case generation is difficult. We describe a new approach to reverse engineer a model represented as structures called a GUI forest, event-flow graphs and an integration tree directly from the executable GUI. We describe "GUI Ripping", a dynamic process in which the software's GUI is automatically "traversed" by opening all its windows and extracting all their widgets (GUI objects), properties, and values. The extracted information is then verified by the test designer and used to automatically generate test cases. We present algorithms for the ripping process and describe their implementation in a tool suite that operates on Java and Microsoft Windows' GUIs. We present results of case studies which show that our approach requires very little human intervention and is especially useful for regression testing of software that is modified frequently. We have successfully used the "GUI Ripper" in several large experiments and have made it available as a downloadable tool.