764 research outputs found
A Systematic Aspect-Oriented Refactoring and Testing Strategy, and its Application to JHotDraw
Aspect oriented programming aims at achieving better modularization for a
system's crosscutting concerns in order to improve its key quality attributes,
such as evolvability and reusability. Consequently, the adoption of
aspect-oriented techniques in existing (legacy) software systems is of interest
to remediate software aging. The refactoring of existing systems to employ
aspect-orientation will be considerably eased by a systematic approach that
will ensure a safe and consistent migration.
In this paper, we propose a refactoring and testing strategy that supports
such an approach and consider issues of behavior conservation and (incremental)
integration of the aspect-oriented solution with the original system. The
strategy is applied to the JHotDraw open source project and illustrated on a
group of selected concerns. Finally, we abstract from the case study and
present a number of generic refactorings which contribute to an incremental
aspect-oriented refactoring process and associate particular types of
crosscutting concerns to the model and features of the employed aspect
language. The contributions of this paper are both in the area of supporting
migration towards aspect-oriented solutions and supporting the development of
aspect languages that are better suited for such migrations.Comment: 25 page
A Testing Strategy for Abstract Classes [Draft]
One of the characteristics of the increasingly widespread use of object-oriented libraries and the resulting
intensive use of inheritance is the proliferation of dependencies on abstract classes. Since abstract classes
cannot be instantiated, they cannot be tested in isolation using standard execution-based testing strategies.
A standard approach to testing abstract classes is to instantiate a concrete descendant class and test the
features that are inherited.
This paper presents a structured approach that supports the testing of features in abstract classes,
paying particular attention to ensuring that the features tested are those defined in the abstract class. Two
empirical studies are performed on a suite of large Java programs and the results presented. The first study
analyzes the role of abstract classes from a testing perspective. The second study investigates the impact
of the testing strategy on the programs in this suite to demonstrate its feasibility and to comment on the
pragmatics of its use
Using Class Interfaces and Mock Objects to Unit Test Aspects
In object oriented programming (OOP) class objects are individual units of code that encapsulate the desired functionality of each object. AOP is an attempt to handle the cross-cutting concerns that represent functionality needed by a class, but is not specific to that class. The cross-cutting functionality is implemented in AOP by using a class-like structure, the aspect. Aspects do not have their own context and as such are dependent upon other objects for their context. By not having their own context it is difficult to test the functionality of aspects. This study investigated the effectiveness of using class interfaces and mock objects to unit test aspects. This was accomplished by having the mock object inherit from the same interface as the base code, so that the mock object could be swapped in for the aspect
A systematic aspect-oriented refactoring and testing strategy, and its application to JHotDraw.
Aspect oriented programming aims at achieving better modularization for a system's crosscutting concerns in order to improve its key quality attributes, such as evolvability and reusability. Consequently, the adoption of aspect-oriented techniques in existing (legacy) software systems is of interest to remediate software aging. The refactoring of existing systems to employ aspect-orientation will be considerably eased by a systematic approach that will ensure a safe and consistent migration. In this paper, we propose a refactoring and testing strategy that supports such an approach and consider issues of behavior conservation and (incremental) integration of the aspect-oriented solution with the original system. The strategy is applied to the JHotDraw open source project and illustrated on a group of selected concerns. Finally, we abstract from the case study and present a number of generic refactorings which contribute to an incremental aspect-oriented refactoring process and associate particular types of crosscutting concerns to the model and features of the employed aspect language. The contributions of this paper are both in the area of supporting migration towards aspect-oriented solutions and supporting the development of aspect languages that are better suited for such migration
Automated Testing for Provisioning Systems of Complex Cloud Products
Context: The proliferation of cloud computing enabled companies to shift their approach
regarding infrastructure provisioning. The uprising of cloud provisioning enabled
by virtualisation technologies sprouted the rise of the Infrastructure as a Service
(IaaS) model. OutSystems takes advantage of the IaaS model to spin-up infrastructure
on-demand while abstracting the infrastructure management from the end-users.
Problem: OutSystems’ orchestrator system handles the automated orchestration of the
clients’ infrastructure, and it must be thoroughly tested. Problems arise because infrastructure
provisioning takes considerable amounts of time, which dramatically increases
the feedback loop for the developers. Currently, the duration of the orchestrator tests
hinder the ability to develop and deliver new features at a desirable pace.
Objectives: The goals of this work include designing an efficient testing strategy that
considers a microservices architecture with infrastructure provisioning capabilities while
integrating it in a Continuous Integration (CI)/Continuous Deployment (CD) pipeline.
Methods: The solution applies multiple testing techniques that target different portions
of the system and follow a pre-determined test distribution to guarantee a balanced
test suite. The strategy was tested against a set of prototypes to evaluate its adequacy and
efficiency. The strategy definition focuses on mapping the type of errors that each test
level should tackle and is, therefore, independent of the employed technologies.
Results: The devised strategy is integrated in a CI/CD pipeline and is capable of
comprehensively test the created prototypes while maintaining a short feedback loop. It
also provides support for testing against commonly found errors in distributed systems
in a deterministic way.
Conclusions: The work developed in this dissertation met the outlined objectives, as
the developed strategy proved its adequacy against the developed prototypes. Moreover,
this work provides a solid starting point for the migration of the orchestrator system to a
microservices architecture
Enhancing the Process of Testing Object -Oriented Systems.
Testing is a crucial step in the overall system development process. Using testing techniques that support features of the underlying software paradigm more effectively tests program than do testing techniques that support features of other paradigms. Systems developed with the object-oriented paradigm require techniques that support object-oriented features such as inheritance, data abstraction, encapsulation, and dynamic binding. Many techniques that are used to test systems developed with the structured paradigm are not sufficient for the testing of object-oriented systems. The goal of this research is to develop methods that will improve the process of testing object-oriented systems. Specifically, emphasis is given to improving the level of testing of methods because the level of method testing is generally considered inadequate. Algorithms are included that identify the set of methods, both interobject and intraobject, that should be tested for a given system. These algorithms are implemented as a part of an automated testing system that derives a framework for the testing of methods. This system includes the automatic generation of test drivers to facilitate the testing. It captures the results of tests for the purposes of reuse for future system maintenance. This framework provides the software engineer who is testing a system a mechanism to determine the level of method coverage that has been achieved in the testing process
- …