Josef Pichler

A Script-Based Testbed for Mobile Software Frameworks

Software testing is essential and takes a large part of resources during software development. This motivates automating software testing as far as possible. Frameworks for automating unit testing are approved and applied for a plethora of programming languages to write tests for small units in the same programming language. Both constraints, unit size and programming language, inhibit automation of software testing in domain of mobile software frameworks. This circumstance has motivated the development of a new testbed for a framework in the domain of mobile systems. In this paper, we describe requirements and challenges in testing mobile software frameworks in general and present a novel testbed for the APOXI framework that addresses these requirements. The main ideas behind this testbed are the usage of a scripting language to specify test cases and to incorporate domain-specific aspects on the language level. The testbed facilitates component and system testing but can be used for unit testing as well.

How to Test the Intangible Properties of Graphical User Interfaces

In this paper we describe our experience from developing and testing a visual graphical user interface (GUI) editor for mobile and multimedia devices. Testing of the editors highly interactive user interface is critical for its success, yet remains a challenge due to the specification of often intangible quality characteristics of the GUI and its proneness to change. The approach we provide is supporting exploratory testing of the GUI with tools integrated with the tested object. Thus a step-by-step guide for manual exploratory testing can be enhanced with automated elements that directly manipulate the status of the editor, access internal properties of the GUI, and record interactions for bug reporting.

Towards tool support for analyzing legacy systems in technical domains

Software in technical domains contains extensive and complex computations in a highly-optimized and unstructured way. Such software systems developed and maintained over years are prone to become legacy code based on old technology and without accurate documentation. We have conducted several industrial projects to reengineer and re-document legacy systems in electrical engineering and steel making domains by means of self-provided techniques and tools. Based on this experience, we derived requirements for a toolkit to analyze legacy code in technical domains and developed a corresponding toolkit including feature location and static analysis on a multi-language level. We have applied our approach and toolkit for software systems implemented in the C++, Fortran, and PL/SQL programming languages and illustrate main benefits of our approach from these experiences.

Documentation generation from annotated source code of scientific software: position paper

There is a widespread agreement in the scientific computing community that documentation positively influences software quality and thereby helps to mitigate the risk of project failure. We accompanied the introduction of a documentation generator within an industrial scientific computing project in order to automatically extract documentation from annotated C++ source code. Over a period of one year we extended and adopted the existing documentation generator RbG and performed some initial experiments to find out whether documentation generators can increment understandability and overall software quality of a scientific software system. However, although technically mature and adequate for the intended documentation tasks RbG was finally not used and the required documentation was created manually. In this paper we report on the adaption of the RbG, why it failed in this case study but potentially could improve software productivity and quality of scientific software.

Domain-specific modeling in industrial automation: challenges and experiences

Domain-specific modeling promises to close the gap between an application domain and a solution domain. As such it enables domain experts to directly model an application by means of a domain-specific language and to fully generate a final software product from the models. The advantages of domain-specific modeling have been demonstrated from several industrial case studies in various domains. However, domain-specific modeling is rarely applied in industrial automation. We have designed and developed two DSM solutions in the domains of injection molding machines and robot welding in order to enable domain experts to directly program in both domains without detailed software development expertise. In this paper we present two DSM tools, discuss challenges and experiences during design and development of both tools and draw some general insights about adapting DSM for industrial automation.

Towards reverse engineering of intermediate code for documentation generators

We describe the motivation, approach and first experience from reverse engineering Common Intermediate Language (CIL) for the purpose of documentation generation. Instead of parsing source code implemented in different programming languages, we reverse engineer CIL code and thereby enable documentation generation for all programming languages that can be compiled into CIL code. Initial results show that we are able to generate documents in the same quality as compared to directly analyzing source code. To overcome initial shortcomings we introduce additional preprocessing in form of AST refactoring which is not required when analyzing source code.

Multi-language re-documentation to support a COBOL to Java migration project

Software migration projects need precise and up-to-date documentation of the software system to be migrated. Missing or outdated documentation hampers the migration process and compromises the overall quality of the resulting new software system. Moreover, if documentation is missing in the first place and no additional effort is undertaken to document the new software system, future maintenance and evolution tasks are burdened right from the beginning. Therefore, we apply an automatic re-documentation approach that uses a single tool chain to generate documentation for the software to be migrated and the transformed software system. By this, we not only support an ongoing COBOL to Java migration project at one of our industry partners but as well create the foundations to continuously generate up-to-date documentation for the new software system.

Automated Static Analysis of Unit Test Code

Automated unit tests are an essential software quality assurance measure that is widely used in practice. In many projects, thus, large volumes of test code have co-evolved with the production code throughout development. Like any other code, test code too may contain faults, affecting the effectiveness, reliability and usefulness of the tests. Furthermore, throughout the software systems ongoing development and maintenance phase, the test code too has to be constantly adapted and maintained. To support detecting problems in test code and improving its quality, we implemented 42 static checks for analyzing JUnit tests. These checks encompass best practices for writing unit tests, common issues observed in using xUnit frameworks, and our experiences collected from several years of providing trainings and reviews of test code for industry and in teaching. The checks can be run using the open source analysis tool PMD. In addition to a description of the implemented checks and their rationale, we demonstrate the applicability of using static analysis for test code by analyzing the unit tests of the open source project JFreeChart.