Automatically generating runtime monitors from tests

A large portion of the software development industry relies on testing as the main technique for quality assurance while other techniques which can provide extra guarantees are largely ignored. A case in point is runtime verification which provides assurance that a system’s behaviour is correct at runtime. Compared to testing, this technique has the advantage of checking the actual runs of a system rather than a number of representative testcases.peer-reviewe

Model extraction and test generation from JUnit test suites

In this paper we describe how to infer state machine models of systems from legacy unit test suites, and how to generate new tests from those models. The novelty of our approach is to combine control dependencies and data dependencies in the same model, in contrast to most other work in this area. Combining both kinds of dependency helps us to build more expressive models, which in turn allows us to produce smarter tests. We illustrate those techniques with examples from our implementation, the James tool, designed to apply these techniques in practice to Java code and tests

Synapse: automatic behaviour inference and implementation comparison for Erlang

In the open environment of the world wide web, it is natural that there will be multiple providers of services, and that these service provisions — both specifications and implementations — will evolve. This multiplicity gives the user of these services a set of questions about how to choose between different providers, as well as how these choices work in an evolving environment. The challenge, therefore, is to concisely represent to the user the behaviour of a particular implementation, and the differences between this implementation and alternative versions. Inferred models of software behaviour – and automatically derived and graphically presented comparisons between them – serve to support effective decision making in situations where there are competing implementations of requirements. In this paper we use state machine models as the abstract representation of the behaviour of an implementation, and using these we build a tool by which one can visualise in an intuitive manner both the initial implementation and the differences between alternative versions. In this paper we describe our tool Synapse which implements this functionality by means of our grammar inference tool StateChum and a model-differencing algorithm. We describe the main functionality of Synapse, and demonstrate its usage by comparing different implementations of an example program from the existing literature

Aplicación de técnicas de pruebas automáticas basadas en propiedades a los diferentes niveles de prueba del software

[Resumen]Las pruebas son una de las actividades clave en el desarrollo de software, puesto que ayudan a detectar defectos que, de otro modo, pasarían desapercibidos hasta que el software sea desplegado. Sin embargo, al contrario que en otras etapas del ciclo de vida del software, como son el análisis, el diseño o la implementación, para las que existen metodologías y técnicas bien definidas y ampliamente aceptadas en la comunidad informática, junto con herramientas que permiten llevar a cabo dichas tareas, no hay una uniformidad sobre las metodologías, técnicas o herramientas a utilizar para llevar a cabo las pruebas del software de una manera eficiente y eficaz. Este hecho provoca que, muchas veces, éstas sean omitidas o no realizadas con todo el rigor necesario. Esta tesis presenta una aproximación, basada en propiedades y puramente funcional, para la realización de las pruebas del software, que intenta paliar estos problemas. Para ello, se definen metodologías y técnicas de pruebas, integradas en el proceso de desarrollo de software, que pueden ser aplicadas a los diferentes niveles de pruebas del software. Así, pueden utilizarse para llevar a cabo pruebas unitarias y de componente, en las que se comprueba que cada componente individual se comporta de la manera esperada, pruebas de integración, que comprueban las interacciones de los componentes que forman parte de un sistema, y pruebas de sistema, que se encargan de comprobar diferentes aspectos del sistema como un todo. Además, se utiliza un lenguaje de especificación de pruebas común en todas las aproximaciones desarrolladas, el lenguaje de programación funcional Erlang, y las metodologías se definen de manera independiente a la estructura del software concreto a probar o el lenguaje de programación en el que éste esté implementado. Por último, cabe destacar que el uso de estas metodologías y técnicas de pruebas se ilustra a través de un ejemplo industrial, en concreto, el sistema VoDKATV. Este sistema ofrece acceso a servicios multimedia (canales de televisión, videoclub, aplicaciones, juegos, entre otros) a través de diferentes tipos de dispositivos, como, por ejemplo, televisiones, ordenadores, tabletas o móviles. Con respecto a la arquitectura, el sistema VoDKATV está compuesto por múltiples componentes implementados con diferentes tecnologías (Java, Erlang, C, etc.) que se integran entre sí. La complejidad de este sistema permite ilustrar cada una de las metodologías y técnicas de pruebas desarrolladas con un ejemplo real

Erlang programok statikus elemzése és szeletelése

A funkcionális programozási nyelvek terjedésének velejárója, hogy felmerül az igény olyan eszközökre, amelyek a fejlesztési folyamatot támogatják. Ezek lehetnek futási idejű eszközök, vagy olyanok, melyek csupán a forráskód elemzésével kı́nálnak hasznos információkat a fejlesztők számára. Az Erlang ipari környezetben is gyakran használt funkcionális programozási nyelv. A RefactorErl egy statikus elemző és refaktoráló eszköz Erlanghoz, mely számos transzformációt biztosı́t a forráskód jelentésmegőrző átalakı́tására, másrészről kiterjedt statikus elemzőkészlettel segı́ti a fejlesztőket a mindennapos tevékenységükben. Kutatásomban olyan elemzési módszerekkel foglalkoztam, amelyek segı́tségével az Erlang programok forráskódjában rejlő összetett összefüggések nyerhetők ki. Ezek az eredmények pedig további magasabb szintű elemzések alapját képzik. Az ismertetett eredményeim a vezérlés és az Erlang folyamatok közötti kapcsolatok elemzéséhez kapcsolódnak. A dolgozatomban Erlang programok vezérlésfolyam-gráfját adtam meg, amely tartalmazza a programok végrehajtása során előálló lehetséges végrehajtási utakat. A gráfot a nyelv szintaktikus kategóriáihoz rendelt formális szabályok segı́tségével definiáltam, amelyek a nyelv szemantikájának megfelelően adják meg a vezérlésfolyam-gráf éleit. A vezérlésfolyam-gráf felhasználásra került további elemzésekhez is, mint például a párhuzamosı́tható komponensek azonosı́tása. A vezérlésfolyam-gráf, illetve a benne foglalt információk felhasználhatóak a forráskódban történő változások hatáselemzéséhez. A vezérlésfüggőségi gráf egy kompaktabb reprezentáció, amely a vezérlési utakban lévő szekvenciák eliminálásával már csak a kifejezések közötti közvetlen függőségeket tartalmazza. Megadtam Erlang programokra a vezérlésfüggőségi gráfot, amelyet adatfüggőségi információkkal egészı́tettem ki. Az ı́gy definiált Erlang függőségi gráf felhasználható gráf alapú statikus programszeleteléshez. A definiált infrastruktúrára épı́tve megadtam egy hatáselemzés alapú teszteset szelekciós módszert. A módszer azon tesztesetek halmazát adja meg, amelyek érintettek lehetnek a változtatás/transzformáció kapcsán. Azaz a változtatás hatása elterjedhet a tesztelt funkcionalitásba. Az elemzés nem csak a transzformációk hatásának elemzésére, hanem tetszőleges változás elemzésére is használható. Dolgozatomban bemutattam Erlang programok egy statikus kommunikációs modelljét. Megadtam azokat az algoritmusokat, melyek segı́tségével felderı́thetőek az elindı́tott Erlang folyamatok és a köztük aszinkron üzenetküldésekkel lebonyolı́tott kommunikáció. A modellbe felvettem olyan rejtett kommunikációs elemeket is, mint a közös osztott memóriának tekinthető Erlang Term Storage (ets) táblák használata. Megadtam azokat a statikus elemzési algoritmusokat, melyek felhasználásával kiegészı́thető a kommunikációs gráf speciális Erlang folyamatokkal (például generikus szerverek) és az interfészeiken keresztül történő rejtett kommunikációval. A kommunikációs gráf kiválóan használható a kódban rejlő összefüggések megjelenı́tésére, kódmegértés, konkurenciából fakadó hibakeresés támogatásához. Ugyanakkor felhasználható konkurens programok változásához köthető hatáselemzés pontosı́tásához is

Model construction, evolution, and use in testing of software systems

The ubiquity of software places emphasis on the need for techniques that allow us to ensure that software behaves as we expect it to behave. The most widely-used approach to ensuring software quality is unit testing, but this is arguably not a very efficient solution, since each test only checks that the software behaves as expected in one single scenario. There exist more advanced techniques, like property-based testing, model-checking, and formal verification, but they usually rely on properties, models, and specifications. One source of friction faced by testers that want to use these advanced techniques is that they require the use of abstraction and, as humans, we tend to find it more difficult to think of abstract specifications than to think of concrete examples. In this thesis, we study how to make it easier to create models that can be used for testing software. In particular, we research the creation of reusable models, ways of automating the generalisation of code and models, and ways of automating the generation of models from legacy unit tests and execution traces. As a result, we provide techniques for generating tests from state machine models, techniques for inferring parametrised state machines from code, and refactorings that automate the introduction of abstraction for property-based testing models and code in general. All these techniques are illustrated with concrete examples and with open-source implementations that are publicly available

Model construction, evolution, and use in testing of software systems

The ubiquity of software places emphasis on the need for techniques that allow us to ensure that software behaves as we expect it to behave. The most widely-used approach to ensuring software quality is unit testing, but this is arguably not a very efficient solution, since each test only checks that the software behaves as expected in one single scenario. There exist more advanced techniques, like property-based testing, model-checking, and formal verification, but they usually rely on properties, models, and specifications. One source of friction faced by testers that want to use these advanced techniques is that they require the use of abstraction and, as humans, we tend to find it more difficult to think of abstract specifications than to think of concrete examples. In this thesis, we study how to make it easier to create models that can be used for testing software. In particular, we research the creation of reusable models, ways of automating the generalisation of code and models, and ways of automating the generation of models from legacy unit tests and execution traces. As a result, we provide techniques for generating tests from state machine models, techniques for inferring parametrised state machines from code, and refactorings that automate the introduction of abstraction for property-based testing models and code in general. All these techniques are illustrated with concrete examples and with open-source implementations that are publicly available

Robust Communications in Erlang

Erlang is a dynamically-typed functional and concurrent programming language lauded by its proponents for its relatively simple syntax, process isolation, and fault tolerance. The functional aspect has rich features like pattern matching and tail-call optimisation, while the concurrent aspect uses isolated processes and asynchronous message passing to share state between system components. The two meet with pattern matching on mailboxes, which allows for a process to pick a message from its mailbox - potentially out of order - based on its structure, value, type, or a mixture thereof. A strongly and dynamically typed language like Erlang can experience many kinds of runtime errors, such as ill-typed operands to arithmetic operators. The interaction between Erlang's type system and process mailboxes can lead to a more subtle runtime error which is harder to detect: orphan messages. As the types of messages are not checked either at compile time or runtime, a process can be sent a message which it will never receive. Essentially, non-trivial type discrepancies in Erlang programs can cause subtle bugs when communication is involved. These problems can be hard to detect and fix, with current solutions such as extensive testing and exhaustive model checking. This thesis reports on work to detect communication-related type discrepancies in Erlang programs. A fragment of the Core Erlang intermediate format is modelled formally so that we can reason about the out-of-order communication in Erlang systems, particularly the dependencies between sent messages when determining whether orphan messages exist. Afterwards, a sub-typing relation based on Erlang's type system is introduced to clearly define the notion of an orphan message, forming the foundation of a system for automatic detection via a mix of static analysis and runtime verification. This culminates in automatic tooling to detect certain cases of communication discrepancies via static analysis, and automatic instrumentation of concurrent programs to detect and recover from more complicated cases at runtime