Abstract: Growing dependency of mankind on software
technology increases the need for thorough testing of the software
applications and automated testing techniques that support testing
activities. We have outlined our testing strategy for performing
various types of automated testing of Java applications using
AspectJ which has become the de-facto standard for Aspect Oriented
Programming (AOP). Likewise JUnit, a unit testing framework is
the most popular Java testing tool. In this paper, we have evaluated
our proposed AOP approach for automated testing and JUnit on
various parameters. First we have provided the similarity between
the two approaches and then we have done a detailed comparison
of the two testing techniques on factors like lines of testing code,
learning curve, testing of private members etc. We established that
our AOP testing approach using AspectJ has got several advantages
and is thus particularly more effective than JUnit.
Abstract: Wide applicability of concurrent programming
practices in developing various software applications leads to
different concurrency errors amongst which data race is the most
important. Java provides greatest support for concurrent
programming by introducing various concurrency packages. Aspect
oriented programming (AOP) is modern programming paradigm
facilitating the runtime interception of events of interest and can be
effectively used to handle the concurrency problems. AspectJ being
an aspect oriented extension to java facilitates the application of
concepts of AOP for data race detection. Volatile variables are
usually considered thread safe, but they can become the possible
candidates of data races if non-atomic operations are performed
concurrently upon them. Various data race detection algorithms have
been proposed in the past but this issue of volatility and atomicity is
still unaddressed. The aim of this research is to propose some
suggestions for incorporating certain conditions for data race
detection in java programs at the volatile fields by taking into account
support for atomicity in java concurrency packages and making use
of pointcuts. Two simple test programs will demonstrate the results
of research. The results are verified on two different Java
Development Kits (JDKs) for the purpose of comparison.
Abstract: Aspect Oriented Programming promises many
advantages at programming level by incorporating the cross cutting
concerns into separate units, called aspects. Join Points are
distinguishing features of Aspect Oriented Programming as they
define the points where core requirements and crosscutting concerns
are (inter)connected. Currently, there is a problem of multiple
aspects- composition at the same join point, which introduces the
issues like ordering and controlling of these superimposed aspects.
Dynamic strategies are required to handle these issues as early as
possible. State chart is an effective modeling tool to capture dynamic
behavior at high level design. This paper provides methodology to
formulate the strategies for multiple aspect composition at high level,
which helps to better implement these strategies at coding level. It
also highlights the need of designing shared join point at high level,
by providing the solutions of these issues using state chart diagrams
in UML 2.0. High level design representation of shared join points
also helps to implement the designed strategy in systematic way.
Abstract: Although Model Driven Architecture has taken
successful steps toward model-based software development, this
approach still faces complex situations and ambiguous questions
while applying to real world software systems. One of these
questions - which has taken the most interest and focus - is how
model transforms between different abstraction levels, MDA
proposes. In this paper, we propose an approach based on Story
Driven Modeling and Aspect Oriented Programming to ease these
transformations. Service Oriented Architecture is taken as the target
model to test the proposed mechanism in a functional system.
Service Oriented Architecture and Model Driven Architecture [1]
are both considered as the frontiers of their own domain in the
software world. Following components - which was the greatest step
after object oriented - SOA is introduced, focusing on more
integrated and automated software solutions. On the other hand - and
from the designers' point of view - MDA is just initiating another
evolution. MDA is considered as the next big step after UML in
designing domain.