Para sistematizar os testes e contornar as restrições de tempo e custo associadas à atividade de teste, diversas técnicas, critérios e ferramentas têm sido desenvolvidas. Além disso, visando ao estabelecimento de uma estratégia de teste incremental, que apresente baixo custo de aplicação e alta eficácia em revelar a presença de erros, estudos teóricos e empíricos vêm sendo conduzidos pela comunidade de teste. O presente trabalho está inserido nesse contexto e tem como objetivo a realização de estudos empíricos para comparar a adequação entre os critérios baseados em erros - Análise de Mutantes (teste de unidade) e Mutação de Interface (teste de integração) - visando ao estabelecimento de estratégias de teste de baixo custo e eficazes, que englobem todo o ciclo de desenvolvimento de software. Nessa perspectiva, algumas estratégias incrementais de aplicação dos operadores de mutação de unidade e de integração são definidas, explorando o aspecto complementar dos critérios baseados em mutação, reduzindo com isso os custos da atividade de teste durante as fases do teste de unidade e de integração, sem comprometer sua qualidade. Ainda, um conjunto essencial de operadores de mutação para o critério Mutação de Interface é apresentado. / Techniques, criteria and tools have been developed and investigated making the testing activity more systematic and aiming at overcoming associated time and cost constraints. Pursuing the establishment of an incremental, low-cost and effective testing strategy, theoretical and empirical studies have been conducted by the testing community. The work proposed here is within this context and aims to conduct empirical studies for evaluating the adequacy between error based criteria - Mutation Analysis (unit testing) and Interface Mutation (integration testing). Therefore, this work intends to establish low-cost and effective testing strategies that would comprise all software development cycle. In this perspective, some incremental testing strategies for mutant operators application are defined exploring the complementary aspects of unit and integration error based criteria, reducing theirs costs without losses in testing quality. In this scope, an essential mutant operators set for Interface Mutation criterion is characterized.

Paradigmas e técnicas de desenvolvimento como a programação Orientada a Objetos (OO) e a programação Orientada a Aspectos (OA) procuram melhorar os níveis de reuso e manutenibilidade na produção de software. Contudo, com a introdução de mecanismos com maior poder de expressividade e, consequentemente, a possível introdução de novos tipos de defeitos, a utilização de linguagens OO e OA pode se tornar um obstáculo ao invés de um auxílio ao desenvolvimento de software. Para lidar com esse problema, nesta dissertação é proposta uma abordagem de teste estrutural de integração para programas orientados a objetos e a aspectos implementados em Java e AspectJ. É definido um modelo de fluxo de controle e de dados baseado no bytecode Java { chamado Grafo Def-Uso Contextual (ou Contextual Def-Use graph) - que é uma abstração formada pela integração dos grafos Def-Uso Orientados a Aspectos (AODU) da unidade sob teste com todas as unidades que interagem direta ou indiretamente com ela até um nível de profundidade de interação máximo ou definido pelo testador. São defiidos três critérios de teste: todos-nós-integrados-Nd, todas-arestas-integradas-Nd e todos-usos-integrados-Nd. Para automatizar o uso do modelo e critérios propostos, a ferramenta JaBUTi/AJ foi estendida. Exemplos de usos são discutidos e, por meio de um estudo experimental, uma análise de aplicabilidade da abordagem proposta é apresentada / Development paradigms and techniques such as Object-Oriented (OO) programming and Aspect-Oriented (AO) programming aim at improving reuse levels and maintenability in the software production. However, due to the introduction of mechanisms to support a greater power of expressiveness and, consequently, possible introduction of new type of faults, the use of OO and AO languages might become an obstacle instead of a benefit in the software development. To deal with these problems, in this dissertation is presented an integration structural testing approach for objectand aspect-oriented software based on Java and AspectJ. It is defined a control- and data- ow model based on Java bytecode { called Contextual Def-Use graph { that is an abstraction composed by the integration of Aspect-Oriented Def-Use graphs (AODU) of the unit under testing with the units triggered by the execution of the unit under testing considering either a maximum interaction depth level or an interaction depth level previously defined by the tester. Three testing criteria are also defined: all-integrated-nodes-Nd, all-integrated-edges-Nd and all-integrated-uses-Nd. To automate the use of the model and the testing criteria, the JaBUTi/AJ tool was extended. Usage examples are discussed to explain the approach and an exploratory study is conducted to evaluate the applicability of the proposed approach

O mecanismo de tratamento de exceções disponível em linguagens orientadas a objetos está sendo cada vez mais utilizado e representa cerca de 8% das linhas de código em programas escritos com linguagens de terceira geração, de acordo com algumas pesquisas. No entanto, este mecanismo está entre os menos compreendido pelos desenvolvedores e menos testado. A dificuldade de testar exceções aumenta na fase de teste de integração, porque exceções lançadas em um determinado nível e não tratadas podem subir na hierarquia de chamada. O uso de aspectos também pode introduzir novos tipos de defeitos, como por exemplo um adendo pode inserir lançamentos de exceções no programa sem que exista algum tratamento previsto para elas. Este trabalho apresenta uma proposta para testes de integração estrutural de fluxos de exceções de programas Java e AspectJ. Isto é feito propondo-se alterações na representação do fluxo de exceção no grafo de fluxo de controle integrado e propondo-se novos critérios baseados no fluxo de exceção. Além disso, essas propostas foram implementadas e geraram uma extensão da ferramenta chamada Ja-BUTi/AJ. Para avaliar a proposta deste trabalho, um estudo de caso e um experimento formal foram conduzidos. O estudo de caso teve como objetivo validar a extensão da JaBUTi/AJ desenvolvida e fazer uma avaliação inicial do custo de aplicação dos critérios propostos. O experimento formal realizou uma comparação entre as ferramentas JaBUTi/AJ e VITTAE no contexto do teste do fluxo de exceções. Ambos os estudos são apresentados e discutidos nesta dissertação / Exception handling mechanisms available in object-oriented languages have become increasingly used and account for about 8% of the lines of code in modern programs according to some empirical researches. Yet, this mechanism is among the least understood by programmers and the less tested. The difficulty of testing exceptions increases in the phase of integration testing (e.g. inter-class testing) because exceptions raised on a certain level and not handled can flow through the call hierarchy. Using aspects also cause other types of errors, e.g. an advice can insert exceptions not foreseen by the base program. This paper presents a proposal for structural integration testing of exception flows of Java and AspectJ programs. This is done by proposing changes to the classic control ow graph and by proposing new criteria based on the exception ow. Moreover, these proposals have been implemented in a tool named JaBUTi/AJ. To evaluate the proposal of this work, a case study and a formal experiment have been conducted. The case study had the objective of validating the JaBUTi/AJ extension developed and making a preliminary assessment of the cost to use the tool. The formal experiment made a comparison between the tools JaBUTi/AJ and VITTAE in the context of exception flow test. Both studies are presented and discussed in this dissertation

No description available.

I många år har testning varit ett sätt att öka kvalitén på utvecklad programkod. I och med teknikens framsteg har testautomatisering blivit ett hett ämne inom programutveckling för att effektivisera den manuella testprocessen. Detta examensarbete har undersökt möjligheterna att införa automatiska tester hos en avdelning på Handelsbanken, främst integrations- och regressionstester. Utifrån förutsättningarna hos avdelningen togs en prototyp fram för att demonstrera hur detta skulle kunna fungera på deras Microsoft-plattform. Prototypen bestod av en Jenkins-server som utförde tester skrivna i C# med hjälp av MSTest.exe. Testerna använde diverse proprietär och open-source ramverk, där tjänster och filer testades med dessa ramverk. Prototypen bevisade att automatisk testning kunde införas på avdelningen, men underhåll och en tydlig samt omfattande testprocess krävdes. / For several years, testing has been a way to increase the quality of developed program code. As technology advances, automated testing has emerged as a hot topic in system development and has been proclaimed to streamline the previous manual testing process. The purpose of this bachelor thesis was to study the possibilities of implementing automated testing at a department of Handelsbanken, focusing on integration and regression testing. Based on the prerequisites of the department, a prototype focusing on their Microsoft platform was developed to demonstrate a possible solution. The prototype consisted of a Jenkins server executing tests written in C# with the help of MSTest.exe. The tests used both proprietary and open-source frameworks. Services and files were tested using said frameworks. The prototype proved that automatic testing could be implemented at the department, but maintenance and a clear and comprehensive testing procedure was required.

Modern-day vehicles consist of numerous electronic computing devices with accompanying software. Since vehicles are generally classified as safety-critical systems, rigorous testing strategies have to be deployed to ensure correct operation of the embedded software. Testing in an active sense is understood to be the main testing method for software in general. The main characteristic of active testing is that test cases have complete control over the system under test, warranting sequential execution of test cases. To complement active testing a method called passive testing is being researched, where the main benefit compared to active testing is that the evaluation of test cases becomes parallelizable. As passive testing opens up for concurrency, the issue of not recognizing faulty behavior arises. This could be the case when simultaneously testing functions which share an output, and the incorrect behavior of a function is being masked by the correct behavior of another function. To avoid vacuous test results, the evaluation of dependent test cases can be separated. Previous work describes the process of extracting dependencies between test cases from requirement specifications. However, this approach is not suitable when test cases are derived from various artifacts. In this thesis we present a syntax-based approach for dependency discovery between test cases. The approach was evaluated through a case study using integration test cases developed for active hardware-in-the-loop testing at Scania CV. Dependencies between 946 test cases have been extracted and the test cases were grouped into three categories, with 286 test cases being identified as independent. The approach shows some potential for evaluating test cases written for active testing, but the results indicate that using test cases written specifically for passive testing may yield better results. The approach also proved to be useful for finding bugs and deviations in scripts. Thus, the method has proven useful for discovering dependencies from syntax, but the results are strongly dependent on the complexity and commonality of the scripts. / Moderna fordon innehåller åtskilliga elektroniska kontrollenheter med medföljande programvara. Eftersom fordon ofta anses vara säkerhetskritiska system krävs robusta teststrategier av den inbyggda mjukvaran för att säkerställa korrekt drift. Aktiv testning är för nuvarande den vanligaste metoden för att testa mjukvara. Den huvudsakliga egenskapen för aktiv testning är att testfall har total kontroll över systemet som är satt under test, vilket medför sekventiell utvärdering av testfall. För att komplettera aktiv testning undersöks en metod som kallas passiv testning, där den största fördelen gentemot aktiv testning är att utvärderingen av testfall kan ske parallellt. Att utvärdera testfall samtidigt medför dock att felaktigt beteende i mjukvaran potentiellt kan maskeras. Detta kan ske då flera funktioner delar utsignaler, och en funktions felaktiga beteende maskeras av en annan funktions korrekta beteende. För att undvika tomma sanningar som testresultat, kan utvärderingen av testfall som har ett beroende mellan dem separeras. Föregående arbeten inom området beskriver processen för att extrahera beroenden mellan testfall från kravspecifikationer. Denna metod är dock inte lämplig när testfall är baserade på flera olika artefakter. I detta examensarbete presenterar vi en syntaxbaserad metod för att hitta beroenden mellan testfall. Metoden utvärderades genom en fallstudie på Scania CV, där aktiva integrationstestfall för hardware-in-the-loop användes för analys. Beroenden mellan 946 testfall kunde extraheras och testfallen grupperades i tre olika kategorier, där 286 klassificerades som oberoende. Metoden visar potential för att analysera testfall skrivna för aktiv testning, men resultaten indikerar att testfall skrivna specifikt för passiv testning kan generera ett bättre resultat. Ett oväntat men positivt utfall är att metoden i viss grad kan användas för att hitta buggar och avvikelser i skript. Således har metoden visats användbar för att hitta beroenden från syntax, men resultatet beror starkt på skriptens komplexitet och gemensamhet.

In this thesis, several heuristics that aim to improve the performance of parallel fault simulation for synchronous sequential circuits have been investigated. Three heuristics were incorporated into a well known parallel fault simulator called PROOFS and the efficiency of the heuristics were measured in terms of the number of faults simulated in parallel, the number of gate evaluations, and the CPU time. The three heuristics are critical path tracing, dynamic area reduction and a new heuristic called two level simulation. Critical path tracing and dynamic area reduction which have been previously proposed for combinational circuits are extended for synchronous sequential circuits in this thesis. The two level simulation that was investigated in this thesis is designed for sequential circuits. Experimental results show that critical path tracing is the most effective of the three heuristics. In addition to the three heuristics, new fault injection and fault ordering methods were suggested to improve the speed of an efficient fault simulator called HOPE. HOPE, which was developed at Virginia Tech is, an improved version of PROOFS. HOPE_NEW, which incorporates the two heuristics performs better than HOPE in the number of gate evaluations and the CPU time. HOPE_NEW is about 1.13 times faster than HOPE for the ISCAS89 benchmark circuits. For the largest circuit, the speedup is about 40 percent. / Master of Science

Uma abordagem de teste estrutural de integração par-a-par para programas OO e OA escritos em Java e AspectJ é apresentada. A finalidade dessa abordagem é descobrir defeitos que possam existir na interface entre os pares de unidades que se relacionam em um programa. Para programas OO este tipo de teste envolve testar a interação entre os pares de métodos. Já para programas OA, o teste estrutural de integração par-a-par envolve testar a interação entre os seguintes pares de unidades: método-método, método-adendo, adendo-método e adendo-adendo. Para efetuar o teste estrutural de integração par-a-par deve-se considerar todo o fluxo de execução (fluxo de controle e de dados) que ocorre entre a unidade chamadora e a unidade chamada. Para isso é definido o grafo Def-Uso Par-a-Par (PWDU) que é uma abstração formada pela integração dos grafos Def-Uso Orientado a Aspectos (AODU) da unidade chamadora e da unidade chamada. Além disso, são propostos três critérios para derivar requisitos de teste para pares de unidades. Dentre eles, dois critérios são baseados em fluxo de controle: todos-nós-integrados e todas-arestas-integradas; e um critério é baseado em fluxo de dados: todos-usos-integrados. Uma ferramenta que apóia o teste estrutural de unidade de programas OO e OA escritos em Java e AspectJ, chamada JaBUTi/AJ, foi estendida para dar apoio à abordagem de teste de integração proposta. Exemplos de usos são discutidos para explicar a aplicação da abordagem / A pairwise integration structural testing approach for OO and AO programs implemented with Java and AspectJ is presented. The purpose of this approach is to find faults that may exist in the interface between the pairs of units that relate in a program. For OO programs this type of testing involves testing the interaction among pair of methods. For AO programs, the pairwise integration structural testing involves testing the interaction among the following pairs of units: method-method, method-advice, advice-method and advice-advice. To perform the pairwise integration structural testing, all the execution flow (control and data flow) that happens between the caller and the called unit must be considered. For this, it is defined the PairWise Def-Use graph (PWDU) that is an abstraction formed by the integration of the Aspect-Oriented Def-Use (AODU) graphs of the caller and called unit. Additionally, three new criteria to derive test requirements for pairs of units are proposed. Amongst them, two criteria are based on control flow: all-integrated-nodes and all-integrated-edges; and one criterion is based on data flow: all-integrated-uses. A tool that supports unit structural testing of OO and AO programs implemented with Java and AspectJ, called JaBUTi/AJ, was extended in order to support the proposed integration testing approach. Examples are discussed in order to explain the application of the approach

A Programação Orientada a Aspectos (POA) é uma técnica de desenvolvimento que apoia a separação de interesses transversais. Na POA, adendos são aplicados a pontos de junção do sistema por meio de uma construção especial chamada descritor de conjuntos de junção (ou simplesmente conjunto de junção). Esse mecanismo apoia a modularização de comportamentos transversais, entretanto, como as interações adicionadas não ficam explícitas no código-fonte, é difícil assegurar que estão corretas. Para lidar com esse problema, nesta tese é proposta uma abordagem rigorosa de teste estrutural de integração para programas orientados a aspectos. É definido um modelo de fluxo de controle e de dados baseado no bytecode Java chamado Grafo Def-Uso baseado em conjuntos de junção (ou PointCut-based Def-Use graph, PCDU) que modela as regiões de execução de um programa escrito em AspectJ que são afetadas por um conjunto de junção. Sobre este modelo são definidos três critérios de teste: todos-nós-baseados-em-conjunto-de-junção, todas-arestas-baseadas-em-conjunto-de-junção e todos-usos-baseados-em-conjunto-de-junção, que requerem a cobertura de todos os comandos, condicionais e pares def-uso no contexto de cada ponto de junção selecionado. Para automatizar o uso do modelo e critérios propostos, é implementada uma ferramenta chamada JaBUTi/PC-AJ. Além disso, para validar a abordagem proposta, são conduzidos estudos teóricos e experimentais que procuram avaliar os critérios tanto do ponto de vista do custo de aplicação quanto do ponto de vista da eficácia em encontrar defeitos. Os estudos oferecem indícios da aplicabilidade e da eficácia dos critérios para encontrar defeitos diretamente relacionados com a POA / Aspect-Oriented Programming (AOP) is a promising development technique that supports separation of crosscutting concerns. In AOP, advice is applied to join points in the system through a special construct called pointcut. This mechanism supports the modularization of crosscutting behavior; however, since the added interactions are not explicit in the source code, it is hard to ensure their correctness. To tackle this problem, this thesis proposes a rigorous structural testing approach for aspect-oriented programs. A control and data flow model based on Java bytecode the PointCut-based Def-Use Graph (PCDU) that models execution regions of a program affected by a pointcut is proposed. On top of this model three testing criteria are defined: all-pointcut-based-advice-nodes, all-pointcut-based-advice-edges, and all-pointcut-based-advice-uses, that require exercising all statements, branches and def-use pairs of each advice at the context of each affected join point. To automate the use of the proposed model and criteria, a tool named JaBUTi/PC-AJ is implemented. Moreover, to validate the proposed approach, both theoretical and experimental studies are presented. These studies provide evidence of the applicability and efficacy of the proposed criteria

A Programação Orientada a Aspectos (POA) é uma técnica de desenvolvimento que apoia a separação de interesses transversais. Na POA, adendos são aplicados a pontos de junção do sistema por meio de uma construção especial chamada descritor de conjuntos de junção (ou simplesmente conjunto de junção). Esse mecanismo apoia a modularização de comportamentos transversais, entretanto, como as interações adicionadas não ficam explícitas no código-fonte, é difícil assegurar que estão corretas. Para lidar com esse problema, nesta tese é proposta uma abordagem rigorosa de teste estrutural de integração para programas orientados a aspectos. É definido um modelo de fluxo de controle e de dados baseado no bytecode Java chamado Grafo Def-Uso baseado em conjuntos de junção (ou PointCut-based Def-Use graph, PCDU) que modela as regiões de execução de um programa escrito em AspectJ que são afetadas por um conjunto de junção. Sobre este modelo são definidos três critérios de teste: todos-nós-baseados-em-conjunto-de-junção, todas-arestas-baseadas-em-conjunto-de-junção e todos-usos-baseados-em-conjunto-de-junção, que requerem a cobertura de todos os comandos, condicionais e pares def-uso no contexto de cada ponto de junção selecionado. Para automatizar o uso do modelo e critérios propostos, é implementada uma ferramenta chamada JaBUTi/PC-AJ. Além disso, para validar a abordagem proposta, são conduzidos estudos teóricos e experimentais que procuram avaliar os critérios tanto do ponto de vista do custo de aplicação quanto do ponto de vista da eficácia em encontrar defeitos. Os estudos oferecem indícios da aplicabilidade e da eficácia dos critérios para encontrar defeitos diretamente relacionados com a POA / Aspect-Oriented Programming (AOP) is a promising development technique that supports separation of crosscutting concerns. In AOP, advice is applied to join points in the system through a special construct called pointcut. This mechanism supports the modularization of crosscutting behavior; however, since the added interactions are not explicit in the source code, it is hard to ensure their correctness. To tackle this problem, this thesis proposes a rigorous structural testing approach for aspect-oriented programs. A control and data flow model based on Java bytecode the PointCut-based Def-Use Graph (PCDU) that models execution regions of a program affected by a pointcut is proposed. On top of this model three testing criteria are defined: all-pointcut-based-advice-nodes, all-pointcut-based-advice-edges, and all-pointcut-based-advice-uses, that require exercising all statements, branches and def-use pairs of each advice at the context of each affected join point. To automate the use of the proposed model and criteria, a tool named JaBUTi/PC-AJ is implemented. Moreover, to validate the proposed approach, both theoretical and experimental studies are presented. These studies provide evidence of the applicability and efficacy of the proposed criteria