João Pascoal Faria

A model-to-implementation mapping tool for automated model-based GUI testing

This paper presents extensions to Spec Explorer to automate the testing of software applications through their GUIs based on a formal specification in Spec

Towards the integration of visual and formal models for GUI testing

\sharp

A metamodel-based approach for automatic user interface generation

. Spec Explorer, a tool developed at Microsoft Research, already supports automatic generation and execution of test cases for API testing, but requires that the actions described in the model are bound to methods in a .Net assembly. The tool described in this paper extends Spec Explorer to automate GUI testing: it adds the capability to gather information about the physical GUI objects that are the target of the user actions described in the model; and it automatically generates a .Net assembly with methods that simulate those actions upon the GUI application under test. The GUI modelling and the overall test process supported by these tools are described. The approach is illustrated with the Notepad application.

Reverse engineered formal models for GUI testing

Abstract 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 extensions is 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.

Automatic Generation of User Interface Models and Prototypes from Domain and Use Case Models

One of the advantages of following a MDA-based approach in the development of interactive applications is the possibility of generating multiple platform-specific user interfaces (UI) from the same platform independent UI model. However, the effort required to create the UI model may be significant. In the case of data-intensive applications, a large part of the UI structure and functionality is closely related with the structure and functionality of the domain entities described in the domain model, and the access rules specified in the use case model. This paper presents an approach to reduce the effort required to create platform independent UI models for data intensive applications, by automatically generating an initial UI model from domain and use case models. For that purpose, UML-aligned metamodels for domain and use case models are defined, together with a MOF-based metamodel for user interface models. The transformation rules that drive the UI model generation are introduced. It is also proposed a MDA-based process for the development of data intensive interactive applications based on the proposed model architecture and transformations.

Test Coverage Analysis of UML State Machines

This paper describes a process to reverse engineer structural and behaviouralformal models of a GUI application by a dynamic technique, mixingmanual with automatic exploration. The goal is to diminish the effort requiredto construct the model and mapping information needed in a model-based GUItesting process. A skeleton of a state machine model of the GUI, represented ina formal pre/post specification language, is generated automatically by the explorationprocess. Mapping information between the model and the implementationis also generated along the way. The model extracted automatically isthen completed manually in order to get an executable model which can be usedas a test oracle. Abstract test cases, including expected outputs, can be generatedautomatically from the final model and executed over the GUI application,using the mapping information generated during the exploration process.

Specification-Based Testing of User Interfaces

The development of interactive systems typically involves the separate design and development of disparate system components by different software developers. The user interface (UI) is the part of an interactive system through which a user can access the system functionality. User interface development is a complex task that typically involves the construction of prototypes and/or models. A prototype facilitates the communication with the stakeholders, especially with the end users, and allows for the validation of elicited requirements. Modelling is a well established way people take for dealing with complexity. A model allows one to focus on important properties of the system being modelled and abstract away from unimportant issues. Software models may capture relevant parts of the problem and solution domains and are typically used as a means for reasoning about the system properties and for communicating with the stakeholders. The user interface tends to be viewed differently, depending on what community the UI designer belongs to. UI designers that are more identified with the Software Engineering (SE) community tend to highlight the system functionality issues, and how it encapsulates system behaviour to provide to the user. UI designers that are more identified with the Human-Computer Interaction (HCI) community tend to focus on user task analysis and the way the user shall work on the UI. According to the HCI perspective, one of the concerns that shall be modelled is the user intended tasks on the interactive system, and this is made through the development of user task analysis. Typically, task analysis and modelling involve the development of goal and task hierarchies and the identification of objects and actions involved in each task (Dix et al., 1998). Besides this task model, a view of the UI relevant aspects of the system core structure and functionality may also be modelled, along with a UI presentation model, in order to complete the whole interactive system model. In the SE community, a common practice is to build a Unified Modelling Language (UML) system model, comprising a domain model and a use case model, supplemented by a non-functional UI prototype, in the early stages of the software development process (Jacobson et al., 1999; Pressman, 2005). The domain model captures the main system’s domain classes, its attributes, relations and, in some cases, its operations, through UML class diagrams. The use case model captures the main system functionalities from the user’s point of view

Adaptive Object-Modelling: Patterns, Tools and Applications

Software testing is a very important activity of the software development process. To expedite the testing process and improve the quality of the tests, models are increasingly used as a basis to derive test cases automatically - a technique known as model-based testing (MBT). Given a system model and a test suite derived automatically from the model or created by other process, the coverage of the model achieved by the test suite is important to assess the quality and completeness of the test suite early in the software development process. This paper presents a novel tool that shows visually the coverage achieved by a test suite on a UML state machine model. The tool receives as input a UML state machine model represented in XMI and a test suite represented in a XML format, and produces a colored UML state machine model that shows the coverage result. Model test coverage is determined by simulating the execution of the test suite over the model. An example is presented in order to show the features of the tool.

Automated Pattern-Based Testing of Mobile Applications

It is proposed an approach to integrate formal methods in the software development process, with an emphasis on the user interface development. The approach covers the specification by means of formal models, early model animation and validation, construction and conformity testing of the user interface implementation with respect to the specification. These conformity tests are described in detail through a state transition model with an abstraction function mapping concrete (implementation) to abstract (specification) states and operations. In order to illustrate the approach, it is presented a simple login/password dialog specification in VDM++, using a reusable control specification library, with a straightforward translation to Java or C#.

Specification-Driven unit test generation for java generic classes

Adaptive Object Models, though a well-known architectural pattern, is seldomly used in software projects where, due to their nature, would highly benefit from it. Characteristics such as complexity, reduced literature and case-studies, lack of reusable framework components, and fundamental issues as those regarding runtime evolution, drive developers away. By overcoming these barriers with a set of patterns, tools and applications, and addressing pending research problems, Adaptive Object Models can dramatically alter the way developers design their software. This paper presents a survey in the field, describes the preliminary contributions and outlines the ongoing doctoral work.