Engineering Abstractions in Model Checking and Testing

Abstract

Abstract-Abstractions are used in model checking to tackle problems like state space explosion or modeling of IO. The application of these abstractions in real software development processes, however, lacks engineering support. This is one reason why model checking is not widely used in practice yet and testing is still state of the art in falsification. We show how user-defined abstractions can be integrated into a Java PathFinder setting with tools like AspectJ or Javassist and discuss implications of remaining weaknesses of these tools. We believe that a principled engineering approach to designing and implementing abstractions will improve the applicability of model checking in practice.

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

“…class SalesManager def initialize ps; @ps = ps; end def calc price products, ps = nil (1) ps ||= @ps sum = 0 products.each{ |p| (2) sum += (p.price * p.number * ps.discount(p)) } sum * ps.clearance discount end end class PricingStrategy def discount product; end def clearance discount; end end…”

“….returns(clearance) return pricing strategy end (2) prods = [stub(:price=>10, :number=>2), stub(:price=>2, :number=>6)]…”

“…In earlier work, we analyzed the applicability of AspectJ [11] for integrating abstractions of program entities into a test environment [2]. While the approach is usable for mock integrations that have a global scope, it turned out to be insufficient for, e.g., usage of different mock objects in different dynamic contexts.…”

“…The Figure 6: Simple code producing a deadlock aspect intercepts creation of type1 and instead instantiates type2 with the original arguments. 10 The aspect is used for replacing Thread and Mutex at (3) using the strategy initialized at (2), that prevents a further propagation of the aspect over the call stack. The replacement classes are part of the ExploR framework and implement multi-threading with co-routines using call/cc context switches.…”

“…Static aspect-oriented programming techniques have been applied before in testing to introduce mock objects, access private data or for monitoring purposes [13,9,2,12]. Code is instrumented at compile-time or load-time, so that it is difficult to distinguish between different runtime contexts.…”