Incremental Modular Testing in Aspect Oriented Programing

212 Pages·2016·1.62 MB·English

University of Porto
Faculty of Engineering
Incremental Modular Testing in
Aspect Oriented Programing
!
André Monteiro de Oliveira Restivo
August 2015
Friday, November 12, 2010
Scientific Supervision by
Ademar Aguiar, Assistant Professor
Departmento de Engenharia Informática
Faculdade de Engenharia da Universidade do Porto
Ana Moreira, Associate Professor
Departamento de Informática
Faculdade de Ciências e Tecnologia, Universidade Nova de Lisboa
In partial fulfillment of requirements for the degree of
Doctor of Philosophy in Computer Science
by the Doctoral Program in Informatics Engineering
Contact Information:
André Monteiro de Oliveira Restivo
Faculdade de Engenharia da Universidade do Porto
Departamento de Engenharia Informática
Rua Dr. Roberto Frias, s/n
4200-465 Porto
Portugal
Tel.: [phone]
Fax.: [phone]
Email: [e-mail]
URL: http://www.fe.up.pt/~arestivo
This thesis was typeset on an Lenovo E530® running Ubuntu 12.04® using the free LATEX typesetting system,
originally developed by Leslie Lamport based on TEX created by Donald Knuth. The body text is set in Latin
Modern, a Computer Modern derived font originally designed by Donald Knuth. Other fonts include Sans
and Typewriter from the Computer Modern family, and Courier, a monospaced font originally designed by
Howard Kettler at IBM and later redrawn by Adrian Frutiger. Typographical decisions were based on the
recommendations given in The Elements of Typographic Style by Robert Bringhurst (2004), and graphical
guidelines were inspired in The Visual Display of Quantitative Information by Edward Tufte (2001). This
colophonhasexactlyonehundredandtwenty-four(124)words,excludingallnumbersandsymbols.
André Monteiro de Oliveira Restivo
“Incremental Modular Testing in Aspect Oriented Programing”
Copyright ©2015 by André Monteiro de Oliveira Restivo.
All rights reserved.
to my parents, for the unconditional support
to Filipa, for understanding

Abstract
Developing good quality software is a hard task. The development cycle is com-
posed of several tasks that must fit perfectly in order to produce software that
is usable, maintainable, reliable, extensible and secure. The reason why it is so
hard to attain these goals is that software is extremely complex. A large software
product is composed of several parts that must be perfectly integrated like in a
giant jigsaw puzzle.
If done correctly, the parts that compose a software product, let us call them
modules, are going to be as loosely coupled as possible. Modules should need to
knowaslittleaspossibleabouttheinnerworkingsofothermodules. Thisso-called
modularity is of paramount importance as it makes modules more understandable,
autonomous and promotes reusability.
The ideal scenario would be one where each module is only responsible for one
concern. Developingsoftwarewouldthenbeaquestionofcomposingthesemodules
together. Unfortunately,althoughsoftwaredevelopmentparadigmsandtechniques
are surely focused in achieving this perfect separation of concerns, there are still
some concerns that get inevitably scattered and tangled throughout the code.
Aspect Oriented Programming (AOP) is a paradigm that promises to tame these
crosscutting concerns and separate them into their own units of modularity. The
way it proposes to do so is to enable the developer to pinpoint specific points of
interest in the code, using a domain specific language, and then inject context
aware code into those points. In this way, a concern that used to be scattered, can
be contained and still affect many different parts of the code.
Software testing provides stakeholders a measure of the quality of the software
beingproduced. Itisoneoftheactivitiesofthedevelopmentcycleandisextremely
important in order to achieve good quality software. Unit testing is specially
v
important when we are trying to create modular software, as it allows testing each
module almost independently from others.
Unfortunately, as we will show in this thesis, using AOP hinders the usage of unit
testing. You can either throw away part of the modularity gained by using it or
drop some unit tests. This happens due to the capability of AOP to change the
behavior of existing modules, making tests that have been specifically created for
those modules only work when the AOP code is not present. Changing the tests
to account for the AOP code breaks the modularity, and the only other existing
option is to remove those tests.
In this thesis, we propose using semi-automatic code inspection to create a tree of
the dependencies between modules and use an incremental testing approach that
allows each software layer to be tested in isolation. As layers are added, one after
the other, if a certain part of the code breaks a previous test, it will be possible
to mark the broken tests as being replaced by new tests that take into account
the modifications that have been introduced by the AOP code. This allows unit
tests in lower layers to still be usable without breaking the modularity promised
by AOP.
A testbed was created to test the proposed approach and we were able to create
and use unit tests that would otherwise be impossible to run in the complete
system. We also showed how the approach is able to tackle some AOP specific
software faults. To help with the tests, we developed a reference implementation
of a support tool.
We believe that the approach being presented solves an important problem that
prevents the adoption of AOP from being more widespread. We do not assume
to have solved all AOP problems, but we think this thesis presents an important
step in the right direction as it enables a more sane usage of tests in conjunction
with aspects.
vi
Resumo
O desenvolvimento de software de boa qualidade é uma tarefa complicada. O
ciclo de desenvolvimento é composto por várias tarefas que têm de se coordenar
perfeitamente, a fim de produzir software utilizável, mantível, confiável, extensível
e seguro. A razão porque é tão difícil de atingir estes objetivos é que o software
é extremamente complexo. Um produto de software de grandes dimensões é com-
posto por várias peças complexas que têm de se encaixar perfeitamente como num
puzzle gigante.
Se feito corretamente, as peças que compõem um projeto de software, vamos
chamá-las de módulos, vão ser fracamente acoplados. Os módulos devem precisar
sabertãopoucoquantopossívelsobreofuncionamentointernodosoutrosmódulos.
A modularidade é de grande importância, pois acaba por produzir módulos mais
fáceis de perceber e promove a sua reutilização.
Idealmente, cada módulo deveria ser responsável por apenas um único interesse
(em inglês concern). O desenvolvimento de software seria então uma questão
de composição destes módulos. Infelizmente, apesar da existência de técnicas e
paradigmas de programação focados em conseguir uma perfeita separação destes
interesses,aindaexistemalgunsqueficaminevitavelmenteespalhadosemisturados
ao longo do código.
AProgramaçãoOrientadaaAspectos(AOP)éumparadigmaqueprometeseparar
esses interesses transversais nas suas próprias unidades de modularidade. A forma
como se propõe fazê-lo é permitindo ao programador que identifique pontos de
interesse no código, usando uma linguagem específica do domínio e, em seguida,
injecte código com acesso ao contexto nesses pontos. Desta forma, um interesse
que esteja espalhado, pode ser contido e ainda assim afectar diferentes partes do
código.
vii
O processo de testes fornece às partes interessadas uma medida da qualidade do
software produzido. É uma das fases do ciclo de desenvolvimento, e é extrema-
mente importante a fim de conseguir que o software seja de boa qualidade. O teste
de unidade é especialmente importante quando estamos a tentar criar um software
modular, pois permite testar cada módulo separadamente, isto é, sem a influência
de outros módulos.
Infelizmente, como ficará demonstrado nesta tese, a utilização de AOP dificulta
o uso de testes de unidade. A solução é descartar alguns testes ou perder parte
da modularidade ganha com o uso de AOP. Isto acontece devido à capacidade
que os aspectos têm de alterar o comportamento dos módulos existentes, fazendo
que testes que foram criados especificamente para esses módulos não funcionem
quando certos aspectos estão presentes. Alterando os testes para terem em conta
o código AOP quebra a modularidade, e a única outra opção existente é remover
esses testes.
Nesta tese, propomos a utilização de métodos de inspeção de código para criar
uma árvore de dependências entre módulos e o uso de uma abordagem de teste
incrementais que permitem testar cada camada de software em isolamento. À
medida que as camadas são adicionadas, uma após a outra, quando uma nova
camada, que contém aspectos, é adicionada, será possível marcar testes que sejam
quebrados por esta nova camada como sendo substituídos por novos testes que
levam em consideração as alterações que tenham sido introduzidas por código
AOP. Isto permite que testes de unidade em camadas mais baixas ainda possam
ser utilizados sem quebrar a modularidade prometida pelos aspectos.
Foicriadoumprojectoparaservirdebancadadetestesparaaabordagemproposta
e,nesseprojecto,fomoscapazesdecriareusartestesdeunidadequedeoutraforma
seriam impossíveis de executar. Também mostramos como a abordagem é capaz
de resolver algumas falhas comuns específicas ao AOP. Para ajudar com os testes,
desenvolvemos uma ferramenta de apoio de referência.
Acreditamos que a abordagem apresentada resolve um problema importante que
impede uma adopção mais alargada do AOP. Não assumimos ter descoberto a
solução para todos os problemas relacionados com AOP, mas achamos que esta
tese apresenta uma passo importante na direcção certa, uma vez que permite um
uso mais fácil de testes em conjunto com os aspectos.
viii
Contents
1 Introduction 1
1.1 Aspects and Modularity . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Research Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Research Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 Main Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 How to Read this Dissertation . . . . . . . . . . . . . . . . . . . . . 6
I State of the Art 9
2 Modularity 11
2.1 On the Complexity of Software . . . . . . . . . . . . . . . . . . . . 12
2.2 Principles of Software Design . . . . . . . . . . . . . . . . . . . . . 13
2.3 Modular Programming . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.1 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.2 Multiple Inheritance . . . . . . . . . . . . . . . . . . . . . . 15
2.3.3 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.4 Mixins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.5 Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
ix
2.3.6 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Crosscutting concerns . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5 Other Approaches . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5.1 Role Oriented Programming . . . . . . . . . . . . . . . . . . 19
2.5.2 Feature Oriented Programming . . . . . . . . . . . . . . . . 19
2.5.3 Subject Oriented Programming . . . . . . . . . . . . . . . . 20
2.5.4 Publish and Subscribe . . . . . . . . . . . . . . . . . . . . . 20
2.5.5 Generative Programming . . . . . . . . . . . . . . . . . . . . 21
2.5.6 Aspect Oriented Programming . . . . . . . . . . . . . . . . . 21
2.6 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3 Aspects 23
3.1 Key Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2 AspectJ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Join Point Model . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.2 Pointcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.3 Advices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.4 The Aspect Construct . . . . . . . . . . . . . . . . . . . . . 28
3.2.5 Precedence . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.6 Inter-type Declarations . . . . . . . . . . . . . . . . . . . . . 30
3.2.7 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3 AspectJ Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4 Alternative Approaches to AOP . . . . . . . . . . . . . . . . . . . . 33
3.4.1 Composition Filters . . . . . . . . . . . . . . . . . . . . . . . 33
3.4.2 Hyperslices . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
x