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

Detalhes bibliográficos
Autor(a) principal: Dalepiane, Mateus Felipin
Data de Publicação: 2014
Tipo de documento: Trabalho de conclusão de curso
Idioma: eng
Título da fonte: Repositório Institucional da UFRGS
Texto Completo: http://hdl.handle.net/10183/110759
Resumo: 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.
id UFRGS-2_7282e77b9684f55c7b1d635fd25bb93c
oai_identifier_str oai:www.lume.ufrgs.br:10183/110759
network_acronym_str UFRGS-2
network_name_str Repositório Institucional da UFRGS
repository_id_str
spelling Dalepiane, Mateus FelipinCota, Erika FernandesHeckeler, Patrick2015-02-27T01:57:41Z2014http://hdl.handle.net/10183/110759000953088Este 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.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.application/pdfengMicroeletrônicaUmlState machineTest case generationEnterprise architectImplementation of a model based test case generator for UML state machinesinfo:eu-repo/semantics/publishedVersioninfo:eu-repo/semantics/bachelorThesisUniversidade Federal do Rio Grande do SulInstituto de InformáticaPorto Alegre, BR-RS2014Ciência da Computação: Ênfase em Engenharia da Computação: Bachareladograduaçãoinfo:eu-repo/semantics/openAccessreponame:Repositório Institucional da UFRGSinstname:Universidade Federal do Rio Grande do Sul (UFRGS)instacron:UFRGSORIGINAL000953088.pdf000953088.pdfTexto completo (inglês)application/pdf1155611http://www.lume.ufrgs.br/bitstream/10183/110759/1/000953088.pdfd603b7e2576f03c15196493184d729eeMD51TEXT000953088.pdf.txt000953088.pdf.txtExtracted Texttext/plain57867http://www.lume.ufrgs.br/bitstream/10183/110759/2/000953088.pdf.txt7ae59bc2d9aa01fd38218d0ae1da3196MD5210183/1107592021-05-07 05:16:22.955723oai:www.lume.ufrgs.br:10183/110759Repositório de PublicaçõesPUBhttps://lume.ufrgs.br/oai/requestopendoar:2021-05-07T08:16:22Repositório Institucional da UFRGS - Universidade Federal do Rio Grande do Sul (UFRGS)false
dc.title.pt_BR.fl_str_mv Implementation of a model based test case generator for UML state machines
title Implementation of a model based test case generator for UML state machines
spellingShingle Implementation of a model based test case generator for UML state machines
Dalepiane, Mateus Felipin
Microeletrônica
Uml
State machine
Test case generation
Enterprise architect
title_short Implementation of a model based test case generator for UML state machines
title_full Implementation of a model based test case generator for UML state machines
title_fullStr Implementation of a model based test case generator for UML state machines
title_full_unstemmed Implementation of a model based test case generator for UML state machines
title_sort Implementation of a model based test case generator for UML state machines
author Dalepiane, Mateus Felipin
author_facet Dalepiane, Mateus Felipin
author_role author
dc.contributor.author.fl_str_mv Dalepiane, Mateus Felipin
dc.contributor.advisor1.fl_str_mv Cota, Erika Fernandes
dc.contributor.advisor-co1.fl_str_mv Heckeler, Patrick
contributor_str_mv Cota, Erika Fernandes
Heckeler, Patrick
dc.subject.por.fl_str_mv Microeletrônica
Uml
topic Microeletrônica
Uml
State machine
Test case generation
Enterprise architect
dc.subject.eng.fl_str_mv State machine
Test case generation
Enterprise architect
description 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.
publishDate 2014
dc.date.issued.fl_str_mv 2014
dc.date.accessioned.fl_str_mv 2015-02-27T01:57:41Z
dc.type.status.fl_str_mv info:eu-repo/semantics/publishedVersion
dc.type.driver.fl_str_mv info:eu-repo/semantics/bachelorThesis
format bachelorThesis
status_str publishedVersion
dc.identifier.uri.fl_str_mv http://hdl.handle.net/10183/110759
dc.identifier.nrb.pt_BR.fl_str_mv 000953088
url http://hdl.handle.net/10183/110759
identifier_str_mv 000953088
dc.language.iso.fl_str_mv eng
language eng
dc.rights.driver.fl_str_mv info:eu-repo/semantics/openAccess
eu_rights_str_mv openAccess
dc.format.none.fl_str_mv application/pdf
dc.source.none.fl_str_mv reponame:Repositório Institucional da UFRGS
instname:Universidade Federal do Rio Grande do Sul (UFRGS)
instacron:UFRGS
instname_str Universidade Federal do Rio Grande do Sul (UFRGS)
instacron_str UFRGS
institution UFRGS
reponame_str Repositório Institucional da UFRGS
collection Repositório Institucional da UFRGS
bitstream.url.fl_str_mv http://www.lume.ufrgs.br/bitstream/10183/110759/1/000953088.pdf
http://www.lume.ufrgs.br/bitstream/10183/110759/2/000953088.pdf.txt
bitstream.checksum.fl_str_mv d603b7e2576f03c15196493184d729ee
7ae59bc2d9aa01fd38218d0ae1da3196
bitstream.checksumAlgorithm.fl_str_mv MD5
MD5
repository.name.fl_str_mv Repositório Institucional da UFRGS - Universidade Federal do Rio Grande do Sul (UFRGS)
repository.mail.fl_str_mv
_version_ 1801224479602376704