Mika Katara

Architectural views of aspects

Support for the incremental design of aspects themselves has been neglected, even as the use of aspects in conjunction with underlying systems is gaining acceptance. The ways in which aspects can cooperate or interfere with each other need to be made explicit at the design level. An aspect architecture, a new software architecture viewtype, is proposed, and its general principles are explained. An instantiation for extending UML is described, where designs of aspects provide maximal flexibility, and a new concern diagram is provided to show how aspects can be combined to treat different concerns of a system. An example shows aspect architecture views of a digital sound recorder.

Experiences of System-Level Model-Based GUI Testing of an Android Application

This paper presents experiences in model-based graphical user interface testing of Android applications. We present how model-based testing and test automation was implemented with Android, including how applications were modeled, how tests were designed and executed, and what kind of problems were found in the tested application during the whole process. The main focus is on a case study that was performed with an Android application, the BBC News Widget. Our goal is to present actual data on the experiences and to discuss if advantages can be gained using model-based testing when compared with traditional graphical user interface testing. Another contribution of this paper is a description of a keyword-based test automation tool that was implemented for the Android emulator during the case study. All the models and the tools created or used in this case study are available as open source.

Making model-based testing more agile: a use case driven approach

We address the problem of misalignment of artifacts developed in agile software development projects and those required by model-based test generation tools. Our solution is domain specific and relies on the existence of domain experts to design the test models. The testers interface the test generation systems with use cases that are converted into sequences of so called action words corresponding to user events at a high level of abstraction. To support this scheme, we introduce a coverage language and an algorithm for automatic test generation.

Towards Deploying Model-Based Testing with a Domain-Specific Modeling Approach

Model-based testing, automating the generation of test cases is technically superior to conventional scripted testing. However, there have been difficulties in deploying the methodology in large scale industrial context. In this paper we present a domain-specific approach to model-based GUI testing that should be easier to adopt than more generic solutions. The method is based on keywords and action words that are considered as best practices in conventional GUI test automation. The basic idea is to record GUI events just like in capture/replay tools, but instead of producing scripts that can be hard to maintain, we produce sequences of keywords. These sequences are further transformed semi-automatically into labeled transition systems where action words are used as transition labels. The action words model user behavior at a high level of abstraction while the keywords correspond to the GUI navigation. We also describe the associated tool set that we are developing and an example of using the approach

Model-Based Testing Service on the Web

Model-based testing (MBT) seems to be technically superior to conventional test automation. However, MBT features some difficulties that can hamper its deployment in industrial contexts. We are developing a domain-specific MBT solution for graphical user interface (GUI) testing of Symbian S60 smartphone applications. We believe that such a tailor-made solution can be easier to deploy than ones that are more generic. In this paper, we present a service concept and an associated web interface that hide the inherent complexity of the test generation algorithms and large test models. The interface enables an easy-to-use MBT service based on the well-known keyword concept. With this solution, a better separation of concerns can be obtained between the test modeling tasks that often require special expertise, and test execution that can be performed by testers. We believe that this can significantly speed up the industrial transfer of model-based testing technologies, at least in this context.

Choosing a test modeling language: a survey

Deployment of model-based testing involves many difficulties that have slowed down its industrial adoption. The leap from traditional scripted testing to model-based testing seems as hard as moving from manual to automatic test execution. Two key factors in the deployment are the language used to define the test models, and the language used for defining the test objectives. Based on our experience, we survey the different types of languages and sketch solutions based on different approaches, considering the testing organization, the system under test, etc. The types of languages we cover include among others domain-specific, test-specific as well as generic design languages. We note that there are no best practices, but provide general guidelines for various cases.

Adaptable concern-based framework specialization in UML

Architectural-level reuse of software can be achieved in the form of application frameworks. Then, the architecture of a system can be copied from a framework, and the developer is liberated to application development. In this scheme, patterns utilized for specializing the framework play a critical role. Unfortunately, the bigger the specialization pattern, the harder it is to adapt the pattern to a particular design due to increasing number of bindings between pattern roles and the elements of the design. We introduce a tool supported methodology based on UML in which specialization patterns are grouped to match different concerns, i.e. conceptual matters of interest, they treat. Also, user-controlled instantiation of individual patterns is allowed to promote learning the architectural conventions. We argue that this approach overcomes some limitations, especially the lack of adaptability, of wizards that are commonly used for similar purposes.

Model-Based Testing with a General Purpose Keyword-Driven Test Automation Framework

Model-based testing (MBT) is a relatively new approach to software testing that extends test automation from test execution to test design using automatic test generation from models. The effective use of the new approach requires new skills and knowledge, such as test modeling skills, but also good tool support. This paper focuses upon the integration of the TEMA model-based graphical user interface test generator with a keyword-driven test automation framework, Robot Framework. Both of the tools are available as open source. The purpose of the integration was to enable the wide testing library support of Robot Framework to be used in online model-based testing. The main contribution of this paper is to present the integration providing a base for future MBT utilization, but we will also describe a short case study where we experimented with the integration in testing a Java Swing GUI application and discuss early experiences in using the framework in testing Web GUIs.

Automatic GUI test generation for smartphone applications - an evaluation

We present the results of an evaluation where we studied the effectiveness of automatic test generation for graphical user interface (GUI) testing of smartphone applications. To describe the context of our evaluation, the tools and the test model library we have developed for the evaluation are also presented. The library contains test models for basic S60 applications, such as camera, contacts, etc. The tools include an on-line test generator that produces sequences of so called keywords to be executed on the test targets. In our evaluation, we managed to find over 20 defects from applications that had been on the market for several months. We also describe the problems we faced during the evaluation.

Testing Non-Functional Requirements with Aspects: An Industrial Case Study

Testing is regarded as one of the most resource consuming tasks of an average software project. A common goal of testing related activities is to make sure that requirements are satisfied by the implementation. Although existing tools are often effective in functional testing, emerging nonfunctional requirements set new demands. Aspect-oriented techniques offer a promising approach for capturing such issues under verification. However, prior to industrial adoption more pragmatic guidelines on applying aspects are required. In this paper, we evaluate aspect-oriented techniques in testing non-functional requirements of an industrial system. In addition, we discuss the types of requirements that lend themselves for more efficient testing using aspects than conventional techniques.