Academia.eduAcademia.edu

Outline

Title
Abstract
Figures
Introduction
Overview
Experimental Results & Discussion
Limitations & Threats to Validity
Conclusion & Future Work
References
All Topics
Computer Science

Visual Testing of GUIs by Abstraction

Profile image of Martin SulzmannMartin Sulzmann

2020, ArXiv

Abstract

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 ...

Figures (7)
Figure 1: Expected compared to actual login screen and differences highlighted by Applitools [24].
Figure 1: Expected compared to actual login screen and differences highlighted by Applitools [24].
Figure 2: The AGS framework and its tools.
Figure 2: The AGS framework and its tools.
Inference rules are to be read as follows: The statements above the bar are the preconditions (premise). The statement below the bar is the conclusion. If the premise can be satisfied, we can derive the conclusion. The premise represents detailed diagnostic information that explains the reason for inequality.
Inference rules are to be read as follows: The statements above the bar are the preconditions (premise). The statement below the bar is the conclusion. If the premise can be satisfied, we can derive the conclusion. The premise represents detailed diagnostic information that explains the reason for inequality.
Table 2: Overview of TPs, FNs, FPs in terms of GUI change detection performance from RQ3.
Table 2: Overview of TPs, FNs, FPs in terms of GUI change detection performance from RQ3.
Figure 3: Results for RQ; and RQ: by fairly similar instance.
Figure 3: Results for RQ; and RQ: by fairly similar instance.
Figure 4: Test report excerpt for changes to the “Sign in” but- ton from Applitools’ demo.
Figure 4: Test report excerpt for changes to the “Sign in” but- ton from Applitools’ demo.
DEFINITION 10 (EQUALITY). Rule (Es-Eq2) checks for equality among two lists of elements by checking for equality among the elements at the respective po- sitions. Rule (Es-Eq1) represents the (base) case where both lists are empty. For attributes, we establish equality among the indi- vidual elements. See rules (As-Eq1) and (As-Eq2). Equality among attributes holds if their key-value pairs are identical. See rule (A-Eq). In essence, two AGSes are equal if the order of elements remains in- tact and the sets of attributes contain the same (identical) attributes.
DEFINITION 10 (EQUALITY). Rule (Es-Eq2) checks for equality among two lists of elements by checking for equality among the elements at the respective po- sitions. Rule (Es-Eq1) represents the (base) case where both lists are empty. For attributes, we establish equality among the indi- vidual elements. See rules (As-Eq1) and (As-Eq2). Equality among attributes holds if their key-value pairs are identical. See rule (A-Eq). In essence, two AGSes are equal if the order of elements remains in- tact and the sets of attributes contain the same (identical) attributes.

Related papers

GUI ripping: reverse engineering of graphical user interfaces for testing
akal malik

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.

View PDFchevron_right
Towards the Integration of Visual and Formal Models for GUI Testing
Raul Moreira Vidal

Electronic Notes in Theoretical Computer Science, 2007

This paper presents an approach to diminish the effort required in GUI modelling and test coverage analysis within a model-based GUI testing process. A familiar visual notation-a subset of UML with minor extensionsis used to model the structure, behaviour and usage of GUIs at a high level of abstraction and to describe test adequacy criteria. The GUI visual model is translated automatically to a model-based formal specification language (e.g., Spec#), hiding formal details from the testers. Then, additional behaviour may be added to the formal model to be used as a test oracle. The adequacy of the test cases generated automatically from the formal model is accessed based on the structural coverage of the UML behavioural diagrams.

View PDFchevron_right
On model-based testing advanced GUIs
Valéria Lelli

2015 IEEE Eighth International Conference on Software Testing, Verification and Validation Workshops (ICSTW), 2015

Graphical User Interface (GUI) design is currently shifting from designing GUIs composed of standard widgets to designing GUIs relying on more natural interactions and ad hoc widgets. This shift is meant to support the advent of GUIs providing users with more adapted and natural interactions, and the support of new input devices such as multi-touch screens. Standard widgets (e.g. buttons) are more and more replaced by ad hoc ones (e.g. the drawing area of graphical editors), and interactions are shifting from mono-event (e.g. button pressures) to multi-event interactions (e.g. multi-touch and gesture-based interactions). As a consequence, the current GUI model-based testing approaches, which target event-based systems, show their limits when applied to test such new advanced GUIs. The work introduced in this paper establishes three contributions: a precise analysis of the reasons of these current limits; a proposition to tackle the identified limits by leveraging the Malai GUI specification language and by proposing the concept of interaction-action-flow graph; feedback from two use cases, an industrial project and an open-source application, where the proposed approach has been applied.

View PDFchevron_right
Towards the Integration of Visual and Formal Models for GUI Testing1
Raul Vidal

Electronic Notes in Theoretical …, 2007

This paper presents an approach to diminish the effort required in GUI modelling and test coverage analysis within a model-based GUI testing process. A familiar visual notation -a subset of UML with minor extensionsis used to model the structure, behaviour and usage of GUIs at a high level of abstraction and to describe test adequacy criteria. The GUI visual model is translated automatically to a model-based formal specification language (e.g., Spec#), hiding formal details from the testers. Then, additional behaviour may be added to the formal model to be used as a test oracle. The adequacy of the test cases generated automatically from the formal model is accessed based on the structural coverage of the UML behavioural diagrams.

View PDFchevron_right
A pattern-based approach for GUI modeling and testing
RODRIGO AZEVEDO MOREIRA

2013

User Interface (UI) patterns are used extensively in the design of today's software. UI patterns embody commonly recurring solutions that solve common GUI design problems, such as "login," "file-open," and "search." Yet, testing of GUIs for functional correctness has largely ignored UI patterns. This paper formalizes the notion of a Pattern-Based Graphical User Interface (GUI) Testing method (PBGT) for systematizing and automating the GUI testing process. The space of all possible interactions with a GUI is typically very large. PBGT presents a new methodology to sample the input space using "UI Test Patterns," that embody commonly recurring solutions to test GUIs. Our empirical studies show that the PBGT methodology is effective in revealing faults in fielded GUIs.

View PDFchevron_right
Revisiting the Notion of GUI Testing
Sashank Nekkanti

Proceedings of the 13th International Conference on Software Technologies, 2018

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 twice the same parts of the Software Under Test (SUT), specifically the application logic code. We revisit the notion of GUI testing and introduce a taxonomy of activities pertaining to testing GUI-based software. We use the taxonomy to map a representative sample of research works and tools, showing several aspects of testing GUI-software may be overlooked.

View PDFchevron_right
Iterative execution-feedback model-directed GUI testing
akal malik

Information and Software Technology, 2010

Current fully automatic model-based test-case generation techniques for GUIs employ a static model. Therefore they are unable to leverage certain state-based relationships between GUI events (e.g., one enables the other, one alters the other's execution) that are revealed at run-time and non-trivial to infer statically. We present ALT-a new technique to generate GUI test cases in batches. Because of its ''alternating" nature, ALT enhances the next batch by using GUI run-time information from the current batch. An empirical study on four fielded GUI-based applications demonstrated that ALT was able to detect new 4-and 5-way GUI interaction faults; in contrast, previous techniques, due to their requirement of too many test cases, were unable to even test 4-and 5-way GUI interactions.

View PDFchevron_right
Behind the Scenes: An Approach to Incorporate Context in GUI Test Case Generation
Martin Schäf

2011

UNU-IIST is jointly funded by the government of Macao and the governments of the People's Republic of China and Portugal through a contribution to the UNU Endowment Fund. As well as providing two-thirds of the endowment fund, the Macao authorities also supply UNU-IIST with its office premises and furniture and subsidise fellow accommodation.

View PDFchevron_right
Modeling and testing hierarchical GUIs
Raul Vidal

Proceedings of the 12th International Workshop on Abstract State Machines, 2005

This paper presents a new approach to model and test hierarchical Graphical User Interfaces (GUIs). We exploit the structure of Hierarchical Finite State Machines (HFSMs) to reduce the number of states in the" flat" Finite State Machine (FSM) resulting from the exploration of the model. Firstly, independent dialogs are identified and highlighted in a HFSM built from the FSM. Then, the portion of the FSM that describes each dialog is reduced. To illustrate the approach, we construct a model of the Notepad application, ...

View PDFchevron_right
Advances in Model-Based Testing of Graphical User Interfaces
Tugkan Tuglular

Advances in Computers, 2017

Graphical user interfaces (GUIs) enable comfortable interactions of the computer-based systems with their environment. Large systems usually require complex GUIs which are commonly fault-prone and thus are to be carefully designed, implemented, and tested. As a thorough testing is not feasible, techniques are favored to test relevant features of the system under test that will be specifically modeled. This chapter summarizes, reviews, and exemplifies conventional and novel techniques for model-based GUI testing.

View PDFchevron_right

References (47)

  1. A. Alameer, S. Mahajan, and W. G. J. Halfond, "Detecting and localizing in- ternationalization presentation failures in web applications," in Proceedings of the 9th IEEE International Conference on Software Testing, Verification and Validation, ser. ICST '16, Chicago, IL, USA: IEEE, 2016, pp. 202-212.
  2. F. N. Egger, ""trust me, i'm an online vendor": Towards a model of trust for e-commerce system design, " in CHI 2000 Extended Abstracts on Human Factors in Computing Systems, ser. CHI EA '00, The Hague, Netherlands: ACM, 2000, pp. 101-102.
  3. A. Everard and D. F. Galletta, "How presentation flaws affect perceived site quality, trust, and intention to purchase from an online store, " Journal of Man- agement Information Systems, vol. 22, no. 3, pp. 56-95, Jan. 2005.
  4. B. J. Fogg, J. Marshall, O. Laraki, A. Osipovich, C. Varma, N. Fang, J. Paul, A. Rangnekar, J. Shon, P. Swani, and M. Treinen, "What makes web sites credible? a report on a large quantitative study," in Proceedings of the ACM SIGCHI Conference on Human Factors in Computing Systems, ser. CHI '01, Seattle, WA, USA: ACM, 2001, pp. 61-68.
  5. W. Li, M. J. Harrold, and C. Görg, "Detecting user-visible failures in ajax web applications by analyzing users' interaction behaviors," in Proceedings of the 25th ACM/IEEE International Conference on Automated Software Engineering, ser. ASE '10, Antwerp, Belgium: ACM, 2010, pp. 155-158.
  6. M. Battat. (Apr. 2019). What is applitools? [Online]. Available: https://applitools. com/blog/what-is-applitools/.
  7. I. Althomali, G. M. Kapfhammer, and P. McMinn, "Automatic visual verification of layout failures in responsively designed web pages, " in Proceedings of the 12th IEEE International Conference on Software Testing, Verification and Validation, ser. ICST '19, Xi'an, China: IEEE, 2019, pp. 183-193.
  8. C. Luo. (May 2018). Resizemybrowser, [Online]. Available: http://resizemybrowser. com/.
  9. QuirkTools. (Apr. 2019). Screenfly, [Online]. Available: http://quirktools.com/ screenfly/.
  10. NETBURN web solutions. (Apr. 2019). Testsize.com, [Online]. Available: http: //testsize.com/.
  11. Galen Framework. (Mar. 2019). Galen framework, [Online]. Available: http: //galenframework.com/.
  12. S. Hallé, N. Bergeron, F. Guerin, G. Le Breton, and O. Beroual, "Declarative layout constraints for testing web applications, " Journal of Logical and Algebraic Methods in Programming, vol. 85, no. 5, pp. 737-758, Aug. 2016.
  13. P. Panchekha, A. T. Geller, M. D. Ernst, Z. Tatlock, and S. Kamil, "Verifying that web pages have accessible layout," in Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, ser. PLDI '18, Philadelphia, PA, USA: ACM, 2018, pp. 1-14.
  14. D. Zaiats. (Apr. 2019). Automotion, [Online]. Available: https://automotion. itarray.net/.
  15. B. Slatkin. (Jun. 2013). The secret to safe continuous deployment, [Online]. Available: https://youtu.be/UMnZiTL0tUc/.
  16. M. C. Feathers, Working effectively with legacy code, 1st ed. Upper Saddle River, NJ, USA: Prentice Hall, 2004.
  17. S. Mahajan, B. Li, P. Behnamghader, and W. G. J. Halfond, "Using visual symp- toms for debugging presentation failures in web applications, " in Proceedings of the 9th IEEE International Conference on Software Testing, Verification and Validation, ser. ICST '16, Chicago, IL, USA: IEEE, 2016, pp. 191-201.
  18. S. Mahajan and W. G. J. Halfond, "Detection and localization of html presenta- tion failures using computer vision-based techniques, " in Proceedings of the 8th IEEE International Conference on Software Testing, Verification and Validation, ser. ICST '15, Graz, Austria: IEEE, 2015, pp. 1-10.
  19. S. Roy Choudhary, M. R. Prasad, and A. Orso, "X-pert: Accurate identification of cross-browser issues in web applications," in Proceedings of the 35th Inter- national Conference on Software Engineering, ser. ICSE '13, San Francisco, CA, USA: IEEE Press, 2013, pp. 702-711.
  20. T. o. Saar, M. Dumas, M. Kaljuve, and N. Semenenko, "Browserbite: Cross- browser testing via image processing," Software: Practice and Experience, vol. 46, no. 11, pp. 1459-1477, Nov. 2016.
  21. Applitools. (Apr. 2019). Ai powered visual ui testing & monitoring, [Online]. Available: https://applitools.com/.
  22. B. Slatkin. (Aug. 2016). Bslatkin/dpxdt, [Online]. Available: https://github.com/ bslatkin/dpxdt/.
  23. Percy. (Apr. 2019). Percy, [Online]. Available: https://percy.io/.
  24. Applitools. (Mar. 2019). Selenium java tutorial, [Online]. Available: https:// applitools.com/tutorials/selenium-java.html.
  25. E. Alégroth, A. Karlsson, and A. Radway, "Continuous integration and visual gui testing: Benefits and drawbacks in industrial practice, " in Proceedings of the 11th International Conference on Software Testing, Verification and Validation, ser. ICST '18, Vasteras, Sweden: IEEE, 2018, pp. 172-181.
  26. K. Moran, C. Watson, J. Hoskins, G. Purnell, and D. Poshyvanyk, "Detecting and summarizing gui changes in evolving mobile apps," in Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering, ser. ASE '18, Montpellier, France: ACM, 2018, pp. 543-553.
  27. M. Grechanik, C. W. Mao, A. Baisal, D. Rosenblum, and B. M. Hossain, "Differ- encing graphical user interfaces, " in Proceedings of the 18th IEEE International Conference on Software Quality, Reliability and Security, ser. QRS '18, Lisbon, Portugal: IEEE, 2018, pp. 203-214.
  28. T. A. Walsh, G. M. Kapfhammer, and P. McMinn, "Automated layout failure detection for responsive web pages without an explicit oracle, " in Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis, ser. ISSTA '17, Santa Barbara, CA, USA: ACM, 2017, pp. 192-202.
  29. Q. Xie, M. Grechanik, C. Fu, and C. Cumby, "Guide: A gui differentiator," in Proceedings of the 25th IEEE International Conference on Software Maintenance, ser. ICSM '09, New York, NY, USA: IEEE, 2009, pp. 395-396.
  30. ReTest. (May 2019). Retest/recheck, [Online]. Available: https://github.com/ retest/recheck/.
  31. --, (May 2019). Retest/recheck-web, [Online]. Available: https://github.com/ retest/recheck-web/.
  32. D. Kraus. (Apr. 2019). Beatngu13/visual-testing, [Online]. Available: https : //github.com/beatngu13/visual-testing/.
  33. S. McMaster and A. M. Memon, "An extensible heuristic-based framework for gui test case maintenance, " in Proceedings of the 2009 International Conference on Software Testing, Verification, and Validation Workshops, ser. ICSTW '09, Denver, CO, USA: IEEE, 2009, pp. 251-254.
  34. Selenium. (May 2016). Selenium webdriver, [Online]. Available: https://www. seleniumhq.org/projects/webdriver/.
  35. Wikipedia. (Aug. 2019). List of most popular websites, [Online]. Available: https://en.wikipedia.org/wiki/List_of_most_popular_websites.
  36. ReTest. (May 2019). Review, [Online]. Available: https://retest.de/review/.
  37. Z. Gao, Z. Chen, Y. Zou, and A. M. Memon, "Sitar: Gui test script repair, " IEEE Transactions on Software Engineering, vol. 42, no. 2, pp. 170-186, Feb. 2016.
  38. M. Ermuth and M. Pradel, "Monkey see, monkey do: Effective generation of gui tests with inferred macro events," in Proceedings of the 25th ACM SIG- SOFT International Symposium on Software Testing and Analysis, ser. ISSTA '16, Saarbrücken, Germany: ACM, 2016, pp. 82-93.
  39. Z. Gao, C. Fang, and A. M. Memon, "Pushing the limits on automation in gui regression testing, " in Proceedings of the 26th IEEE International Symposium on Software Reliability Engineering, ser. ISSRE '15, Gaithersbury, MD, USA: IEEE, 2015, pp. 565-575.
  40. K. Mao, M. Harman, and Y. Jia, "Sapienz: Multi-objective automated testing for android applications," in Proceedings of the 25th ACM SIGSOFT Interna- tional Symposium on Software Testing and Analysis, ser. ISSTA '16, Saarbrücken, Germany: IEEE, 2016, pp. 94-105.
  41. R. M. L. M. Moreira, A. C. R. Paiva, M. Nabuco, and A. M. Memon, "Pattern- based gui testing: Bridging the gap between design and quality assurance," Software: Testing, Verification and Reliability, vol. 27, no. 3, e1629, May 2017.
  42. J. A. Saddler and M. B. Cohen, "Eventflowslicer: A tool for generating realistic goal-driven gui tests, " in Proceedings of the 32nd IEEE/ACM International Con- ference on Automated Software Engineering, ser. ASE '17, Urbana-Champaign, IL, USA: IEEE Press, 2017, pp. 955-960.
  43. W. Song, X. Qian, and J. Huang, "Ehbdroid: Beyond gui testing for android applications, " in Proceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering, ser. ASE '17, Urbana-Champaign, IL, USA: IEEE Press, 2017, pp. 27-37.
  44. E. Alegroth, M. Nass, and H. H. Olsson, "Jautomate: A tool for system-and acceptance-test automation, " in Proceedings of the 6th IEEE International Confer- ence on Software Testing, Verification and Validation, ser. ICST '13, Washington, DC, USA: IEEE Computer Society, 2013, pp. 439-446.
  45. E. Borjesson and R. Feldt, "Automated system testing using visual gui testing tools: A comparative study in industry, " in Proceedings of the 5th IEEE Interna- tional Conference on Software Testing, Verification and Validation, ser. ICST '12, Montreal, QC, Canada: IEEE Computer Society, 2012, pp. 350-359.
  46. T. Yeh, T.-H. Chang, and R. C. Miller, "Sikuli: Using gui screenshots for search and automation," in Proceedings of the 22nd Annual ACM Symposium on User Interface Software and Technology, ser. UIST '09, Victoria, BC, Canada: ACM, 2009, pp. 183-192.
  47. E. T. Barr, M. Harman, P. McMinn, M. Shahbaz, and S. Yoo, "The oracle problem in software testing: A survey, " IEEE Transactions on Software Engineering, vol. 41, no. 5, pp. 507-525, May 2015.

Related papers

Classifying and Qualifying GUI Defects
Valéria Lelli

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.

View PDFchevron_right
Structural Feature Extraction for GUI Test Enhancement
Fevzi Belli

2009 International Conference on Software Testing, Verification, and Validation Workshops, 2009

The challenging goal of designing interactive systems is to prevent faults caused by the control unit that could potentially lead to failures. When designing interactive systems, it is the behavior that is dominant in the process of modeling. Nevertheless, structural features in software application programming and their organization are seldom taken into account for test derivation. The consequence is a reduction in fault coverage with regard to find structural defects in such systems. This paper introduces an approach to reveal structural features of such systems that expose further test opportunities. The approach uses a graphical, event-based model of which structural features are extracted by simple transformations resulting into an increased fault coverage.

View PDFchevron_right
GUI Inspection from Source Code Analysis
Jose Adolfo Campos

2010

Graphical user interfaces (GUIs) are critical components of today's software. Given their increased relevance, the correctness and usability of GUIs are becoming essential. This paper describes the latest results in the development of our tool to reverse engineer the GUI layer of interactive computing systems. We use static analysis techniques to generate models of the user interface behavior from source code. Models help in graphical user interface inspection by allowing designers to concentrate on its more important aspects. One particular type of model that the tool is able to generate is state machines. The paper shows how graph theory can be useful when applied to these models. A number of metrics and algorithms are used in the analysis of aspects of the user interface's quality. The ultimate goal of the tool is to enable analysis of interactive system through GUIs source code inspection.

View PDFchevron_right
A generic library for GUI reasoning and testing
João Saraiva

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.

View PDFchevron_right
A practical approach to testing GUI systems
Marek Reformat

Empirical Software Engineering, 2007

GUI systems are becoming increasingly popular thanks to their ease of use when compared against traditional systems. However, GUI systems are often challenging to test due to their complexity and special features. Traditional testing methodologies are not designed to deal with the complexity of GUI systems; using these methodologies can result in increased time and expense. In our proposed strategy, a GUI system will be divided into two abstract tiers—the component tier and the system tier. On the component tier, a flow graph will be created for each GUI component. Each flow graph represents a set of relationships between the pre-conditions, event sequences and post-conditions for the corresponding component. On the system tier, the components are integrated to build up a viewpoint of the entire system. Tests on the system tier will interrogate the interactions between the components. This method for GUI testing is simple and practical; we will show the effectiveness of this approach by performing two empirical experiments and describing the results found.

View PDFchevron_right

Related topics

  • Computer Science
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved