Submitted by Automa??o e Estat?stica (sst@bczm.ufrn.br) on 2017-10-18T19:35:37Z No. of bitstreams: 1 DemostenesSantosDeSena_TESE.pdf: 4593790 bytes, checksum: 3e0845d816f16e3a8f7659744e28f8ad (MD5) / Approved for entry into archive by Arlan Eloi Leite Silva (eloihistoriador@yahoo.com.br) on 2017-10-19T19:11:29Z (GMT) No. of bitstreams: 1 DemostenesSantosDeSena_TESE.pdf: 4593790 bytes, checksum: 3e0845d816f16e3a8f7659744e28f8ad (MD5) / Made available in DSpace on 2017-10-19T19:11:30Z (GMT). No. of bitstreams: 1 DemostenesSantosDeSena_TESE.pdf: 4593790 bytes, checksum: 3e0845d816f16e3a8f7659744e28f8ad (MD5) Previous issue date: 2017-02-13 / Os mecanismos de tratamento de exce??es s?o recursos fornecidos pelas principais linguagens de programa??o para auxiliar no desenvolvimento de sistemas robustos. A pol?tica de tratamento de exce??es corresponde ao conjunto de regras de design do tratamento excepcional e definem os elementos de c?digo (m?todos, classes ou pacotes) respons?veis pela sinaliza??o, propaga??o, captura das exce??es e as respectivas a??es de tratamento. Alguns estudos emp?ricos demonstraram que o tratamento inadequado de exce??es, consequ?ncia da falta da pol?tica documentada, ? uma poss?vel fonte de defeitos. Por outro lado, devido ? natureza impl?cita dos fluxos de exce??es, a identifica??o e corre??o dos tratamentos de exce??es tornam-se tarefas complexas. Para amenizar os problemas decorrentes do tratamento inadequado devido ? falta de documenta??o do tratamento de exce??es, algumas abordagens definiram linguagens de especifica??o das regras de tratamento com suporte ferramental para auxiliar na defini??o e checagem das regras. Entretanto, historicamente, as pol?ticas de tratamento de exce??es dos sistemas s?o postergadas ou ignoradas no processo de desenvolvimento. Adicionalmente, nenhuma das abordagens propostas oferece suporte ? defini??o das regras, de forma a auxiliar o arquiteto a extrair as regras a partir da an?lise de c?digo fonte pr?-existente, e este ? o objetivo da abordagem apresentada neste trabalho. Para apoiar a execu??o da abordagem proposta, foi desenvolvida uma ferramenta de an?lise est?tica que permite: (i) a coleta dos fluxos excepcionas e das respectivas a??es de tratamentos; (ii) a identifica??o e defini??o dos agrupamentos, que s?o os elementos de c?digo que possuem os mesmos comportamentos em rela??o ao tratamento de exce??es; (iii) a extra??o das regras; e, (iv) a checagem das regras e identifica??o das causas das viola??es ? pol?tica. A abordagem ? demonstrada em dois estudos emp?ricos. No primeiro estudo emp?rico foram analisadas 656 bibliotecas (libs) Java do reposit?rio central Maven com objetivo de extrair e caracterizar a pol?tica de tratamento de exce??es destas libs. Este estudo revelou que 80,9% das bibliotecas possuem fluxos excepcionais que implementam pelo menos um anti-pattern do tratamento excepcional. O segundo estudo emp?rico teve como objetivo investigar os benef?cios da extra??o das regras excepcionais a partir do c?digo pr?-existente no processo de defini??o e checagem da pol?tica de tratamento de exce??es. Dois sistemas de informa??o Web (i.e., IProject e SIGAA) foram utilizados neste segundo estudo. Neste estudo pudemos observar que todas as regras reportadas pelos arquitetos foram extra?das pelo suporte ferramental, e que os resultados do processo de extra??o permitiram que novas regras fossem adicionadas pelos arquitetos. Essas regras adicionadas foram as regras n?o definidas pelos arquitetos e corresponderam ? 57,1% (IProject) e 52,8% (SIGAA/Gradua??o) das regras da pol?tica dos sistemas analisados. O processo de checagem das regras definidas com o apoio da abordagem mostrou que 35,6% e 45,7% dos fluxos excepcionais do IProject e SIGAA/Gradua??o, respectivamente, violavam alguma das regras de tratamento de exce??es. / The Exception handling (EH) mechanism is a technique embedded in most of the mainstream programming languages to support the development of robust systems. The exception handling policy is composed by the set of exception handling design rules and which specify the elements (methods, classes and packages) or that contains the elements responsible for raising, propagating and catching of exceptions as well as the handling actions. Empirical studies have demonstrated that an inappropriate exception handling as consequence of undocumented exception handling policy is a source of bug hazards. On the other hand, due to the implicit nature of exception flows, the identification of exception handling code is a complex task. To address the problems resulting from the not-understood or inadequate exception handling, some approaches have been proposed languages to specify exception handling rules as well as a set of support tool to verify the constraints and checking the rules. However, historically, the exception handling policies are postponed or ignored in the software process development. Additionally, none of the proposed approaches provide support to the phase of exception policy definition. This work proposes an approach that helps the architect to extract the EH rules by performing an analysis on the existing code. Doing so, this approach fills the previous gap the EH policy definition. To support the proposed approach, a static tool suite was developed, which performs: (i) the discovery of exception flows and its handling actions; (ii) the definition of compartments; (iii) the semi-automatic rule extraction process; and (iv) the rule checking and identification of rule violation causes. This approach was assessed in two empirical studies. In the first study, 656 libraries from Maven central repository were analyzed. The main goal of this study was to reveal and to characterize the exception handling policy of the analyzed libraries. This study revealed that 80.9% of the analyzed libraries have exception flows that implement at least one exception handling anti-pattern. In the second study, we investigated the benefits of rule extraction process in the definition and checking of exception handling rules. Two web information systems (i.e., IProject and SIGAA) were analyzed in this second study. We found that all set of rules reported by the architects were extracted by our tool and the result of extraction process allowed that new rules were added to the policy. These added rules were not defined by architects and they corresponded to 57.1% (IProject) and 52.8% (SIGAA/Gradua??o) of the rules of analyzed systems. The checking process of defined rules supported by our approach verified that 35.6% (IProject) and 45.7% (SIGAA/Gradua??o) of exception flows violated some defined rule.

Made available in DSpace on 2014-12-17T15:48:10Z (GMT). No. of bitstreams: 1 EliezioSSN_DISSERT.pdf: 2190104 bytes, checksum: 2908609aa5c1ba4f1490b02210bf4470 (MD5) Previous issue date: 2014-04-25 / Coordena??o de Aperfei?oamento de Pessoal de N?vel Superior / Mainstream programming languages provide built-in exception handling mechanisms to support robust and maintainable implementation of exception handling in software systems. Most of these modern languages, such as C#, Ruby, Python and many others, are often claimed to have more appropriated exception handling mechanisms. They reduce programming constraints on exception handling to favor agile changes in the source code. These languages provide what we call maintenance-driven exception handling mechanisms. It is expected that the adoption of these mechanisms improve software maintainability without hindering software robustness. However, there is still little empirical knowledge about the impact that adopting these mechanisms have on software robustness. This work addresses this gap by conducting an empirical study aimed at understanding the relationship between changes in C# programs and their robustness. In particular, we evaluated how changes in the normal and exceptional code were related to exception handling faults. We applied a change impact analysis and a control flow analysis in 100 versions of 16 C# programs. The results showed that: (i) most of the problems hindering software robustness in those programs are caused by changes in the normal code, (ii) many potential faults were introduced even when improving exception handling in C# code, and (iii) faults are often facilitated by the maintenance-driven flexibility of the exception handling mechanism. Moreover, we present a series of change scenarios that decrease the program robustness / As linguagens de programa??o convencionais fornecem mecanismos de tratamento de exce??es internos a fim de prover implementa??o de tratamento de exce??es em sistemas de software robusto e manuten?vel. A maioria dessas linguagens modernas, tais como C#, Ruby, Python e muitas outras, frequentemente afirmaram ter mecanismos de tratamento de exce??o mais apropriados. Elas reduzem as restri??es de programa??o no tratamento de exce??o buscando agilizar mudan?as no c?digo fonte. Essas linguagens suportam o que chamamos de mecanismos de tratamento de exce??es dirigidos a manuten??o. Espera-se que a ado??o desses mecanismos aumentem a manutenibilidade dos softwares sem impactar na robustez. Entretanto ainda existe pouco conhecimento emp?rico acerca do impacto que a ado??o desses mecanismos tem na robustez de softwares. Este trabalho busca preencher essa lacuna conduzindo um estudo emp?rico direcionado ao entendimento da rela??o entre mudan?as em programas C# e sua robustez. Em particular, n?s avaliamos como mudan?as nos c?digos normal e excepcional se relacionam com faltas no tratamento de exce??o. N?s aplicamos uma an?lise de impacto de mudan?a e uma an?lise de fluxo de controle em 100 vers?es de 16 programas escritos em C#. A partir dos dados coletados, este trabalho identificou os elementos do trade-off entre manutenibilidade e robustez

Submitted by Automa??o e Estat?stica (sst@bczm.ufrn.br) on 2017-01-12T13:24:40Z No. of bitstreams: 1 JoilsonVidalAbrantes_DISSERT.pdf: 2404682 bytes, checksum: d60333810463c26554d8e41bfe6683fb (MD5) / Approved for entry into archive by Arlan Eloi Leite Silva (eloihistoriador@yahoo.com.br) on 2017-01-16T15:05:25Z (GMT) No. of bitstreams: 1 JoilsonVidalAbrantes_DISSERT.pdf: 2404682 bytes, checksum: d60333810463c26554d8e41bfe6683fb (MD5) / Made available in DSpace on 2017-01-16T15:05:25Z (GMT). No. of bitstreams: 1 JoilsonVidalAbrantes_DISSERT.pdf: 2404682 bytes, checksum: d60333810463c26554d8e41bfe6683fb (MD5) Previous issue date: 2016-02-25 / A pol?tica de tratamento de exce??es de um sistema compreende o conjunto de regras de design que especificam o comportamento e tratamento das condi??es excepcionais, ou seja, define como as exce??es devem ser manuseadas e disparadas. Essa pol?tica geralmente n?o ? documentada e fica definida implicitamente pelo arquiteto do sistema. Por essa raz?o os desenvolvedores podem pensar que apenas inserindo blocos try-cach em todos locais onde exce??es podem potencialmente ser lan?adas est?o lidando adequadamente com as condi??es excepcionais de um sistema. Por?m este comportamento pode transformar o tratamento das condi??es excepcionais em uma generaliza??o do mecanismo "goto", tornando o programa mais complexo e menos confi?vel. Este trabalho prop?e uma linguagem espec?fica de dom?nio, chamada ECL (Exception Contract Language) para especificar a pol?tica de tratamento de exce??es e uma ferramenta de monitoramento em tempo de execu??o que verifica dinamicamente a pol?tica de tratamento de exce??es. Essa ferramenta ? chamada de DAEH (Dynamic Analysis of Exception Handling e ? implementada na forma de uma biblioteca de aspectos, que pode ser adicionada a uma aplica??o Java sem a necessidade de alterar o c?digo fonte da mesma. Esta abordagem foi aplicada a dois sistemas WEB, a quatro vers?es do framework JUnit e a uma aplicatica??o m?vel. Os resultados indicam que esta abordagem pode ser usada para expressar e automaticamente verificar a pol?tica de tratamento de exce??es de sistemas, e, consequentemente apoiar o desenvolvimento de sistemas Java mais robustos. / The exception handling policy of a system comprises the set of design rules that specify its exception handling behavior how exceptions should be handled and thrown. Such policy is usually undocumented and implicitly defined by the system architect. For that reason, the developers may think that by just sprinkling the with catch-blocks in all places where exceptions may potentially be released they are adequately dealing with the exceptional conditions of a system. This lack of information may turn the exception handling into a generalized "goto"mechanism making the program more complex and less reliable. This work proposes a domain - specific language called ECL (Exception Contract Language) to specify the exception handling policy and a runtime monitoring tool which dynamically checks thise policy. This tool is called DAEH (Dynamic Analysis Of Exception Handling). It is implemented in the form of an aspect library, which can added to any Java system without the need to change the application source code. We applied this approach to two large-scale WEB systems and to the a set of versions to the well-known JUnit framework and a mobile application. The results indicate that this approach can be used to express and automatically check the exception handling policy of a system, and consequently support the development of more robust Java systems and more robust.

Submitted by Automa??o e Estat?stica (sst@bczm.ufrn.br) on 2017-06-02T19:19:17Z No. of bitstreams: 1 TaizaRabelloMontenegro_DISSERT.pdf: 2317460 bytes, checksum: 372e57740f0bdb5c6fc0cdd5a279c949 (MD5) / Approved for entry into archive by Arlan Eloi Leite Silva (eloihistoriador@yahoo.com.br) on 2017-06-05T20:02:53Z (GMT) No. of bitstreams: 1 TaizaRabelloMontenegro_DISSERT.pdf: 2317460 bytes, checksum: 372e57740f0bdb5c6fc0cdd5a279c949 (MD5) / Made available in DSpace on 2017-06-05T20:02:53Z (GMT). No. of bitstreams: 1 TaizaRabelloMontenegro_DISSERT.pdf: 2317460 bytes, checksum: 372e57740f0bdb5c6fc0cdd5a279c949 (MD5) Previous issue date: 2017-02-20 / Na medida em que aumenta a depend?ncia da sociedade com os sistemas de software, aumenta tamb?m a demanda pela robustez destes sistemas. O tratamento de exce??es ? uma das t?cnicas mais utilizadas para a constru??o de sistemas de software robustos. A pol?tica de tratamento de exce??es ? o conjunto de regras que define como as exce??es devem ser manuseadas. Por?m, na maioria dos casos, essa pol?tica n?o est? definida de forma expl?cita, sendo um desafio para o desenvolvedor criar o c?digo de tratamento de exce??es. Este trabalho prop?e uma ferramenta em formato de plug-in do Eclipse, denominada ExceptionPolicyExpert, que tem o objetivo de orientar o desenvolvedor na implementa??o desse tipo de c?digo de forma a atender uma pol?tica previamente definida. Esta ferramenta analisa o c?digo fonte e verifica se h? alguma viola??o ? pol?tica de tratamento de exce??es, alertando o desenvolvedor para n?o conformidade, caso exista. Para auxiliar o levantamento dos requisitos da ferramenta, foi realizado um estudo explorat?rio com desenvolvedores, utilizando t?cnicas de Grounded Theory, que buscou entender quais eram os principais desafios deles no momento da implementa??o do c?digo de tratamento de exce??es. O estudo mostrou que a maioria deles n?o recebem orienta??es a respeito da pol?tica de tratamento de exce??es e nem tem acesso ? pol?tica de tratamento de exce??es a ser seguida. Consequentemente, muitas vezes lidam com esse c?digo de forma indevida. Dessa forma, foi proposta uma ferramenta que visa trazer informa??es sobre a pol?tica de tratamento de exce??es para a IDE, de forma que auxilie o desenvolvedor na implementa??o do c?digo excepcional sem violar a pol?tica. A avalia??o da ferramenta mostrou que ela auxilia o desenvolvedor a tomar decis?es no momento da implementa??o do c?digo de tratamento de exce??es. / As our society becomes more and more dependent of software systems the demand robustness requirements increases. The exception handling mechanism is one of the most used techniques to enable the development of robust software systems develop. The exception handling policy comprises the set of rules that specify how exceptions should be thrown and handled inside a system. But usually the policy is not explicitly defined. As a consequence, it becomes a challenge for developers to create the exception handling code according to it. This work proposes an Eclipse plug-in, called ExceptionPolicyExpert, to guide the developer on how to implement this kind of code by checking policy violations and providing recommendations to developers concerning how to exceptions should be handled and signaled. In order to support the creation of such tool, we performed an exploratory study, using Grounded Theory techniques, to understand which are the main challenges that the developers have during the implementation of the exception handling code. This study showed that most of the developers did not receive any instructions regarding the exception handling policy and they often handle exceptions in a wrong way. Therefore, the proposed tool aims to provide information to developer regarding the exception handling policy integrated to the IDE - helping him/her to develop exception handling code and preventing policy violations. The tool evaluation showed that the tool helps the developer to make decisions when implementing the exception handling code.

Submitted by Automa??o e Estat?stica (sst@bczm.ufrn.br) on 2017-02-20T21:14:31Z No. of bitstreams: 1 FranciscoDiogoOliveiraDeQueiroz_DISSERT.pdf: 2384075 bytes, checksum: 6637cd90d60ea8666ced83de9d255a5f (MD5) / Approved for entry into archive by Arlan Eloi Leite Silva (eloihistoriador@yahoo.com.br) on 2017-02-23T00:25:27Z (GMT) No. of bitstreams: 1 FranciscoDiogoOliveiraDeQueiroz_DISSERT.pdf: 2384075 bytes, checksum: 6637cd90d60ea8666ced83de9d255a5f (MD5) / Made available in DSpace on 2017-02-23T00:25:27Z (GMT). No. of bitstreams: 1 FranciscoDiogoOliveiraDeQueiroz_DISSERT.pdf: 2384075 bytes, checksum: 6637cd90d60ea8666ced83de9d255a5f (MD5) Previous issue date: 2016-08-17 / Com a ascens?o da tecnologia m?vel nos ?ltimos anos, dispositivos como smartphones e tablets t?m se tornado parte integral da vida das pessoas. Como telefones tradicionais, os smartphones podem ser utilizados para realizar chamadas e mandar mensagens de texto, mas ? a possibilidade de fornecer variados tipos de aplica??es que os tornam t?o atrativos para seus usu?rios. Neste contexto, aplica??es Android tem se tornado cada vez mais populares; e no mesmo ritmo em que cresce o n?mero de aplica??es dispon?veis, tamb?m cresce o n?mero de usu?rios afetados pelos crashes de tais aplica??es. Para poder lidar com tais condi??es excepcionais, o c?digo para lan?amento e captura de exce??es n?o ? uma parte opcional mas uma parte fundamental de tais aplica??es. Por?m, o que se tem observado ? que o c?digo projetado para tratar estas condi??es excepcionais pode muitas vezes ser a causa de crashes (e.g., exce??es n?o capturadas). At? o momento nenhum estudo investigou as principais caracter?sticas do c?digo de tratamento de exce??es (TE) de aplica??es Android. Este trabalho apresenta um conjunto de estudos complementares para melhor entender as caracter?sticas do c?digo de TE de aplica??es Android assim como identificar a vis?o dos desenvolvedores a respeito destas caracter?sticas. Neste trabalho foram realizados tr?s estudos: (i) um estudo explorat?rio onde foram inspecionados o c?digo de TE de 15 aplica??es Android populares (o que no total correspondeu a 3490 blocos try-catch-finally); e (ii) dois estudos qualitativos baseados em t?cnicas de Teoria Fundamentada em Dados - nestes foram aplicados surveys a 28 desenvolvedores Android e 47 especialistas Android para levantar a opini?o dos mesmos sobre boas e m?s praticas no desenvolvimento do tratamento de exce??es no ambiente Android. Durante estes estudos observamos um grande n?mero de exce??es sendo silenciadas no c?digo de apps. Tamb?m observamos que poucas aplica??es enviavam informa??es as informa??es sobre as exce??es uncaught para servidores de crash report. / Along the recent years, we have witnessed an astonishing increase in the number mobile applications being developed and some of them becoming largely used. Such applications extend phones capabilities far beyond of the basic calls. In the same rate the number of a users increase, also increases the number of users affected by application faults and crashes. In this contexto, Android apps are becoming more and more popular. The number of such apps is astonishingly increasing in a daily rate, as well as the number of users affected by their crashes. Android apps as other Java apps may crash due to faults on the exception handling (EH) code (e.g. uncaught exceptions). Techniques for exception detection and handling are not an optional add-on but a fundamental part of such apps. Yet, no study has investigated the main characteristics of the EH code of mobile apps nor the developers perspective about the good and bad practices of EH in such context. In this work we conducted three complementary studies: (i) one that inspected the EH code of 15 popular Android apps (which overall comprises of 3490 try-catch-finally blocks); and two qualitative studies based an Grounded Theory techniques, on which two surveys were applied to 28 Adndroid developers and 47 Android experts respectively, to get their opinion about the good and bad practices of EH development in Android environment. Some outcomes of the studies show a high occurrence of exception swallowing and only few apps sending exception information to a remote server ? both considered by Android experts as bad practices that negatively impact the app robustness.

Made available in DSpace on 2014-12-17T15:48:02Z (GMT). No. of bitstreams: 1 HugoFM_DISSERT.pdf: 1847783 bytes, checksum: 58d9312a629dabdd3fe4b15c8dc44101 (MD5) Previous issue date: 2012-07-26 / The Exception Handling (EH) is a widely used mechanism for building robust systems. In Software Product Line (SPL) context it is not different. As EH mechanisms are embedded in most of mainstream programming languages (like Java, C# and C++), we can find exception signalers and handlers spread over code assets associated to common and variable SPL features. When exception signalers and handlers are added to an SPL in an unplanned way, one of the possible consequences is the generation of faulty family instances (i.e., instances on which common or variable features signal exceptions that are mistakenly caught inside the system). In this context, some questions arise: How exceptions flow between the optional and alternative features an LPS? Aiming at providing answers to these questions, this master thesis conducted an exploratory study, based on code inspection and static analysis code, whose goal was to categorize the main ways which exceptions flow in LPSs. To support the study, we developed an static analysis tool called PLEA (Product Line Exception Analyzer) that calculates the exceptional flows of LPSs, and categorize these flows according to the features associated with handlers and signalers. Preliminary results showed that some types of exceptional flows have more potential to yield failures in exceptional behavior of SLPs / O mecanismo de tratamento de exce??es ? amplamente utilizado para a constru??o de sistemas robustos. No contexto de Linhas de Produto de Software (LPSs) n?o ? diferente. Uma vez que mecanismos de tratamento de exce??es est?o embutidos nas principais linguagens de programa??o da atualidade (como Java, C# e C++), podemos encontrar sinalizadores e tratadores de exce??es espalhados entre os artefatos de c?digo associados a caracter?sticas (do ingl?s: features) opcionais e obrigat?rias de uma LPS. Quando tratadores ou sinalizadores de exce??es s?o adicionados a uma LPS de forma n?o planejada, uma das poss?veis conseq??ncias ? a gera??o de produtos falhos (i.e., produtos em que exce??es lan?adas por features vari?veis ou obrigat?rias s?o erroneamente tratadas). Neste contexto, surge a pergunta: Quais as consequ?ncias de se usar o mecanismo de tratamento de exce??es em LPSs? Com o objetivo de responder a esta pergunta, este trabalho conduz um estudo explorat?rio, baseado em inspe??o de c?digo e an?lise est?tica de c?digo, cujo objetivo foi caracterizar as principais formas em que exce??es fluem em LPSs. Para apoiar a realiza??o deste estudo desenvolvemos a PLEA (Product Line Exception Analyzer), uma ferramenta baseada em analise est?tica de c?digo que calcula os fluxos excepcionais de uma LPS e os classifica de acordo com as features associadas aos seus tratadores e sinalizadores. Resultados preliminares mostraram que alguns tipos de fluxos excepcionais tem mais potencial para originarem falhas no comportamento excepcional das LPSs

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