Testing object-oriented programs using dynamic aspects and non-determinism

Abstract

The implementation of unit tests with mock objects and stubs often involves substantial manual work. Stubbed methods return simple default values, therefore variations of these values require separate test cases. The integration of mock objects often requires more infrastructure code and design decisions exposing private data. We present an approach that both improves the expressiveness of test cases using non-deterministic choice and reduces design modifications using dynamic aspect-oriented programming techniques.Non-deterministic choice facilitates local definitions of multiple executions without parameterization or generation of tests. It also eases modelling naturally non-deterministic program features like IO or multi-threading in integration tests. Dynamic AOP facilitates powerful design adaptations without exposing test features, keeping the scope of these adaptations local to each test. We also combine nondeterminism and dynamic aspects in a new approach to testing multi-threaded programs using co-routines.

Declarative mocking

“…These frameworks make traditional stub-based mock objects easier to create, while our work focuses on making mock objects more expressive and declarative. Ostermann incorporates nondeterministic choice to make mock objects more expressive [29]; declarative mocking naturally supports nondeterminism as well as additional expressiveness.…”

A Meta-Aspect Protocol for Developing Dynamic Analyses

“…Toledo et al also deploy security aspects in the dynamic scope of application objects [23]. In earlier work, we used deployment on a block of code like in CaesarJ [4] to separate design changing aspects used in different test cases [2]. Deployment on a block is particularly powerful in combination with expressive aspect scoping [21].…”

“…Instead of one global environment, an environment stack is initialized at (5) and maintained with the callback methods at (6). The deployment method at (7) takes an aspect, a (yet unused) scoping strategy and class PerObject < AspectLanguage def initialize (1) @objects = ObjMan.new(:env) end def weaving jp (2) if objects.augmented? (jp.target) env = objects.get data(jp.target) env.iterate aspects{ |a| ... } end end end def deploy on object, a (3) env = AspectEnvironment.new env.add a LANG.objects.augment(object) LANG.objects.set data(object, env) end # Example: (4) (8) deploy tracing do sign(5) end an anonymous block as arguments.…”

“…2 and the language PerBlock defined in Fig. 5, but augment method bodies with the propagation expression at (2). The propagation expression automatically calls the context propagation of the language (which we defined in Fig.…”

“…In earlier work, we presented a test exploration tool that reduces the size of test cases by applying a non-deterministic choice operator [2]. Such an operator has also been used for the generation of complex test input [12].…”