Implementation of a model based test case generator for UML state machines

Abstract

This work proposes the integration of a model-based test case generation framework for UML state machines into a commercial modeling tool. The framework was proposed by Heckeler et al. in 2013, and generates test cases for robustness testing of UML state machines modeled within Enterprise Architect. Heckeler’s work uses exported model files from Enterprise Architect (EA) to access the modeled state machine information. The test case generation is composed of three main tasks: abstract test case generation, executable test case generation and test cases execution control. The generation of the abstract test cases, called path lists, is responsible for extracting all the necessary information directly from the model, generate a new representation of the transition system that complies with the boolean satisfiability solver used to resolve transition guards, and run queries on this transition system to generate all abstract test cases in order to satisfy the target coverage. These abstract test cases are lists of transitions that should be executed in the state machine. The second task is responsible for transforming the path lists into executable test cases. In order to generate robustness tests, this task also extends the path lists with calls to all undefined transitions, using informations from the model. The executable test cases are based on CppUnit test suite. Besides generating the test cases this task also generate configuration scripts to control Gnu Debugger (GDB) during test execution. These scripts include commands for starting and stopping the recording needed for reverse transition execution, and are used to read the state encoding variables during runtime. The third task runs the executable test cases, uses GDB to extract the values necessary for verification and to accelerate the test case execution using GDB reverse execution. When an error is detected, this task outputs a trace that shows the triggers call order to facilitate the error reproduction. This work proposes an integrated solution within Enterprise Architect as a plugin, using EA Application Program Interface, in order to improve the end-user experience. As an initial integration work, it focuses on the integration of the first task, the abstract test case generation. In order to achieve this initial integration, this work proposes a C# state machine model to store all data extracted from EA, presented as a class diagram, and a software architecture to be used within the plugin, that can easily be extended to include both new test case generation techniques and test case coverages into it. The integrated test case generator validation is done using the same two state machines used in the framework proposal by Heckeler, by comparing the path list output from the previously implementation with the output from the EA integrated solution. The first state machine is a hash table implementation that comprises 3 states and 11 transitions. The second state machine is a traffic light controller implementation that comprises 11 states and 19 transitions.

Este trabalho propõe a integração de um framework de geração de casos de teste baseado em modelos de máquinas de estados UML com uma ferramenta comercial de modelagem. O framework foi proposto por Heckeler et al. em 2013, e gera casos de teste para teste de robustês de máquinas de estados UML modeladas utilizando o Enterprise Architect. O trabalho do Heckeler utiliza arquivos exportados do Enterprise Architect (EA) para acessar as informações da máquina de estados modelada. A geração de casos de teste é composta por três passos: geração de casos de teste abstratos, geração de casos de teste executáveis e controle da execução dos casos de teste. A geração dos casos de teste abstratos, chamados de path lists, é responsável por extrair todas as informações necessárias diretamente do modelo, gerar uma nova representação do sistema de transição conforme a representação do solucionador de satisfazibilidade booliana utilizado para resolver guardas de transição, e executar consultas sobre este sistema de transição para gerar todos os casos de teste abstratos a fim de satisfazer a cobertura desejada. Esses casos de teste abstratos são listas de transições que devem ser executadas na máquina de estados. O segundo passo é responsável por transformar as path lists em casos de teste executáveis. A fim de gerar testes de robustez, este passo também estende as path lists com chamadas para todas as transições não definidas em cada estado, usando informações do modelo. Os casos de teste executáveis são baseados em suíte de teste CppUnit. Além de gerar os casos de teste, este passo também gera scripts de configuração para controlar o Gnu Debugger (GDB) durante a execução do teste. Esses scripts incluem comandos para iniciar e parar a gravação necessário para a execução reversa de transição, e são usados para ler as variáveis de codificação dos estados durante a execução. O terceiro passo executa os casos de teste executáveis, usa o GDB para extrair os valores necessários para a verificação, e acelera a execução dos casos de teste utilizando o recurso de execução reversa do GDB. Quando um erro é detectado, este passo emite um trace que mostra as transições que foram chamadas, para permitir a reprodução posterior do erro. Este trabalho propõe uma solução integrada dentro do Enterprise Architect como um plugin, utilizando a interface de programação do EA, a fim de melhorar a usabilidade para o usuário final. Como um trabalho de integração inicial, este trabalho foca na integração do primeiro passo, a geração de casos de teste abstratos. Para realizar essa integração inicial, este trabalho propõe um modelo em C# para máquinas de estados para armazenar todos os dados extraídos de EA, apresentado em um diagrama de classes, e uma arquitetura de software para ser utilizada na implementação do plugin, que pode ser facilmente estendida para incluir tanto novos técnicas de geração de casos de teste quanto coberturas do caso de teste. A validação do gerador de casos de teste integrado é feita utilizando as mesmas duas máquinas de estados utilizadas por Heckeler na proposta do framework, comparando-se as path lists geradas pela implementação anterior com as geradas pela solução integrada com ao EA. A primeira máquina de estados é a implementação de uma tabela hash composta por 3 estados e 11 transições. A segunda máquina de estado é a implementação de um controlador de semáforo que compreende 11 estados e 19 transições.