Made available in DSpace on 2014-12-17T15:48:06Z (GMT). No. of bitstreams: 1 RicardoJSJ_DISSERT.pdf: 4102063 bytes, checksum: 92b62a467283fb011a1258e8b80ca7b4 (MD5) Previous issue date: 2013-02-01 / Checking the conformity between implementation and design rules in a system is an important activity to try to ensure that no degradation occurs between architectural patterns defined for the system and what is actually implemented in the source code. Especially in the case of systems which require a high level of reliability is important to define specific design rules for exceptional behavior. Such rules describe how exceptions should flow through the system by defining what elements are responsible for catching exceptions thrown by other system elements. However, current approaches to automatically check design rules do not provide suitable mechanisms to define and verify design rules related to the exception handling policy of applications. This paper proposes a practical approach to preserve the exceptional behavior of an application or family of applications, based on the definition and runtime automatic checking of design rules for exception handling of systems developed in Java or AspectJ. To support this approach was developed, in the context of this work, a tool called VITTAE (Verification and Information Tool to Analyze Exceptions) that extends the JUnit framework and allows automating test activities to exceptional design rules. We conducted a case study with the primary objective of evaluating the effectiveness of the proposed approach on a software product line. Besides this, an experiment was conducted that aimed to realize a comparative analysis between the proposed approach and an approach based on a tool called JUnitE, which also proposes to test the exception handling code using JUnit tests. The results showed how the exception handling design rules evolve along different versions of a system and that VITTAE can aid in the detection of defects in exception handling code / Verificar a conformidade entre a implementa??o de um sistema e suas regras de design ? uma atividade importante para tentar garantir que n?o ocorra a degrada??o entre os padr?es arquiteturais definidos para o sistema e o que realmente est? implementado no c?digo-fonte. Especialmente no caso de sistemas dos quais se exige um alto n?vel de confiabilidade ? importante definir regras de design (design rules) espec?ficas para o comportamento excepcional. Tais regras descrevem como as exce??es devem fluir atrav?s do sistema, definindo quais s?o os elementos respons?veis por capturar as exce??es lan?adas por outros elementos do sistema. Entretanto, as abordagens atuais para verificar automaticamente regras de design n?o proveem mecanismos adequados para definir e verificar regras de design espec?ficas para a pol?tica de tratamento de exce??es das aplica??es. Este trabalho prop?e uma abordagem pr?tica para preservar o comportamento excepcional de uma aplica??o ou fam?lia de aplica??es, baseada na defini??o e verifica??o autom?tica em tempo de execu??o de regras de design de tratamento de exce??o para sistemas desenvolvidos em Java ou AspectJ. Para apoiar esta abordagem foi desenvolvida, no contexto deste trabalho, uma ferramenta chamada VITTAE (Verification and Information Tool to Analyze Exceptions) que estende o framework JUnit e permite automatizar atividades do teste de regras de design excepcionais. Foi realizado um estudo de caso preliminar com o objetivo de avaliar a efic?cia da abordagem proposta sobre uma linha de produto de software. Al?m deste, foi realizado um experimento cujo objetivo foi realizar uma an?lise comparativa entre a abordagem proposta e uma abordagem baseada na ferramenta JUnitE, que tamb?m prop?e testar o c?digo de tratamento de exce??es utilizando testes JUnit. Os resultados mostraram que as regras de design excepcionais evoluem ao longo de diferentes vers?es de um sistema e que a VITTAE pode auxiliar na detec??o de defeitos no c?digo de tratamento de exce??o

Submitted by Johnny Rodrigues (johnnyrodrigues@ufcg.edu.br) on 2018-08-22T23:26:49Z No. of bitstreams: 1 JOÃO ARTHUR BRUNET MONTEIRO - DISSERTAÇÃO PPGCC 2010..pdf: 1055709 bytes, checksum: e8145387f1111c96339e77c6b84ebade (MD5) / Made available in DSpace on 2018-08-22T23:26:49Z (GMT). No. of bitstreams: 1 JOÃO ARTHUR BRUNET MONTEIRO - DISSERTAÇÃO PPGCC 2010..pdf: 1055709 bytes, checksum: e8145387f1111c96339e77c6b84ebade (MD5) Previous issue date: 2010-07-26 / Assegurar que um programa está de acordo com sua especificação é um elemento chave na garantia de qualidade de software. Embora haja amplo suporte ferramental para checar se uma implementação está funcionalmente de acordo com seus requisitos, checar se ela está em conformidade com regras de design ainda é uma atividade que por muitas vezes é executada manualmente. Neste trabalho propomos uma técnica que visa automatizar a checagem de conformidade entre regras de design de baixo-nível e implementação. A técnica proposta, intitulada testes de design, permite a verificação de programas baseada em testes. O objetivo da técnica é checar se os programadores estão seguindo as regras de design previamente especificadas. Regras são especificadas como testes, daí o nome testes de design. De fato, testes de design são JUnit test cases com uma semântica diferente de testes funcionais. Testes funcionais checam se o software se comporta como esperado quando estimulado por determinadas entradas, ao passo que testes de design checam se o software está sendo construído da maneira esperada. Para dar suporte à abordagem de testes de design, foi desenvolvida uma biblioteca chamada DesignWizard (http://www.designwizard.org). Uma avaliação levando em consideração a usabilidade e a escalabilidade do DesignWizard foi efetuada com o objetivo de mostrar sua viabilidade na checagem de conformidade de grandes projetos. Os resultados do experimento de escalabilidade apontam na direção de que a eficiência não é um problema para a ferramenta e que, de acordo com o experimento de usabilidade, o suporte da ferramenta à escrita de testes de design cumpre com as expectativas dos desenvolvedores. / Assuring that a program conforms to its specification is a key concern in software quality assurance. Although there is substantial tool support to check whether an implementation complies to its functional requirements, checking whether it conforms to its design remains as an almost completely manual activity. We propose the concept of design tests, which are test-like programs that automatically check whether an implementation conforms to a specific design rule. Design rules are implemented directly in the target programming language in the form of tests. As a proof of concept, we present DesignWizard, an library developed to support design tests for Java programs as JUnit test cases. We have performed an evaluation to show that DesignWizard’s API is easy to use and the tool scales as software grows. To achieve this, we have conducted an experiment to assess the usability of DesignWizard’s API by analysing eleven developers on the activity of composing five design tests using DesignWizard’s API. Besides that, we have measured the time and memory consumption that DesignWizard takes to apply static analysis on several projects sizes varying between 0.125MB and 46MB. The results of our study show that the time and memory consumption of static analysis performed by Design Wizard has a linear form as the size of the application grows. Besides that, the experiment conducted with the programmers leads us to conclude that DesignWizard’s API is easy to use in the sense that it meets to programmers expectations.