Laura M. Castro

Testing Erlang data types with quviq quickcheck

When creating software, data types are the basic bricks. Most of the time a programmer will use data types defined in library modules, therefore being tested by many users over many years. But sometimes, the appropriate data type is unavailable in the libraries and has to be constructed from scratch. In this way, new basic bricks are created, and potentially used in many products in the future. It pays off to test such data types thoroughly. This paper presents a structured methodology to follow when testing data types using Quviq QuickCheck, a tool for random testing against specifications. The validation process will be explained carefully, from the convenience of defining a model for the datatype to be tested, to a strategy for better shrinking of failing test cases, and including the benefits of working with symbolic representations. The leading example in this paper is a data type implemented for a risk management information system, a commercial product developed in Erlang, that has been used on a daily basis for several years.

ARMISTICE: an experience developing management software with Erlang

In this paper, some experiences of using the concurrent functional language Erlang to implement a classical vertical application, a risk management information system, are presented. Due to the complex nature of the business logic and the interactions involved in the client/server architecture deployed, traditional development techniques are unsatisfactory. First, the nature of the problem suggests an iterative design approach. The use of abstractions (functional patterns) and compositionality (both functional and concurrent composition) have been key factors to reduce the amount of time spent adapting the system to changes in requirements. Despite our initial concerns, the gap between classical software engineering and the functional programming paradigm has been successfully fullfiled.

Assessing the effects of introducing a new software development process: a methodological description

In this article, we report from a 22-months long action research study in which we evaluate the usefulness of a set of software development tools in an industrial setting, a small software company. We focus on how developers in the industry use and adopt these tools, what expectations they have on them, how the tools can be improved, and how the adoption process itself can be improved. We describe these change processes from a methodological perspective, how we monitored the processes, how we reviewed the outcomes, and the strategies that we applied. We show how the processes evolved, intermediate results, and the steps that were taken along the way based on the outcomes. We believe that the described study may inspire other tool-developers and/or researchers to organize similar studies to further our understanding of the complex processes involved in the adoption of software development tools in industry.

On modelling agent systems with erlang

Multi-agent systems are a kind of concurrent distributed systems. In this work, some guidelines on how to create multi-agent systems using Erlang are presented. The modelled system supports cooperation among agents by plan exchange, reconfiguration and has a certain fault-tolerance. The distributed and concurrent functional programming Erlang, together with OTP platform, allows the creation of high-availability and fault-tolerant concurrent and distributed systems, and it seems to be an interesting framework for implementing multi-agent systems.

Testing Data Consistency of Data-Intensive Applications Using QuickCheck

Many software systems are data-intensive and use a data management systems for data storage, such as Relational Database Management Systems (RDBMS). RDBMSs are used to store information in a structured manner, and to define several types of constraints on the data, to maintain basic consistency. The RDBMSs are mature, well tested, software products that one can trust to reliably store data and keep it consistent within the defined constraints. There are, however, scenarios in which passing the responsibility of consistency enforcement to the RDBMS is not convenient, or simply not possible. In such cases, the alternative is to have that responsibility at the business logic level of the system. Hence, from the point of view of testing data-intensive applications, one of the most relevant aspects is to ensure correctness of the business logic in terms of data consistency. In this article, we show how QuickCheck, a tool for random testing against specifications, can be used to test the business logic of an application to increase confidence on data integrity. We build an abstract model of the data containing the minimum information necessary to create meaningful test cases, while keeping its state substantially smaller than the data in the complete database. From the abstract model we automatically generate and execute test cases which check that data constraints are preserved.

Automatic generation of test models and properties from UML models with OCL constraints

Model-Based Testing and Property-Based Testing are two testing methodologies that usually facilitate the automation of the generation of test cases, using either models or properties as basis to derive complete test suites. In doing so, they also contribute to reduce both the source code needed for testing purposes and the time spent on writing those tests, hence saving effort and increasing maintainability. In this paper, we describe how to generate complete property-based test suites automatically translated from a model that describes the system under test, specifically a UML model with OCL constraints. The proposed approach can be applied to both stateless and stateful components. We have used QuickCheck, an automatic property-based testing tool for test case generation, execution and diagnosis, as support tool. Our method produces QuickCheck executable test models as output, so we use the same tool to run and evaluate them. As part of our work, we analyze and discuss the advantages and disadvantages of our approach in contrast to writing test suites manually.

A Practical Methodology for Integration Testing

The recognition of the importance of verification and validation tasks, within the software development process or life cycle, is growing significantly. Still, its unarguably complexity and the great amount of time and resources needed to perform testing properly, together with the industrys unawareness of the most powerful and versatile testing tools, makes that, in practise, these activities are often underestimated and diminished, or just simply ignored and skipped, sometimes due to clients demands or hard time-to-market constraints. Integration testing is a specific kind of testing, which is gathering more and more attention within a software engineering industry that has been for quite some time already relying in structuring application and systems in different modules and components. In this paper, we propose a generic and re-usable model-based methodology for testing integration between different components, and illustrate it using a real case study, LiveScheduler, a scheduler and control tool for transmissions on live broadcast channels through the Internet.

Feasibility of Property-Based Testing for Time-Dependent Systems

As needed as testing is in software development to ensure the construction of quality products, it has also been traditionally forgotten or neglected, mostly due to its cost. However, in the recent past industry is acknowledging the far greater costs of not testing, or testing in a non-efficient and non-effective manner, particularly when the monetization of a software product is involved. This has lead to new approaches, techniques and tools for software testing, such as property-based testing. In this paper, we present how we applied this advanced technique, property-based testing, to verify a system where the handling of temporal information is critical: a distributed system for advertisement transmission over a digital TV network.

Model-based testing of data types with side effects

Data types are the core of many applications, and libraries offering implementations of data types should better be solid and well tested. Testing purely functional data types with QuickCheck provides a complete test method for data types, but establishing a complete test method for data types with side-effects is still an open issue. In this paper we show how we can use a stateful QuickCheck model to establish a complete test method for any data type. Considering side effects allows us to move from the purely functional world to the imperative world, as needed to face the testing of data types implementations in languages such as C. We therefore applied our method to some of the data types provided by the well-known GNOME Glib library.

Efficient Discovery of Widely Distributed and Non-volatile Resources on DHTs

In recent years, a new generation of structured and decentralized P2P CDNs based on distributed hash tables (DHTs) has emerged. Nowadays, DHT algorithms are a powerful building block when designing distributed behaviors. However, sometimes DHTs are not flexible enough and problems arise when an efficient lookup in the DHT structure itself -instead of in the stored data- is required. Our motivation scenario is the resource discovery problem in a decentralized and distributed caching architecture, deployed in a set of clusters built from cheap off-the-shelf computers organized in a DHT overlay network. In this paper we present the design of a resource discovery service layered on the underlying DHT and based on the combination of(1) an spanning-tree built mapping DHT nodes to their parents in a bottom-up fashion, and (2) a set of routing indices which allow nodes to efficiently lookup other nodes in the DHT overlay network, matching some resource constraints This service does not alter the underlying DHT behavior, it scales to large wide area systems and it tracks both relatively static and frequently changing resources. Furthermore, the results of the experiments conducted to evaluate the good performance and scalability of the architecture are also presented.