Automated Graphical User Interface Testing Framework—Evoguitest—Based on Evolutionary Algorithms

Software testing in general and graphical user interface (GUI) testing in particular is one of the major challenges in the lifecycle of any software system. GUI testing is inherently more difficult than the traditional and command-line interface testing. Some of the factors that make GUI testing different from the traditional software testing and significantly more difficult are: a large number of objects, different look and feel of objects, many parameters associated with each object, progressive disclosure, complex inputs from multiple sources, and graphical outputs. The existing testing techniques for the creation and management of test suites need to be adapted/enhanced for GUIs, and new testing techniques are desired to make the creation and management of test suites more efficient and effective. In this article, a methodology is proposed to create test suites for a GUI. The proposed methodology organizes the testing activity into various levels. The tests created at a particular level can be reused at higher levels. This methodology extends the notion of modularity and reusability to the testing phase. The organization and management of the created test suites resembles closely to the structure of the GUI under test.

The increasing expectations of users for ever more functional and impressive Graphical User Interfaces (GUIs) have instigated changes to the way in which programming languages are taught. The rise in popularity of the subject matter has caused problems for lecturers with regards to time and costs. The numbers of student solutions that need to be marked in short periods of time are barely feasible for one person alone or even a marking team to manage; this has been a major influence in the development of marking systems. No system exists for marking GUI programs, indeed few exist for marking any programs. This paper presents the concepts behind an introspective testing and marking tool for GUIs. The hierarchical relationship between interface components and the use of an introspective approach allows us to retrieve data from the GUI components themselves, rather than through relative estimations. This not only allows for dynamic testing of the student's solutions but also aesthetic testing measures.

With the growing usage and migration of interactive applications and systems into today’s environment, the significance of the graphical user interfaces (GUIs) increases as they act as the gates into using systems efficiently. Therefore, extensive efforts are spent to enhance the usability of the GUIs. However, most of the works focus on testing the functional properties of applications’ GUIs rather than nonfunctional features such as performance. For this reason, it is worthwhile to assess the performance of various GUI components at runtime. In this paper, the most popular programming languages used to create GUI based applications namely, Java and C# were compared experimentally to evaluate their performance in terms of the creation and manipulation of GUI components/controls. The experimental results of this study, which is based on 32 testing scenarios, showed that Java outperformed C# in all test scenarios. This might be because of the “HotSpot” performance engine that Java uses. This study is useful for developers to get insights into the performance of different GUI components provided by different programming languages. Also, it helps them to choose the right programming language for their GUI based applications hence enhance the overall applications’ performance and user satisfaction.

This position paper presents a synopsis of the imperative function artificial intelligence (AI) has partaken in software engineering (SE) as well as in software testing. In addition, the paper discusses how graphical user interface (GUI), and event driven software testing can derive benefits from the use of AI techniques. Artificial intelligence has significantly aided the process of the automation of different software process. The employment of AI in software testing is not novel, having played a crucial role in the automation of software testing since its innovation. The usage of AI techniques not only reduces the cost but it also guarantees better quality as well as thorough testing. GUI Testing can be considered as the most challenging area of software testing. Although the results are quite preliminary, but the application of different AI techniques for GUI testing has proven to produce ideal results. Nevertheless, the application of AI techniques in GUI testing, in comparison with software testing, which has procured much assistance by venturing with AI, leaves much to be desired.

Application development of a large number of graphical user interface (GUI) screens and reports requires a labor‐intensive process. In the typical scenario, a GUI developer drags each component, such as the textfield, label, and error messages, on each of the new GUI screens or reports. They then set the component properties and perhaps write any validation routines for input data. Using the proposed Observation Panel Bean (OPB), the developer drags only one component per field, and the OPB dynamically builds the GUI components with consistent properties and links the observation field to the needed validation routine. With little development effort these fields are simply selected from the data dictionary and placed on the GUI. The proposed OPB uses Fowler's observation pattern as a high‐level abstraction representing attributes observed about information in the application domain. The panel collaborates with the observation pattern to set the label, error message, and properties of the various components. Yoder's validator pattern collaborates with the observation pattern and the data dictionary to validate the observations. The proposed OPB decreases GUI development time, adds adaptability to GUI design, and increases consistency in GUI component presentation. Copyright © 2002 John Wiley & Sons, Ltd.

The practitioner interested in reducing software verification effort may found herself lost in the many alternative definitions of Graphical User Interface (GUI) testing that exist and their relation to the notion of system testing. One result of these many definitions is that one may end up testing the same parts of the Software Under Test (SUT), specifically the application logic, twice. To clarify two important testing activities and avoid duplicate testing effort, this paper empirically evaluates to what extent GUI tests exercise the application logic of the software under test (and not only the GUI code). Experimental results show that GUI tests do not necessarily entirely exercise application logic functionality, at least not as much as system tests directly interacting with application logic code.

Graphical User Interface (GUI) has become one of the most significant parts of mobile applications (apps). It is a direct bridge between mobile apps and end users, which directly affects the end user’s experience. Neglecting GUI quality can undermine the value and effectiveness of the entire mobile app solution. Significant research efforts have been devoted to GUI testing, one effective method to ensure mobile app quality. By conducting rigorous GUI testing, developers can ensure that the visual and interactive elements of the mobile apps not only meet functional requirements but also provide a seamless and user-friendly experience. However, traditional solutions, relying on the source code or layout files, have met challenges in both effectiveness and efficiency due to the gap between what is obtained and what app GUI actually presents. Vision-based mobile app GUI testing approaches emerged with the development of computer vision technologies and have achieved promising progress. In this survey article, we provide a comprehensive investigation of the state-of-the-art techniques on 271 articles, among which 92 are vision-based studies. This survey covers different topics of GUI testing, like GUI test generation, GUI test record & replay, GUI testing framework, and so on. In particular, we highlight the emerging role of vision-based techniques and analyze how they reshape traditional approaches to mobile app GUI testing. Based on the investigation of existing studies, we outline the challenges and opportunities of (vision-based) mobile app GUI testing and propose promising research directions with the combination of emerging techniques.

Graphical User Interfaces (GUIs) are amongst the most common user interfaces, enabling interactions with applications through mouse movements and key presses. Tools for automated testing of programs through their GUI exist, however they usually rely on operating system or framework specific knowledge to interact with an application. Due to frequent operating system updates, which can remove required information, and a large variety of different GUI frameworks using unique underlying data structures, such tools rapidly become obsolete, Consequently, for an automated GUI test generation tool, supporting many frameworks and operating systems is impractical. We propose a technique for improving GUI testing by automatically identifying GUI widgets in screen shots using machine learning techniques. As training data, we generate randomized GUIs to automatically extract widget information. The resulting model provides guidance to GUI testing tools in environments not currently supported by deriving GUI widget information from screen shots only. In our experiments, we found that identifying GUI widgets in screen shots and using this information to guide random testing achieved a significantly higher branch coverage in 18 of 20 applications, with an average increase of 42.5% when compared to conventional random testing.

This paper introduces an automated grader for Java programs called GUI_Grader that allows students a degree of flexibility in graphical user interface (GUI) design. GUI_Grader allows students to build multi-window Java applications, choose among alternative GUI components, and decide how to order, position and label components. This enables students to practice some aspects of designing their own GUI applications while still providing automated grading `based on a single test plan. The data-driven approach helps to maintain consistency between test plans and program specifications. Testing GUI_Grader on Java assignments from both a first-year and an upper-year course confirms the feasibility of the approach.

In recent times, software industry has seen the immense expansion in its popularity. Graphical user interface (GUI) is of the most important and ground breaking factor behind the exponential growth of acceptance of software systems. Beside this popularity, software organizations are trying best to optimize the quality of delivered products. In software development life cycle, software testing is one major phase having focus towards improved software quality. Increased attention towards GUI in development helped in materialization of GUI testing as a vital branch of software testing. Manual efforts to test GUI have revealed a lot of problems, which, ultimately led towards automation of GUI testing. This paper presents a novel approach towards automation of GUI test coverage analysis based on an evolutionary algorithm, Particle Swarm Optimization (PSO). Another objective that has been tried to achieve is keeping number of test cases at minimum side.

All most all of the bugs related to graphical user interface (GUI) module of applications and are described in terms of events associated with GUI components. In this paper, a bug mining model for discovering duplicate and similar GUI bugs is presented and approach for detecting the similar and duplicate GUI bugs is described. Resolution of similar and duplicate bugs are almost identical, so if similar and duplicates are identified it will optimize the time for fixing reported GUI bugs and it can also help in achieving the faster development. A GUI bug can be transformed into a sequence of events, components and expected implementation requirements for each GUI event. This transformation is used in this paper to discover the similar and duplicate GUI bugs. First all the GUI bugs are transformed into events, components and requirements sequence, then these sequences are pair wise matched and common subsequence is generated which will indicate the similarity for the GUI bugs.

Graphical user interface (GUI) is an important feature of current software, and testing for GUI is considered as the most efficient method to guarantee the quality of GUI. It is consensus that in industry and academia automated GUI testing approach and tool have been a great help in reducing time and cost in testing, especially regression testing. However, almost all existing automated GUI testing approaches are code intrusive, and strongly dependent on platform or system environment, which leads to the lack of general applicability of GUI testing tools. And most of these tools can only be used in specific software or software platforms. To deal with the challenge, this paper proposes a novel automated GUI testing based on image recognition, which is a non-intrusive and general GUI testing approach. A platform called Auto GUI Testing Platform (AGTP) based on our approach is developed. And a case study is proposed to demonstrate the validity and practicability of AGTP.

The paper provides the design of a distributed test system for testing distributed GUI (Graphical User Interface) applications. The distributed GUI application that is considered allows multiple operators or users to interact with a distributed system in parallel. The distributed GUI application allows the use of existing GUI test frameworks for local test execution and offers additional services of coordination and synchronization among the deployed GUI test frameworks, test verdict arbitration, and debugging support, all of which are needed to deal with the concurrent nature of the system under test. In addition, the paper offers a test specification method for test cases that is based on the semantic model of a concurrent event flow graph. This method allows the automatic test case execution on top of the suggested distributed test system. The overall approach allows the extension of testing of single GUI application systems towards testing of distributed GUI application systems by preserving investments in test automation for single GUI testing.

Graphical user interfaces (GUIs) for today's applications are extremely large. Moreover, they provide many degrees of freedom to the end-user, thus allowing the user to perform a very large number of event sequences on the GUI. The large sizes and degrees of freedom create severe problems for GUI quality assurance, including GUI testing. In this paper, we leverage methods and measures from network analysis to analyze and study GUIs, with the goal of aiding GUI testing activities. We apply these methods and measures on the event-flow graph model of GUIs. Results of a case study show that "network centrality measures" are able to identify the most important events in the GUI as well as the most important sequences of events. These events and sequences are good candidates for test prioritization. In addition, the "betweenness clustering" method is able to partition the GUI into regions that can be tested separately.

Automated testing in web applications is becoming increasingly popular due to its cost-effectiveness, efficiency, and repeatability. Ensuring the quality of such software is vital, especially in scenarios where business requirements are uncertain and volatile. In this paper, we propose Cytestion, a tool that automatically explores a web application’s Graphical User Interface (GUI) to detect faults that cause visible failures, such as crashes, errors, and unexpected behaviors. For that, it applies a scriptless and progressive approach. To work as an oracle, Cytestion evaluates the output of each test case execution by considering the HTTP status of server requests, default and customized failure GUI messages, and console failure messages. We evaluated the effectiveness and cost of our approach in two empirical studies. The first study works with injected faults in open-source projects, while the second is a case study on eight industrial projects. Cytestion detected several faults in both studies and outperformed a state-of-the-art GUI testing tool.