Test Blueprints - Exposing Side Effects in Execution Traces to Support Writing Unit Tests

Writing unit tests for legacy systems is a key maintenance task. When writing tests for object-oriented programs, objects need to be set up and the expected effects of executing the unit under test need to be verified. If developers lack internal knowledge of a system, the task of writing tests is non-trivial. To address this problem, we propose an approach that exposes side effects detected in example runs of the system and uses these side effects to guide the developer when writing tests. We introduce a visualization called Test Blueprint, through which we identify what the required fixture is and what assertions are needed to verify the correct behavior of a unit under test. The dynamic analysis technique that underlies our approach is based on both tracing method executions and on tracking the flow of objects at runtime. To demonstrate the usefulness of our approach we present results from two case studies.

Gute Arbeit gibt herrlichen Lohn, in einer Predigt über das Evangelium am Sonntage Septuagesimae, Math. XX. 1. - 16. in der Kirche St. Leonhard in Stutgard, 1738 : mit einer eingeflossenen Anweisung, wie die vorsehende Execution des verurtheilten Juden, Joseph Süß Oppenheimers, christlich anzusehen und zu gebrauchen seye, ...

von Georg Cunrad Rieger

Execution der An̄a Maria Karpffin : ihres Alters 28 Jahr, v. Unterdencken gebürtig, welche Zu Dahlhoffen ein Kind jämerl. ermordet und noch ein anders WochenKind gestohlen ...

Thomas Bäck sc. exc.

Vorstellung der scharpffen Execution, wie selbige an 6 Malefitz Personen in der Fürstlichen Statt Wohlau, den 27. April, vnd II July deß 1661. Jahrs, vollzogen worden : Von ihrem abscheulichen Verbrechen, meldet der Text weitläufftig

Original: Text fehlt. Risse u. kleinere Fehlstellen im Kupferstich

Keyserliche Execution vber die Aechter vnd Malefitz Personen in Franckfuhrt am Mayn ergangenn : 1616

Simon Severin Aegemann fecit Anno 1616[?]

Vorstellung der Execution, welche an den beyden Wallachischen Rebellen, Horia und Klotska, zu Karlsburg vollzogen worden

I. D. D. [d.i. wahrscheinl. Johann David Donnhäuser]

Warhaffte Contrafactur und Abbildung, deren ehmals Vornehm-Berühmten drey Ungarischen Grafen : nachmals aber an Ihrer Römischen Kayserl. Mayst. höchst-vergriffenen Rebellen, Nadasti, Serini und Frangipani, mit beygefügter ausführlicher Beschreibung, was massen selbige, dem billich-ergangenem Urtheil gemäß zur Execution gezogen, und den 30. April dieses 1671. Jahrs vom Leben zum Tod gebracht worden

Portr.-Medaillons d. Rebellen u. d. Hinrichtungsszenen

Parallel execution of Prolog programs: a survey

Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this article is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The article describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory management, compile-time analysis, and execution visualization.

Cooperative Task Execution between Modular Robots Based on Tight-Loose Cooperation Strategies

The complexity in the execution of cooperative tasks is high due to the fact that a robot team requires movement coordination at the beginning of the mission and continuous coordination during the execution of the task. A variety of techniques have been proposed to give a solution to this problem assuming standard mobile robots. This work focuses on presenting the execution of a cooperative task by a modular robot team. The complexity of the task execution increases due to the fact that each robot is composed of modules which have to be coordinated in a proper way to successfully work. A combined tight and loose cooperation strategy is presented and a bar-pushing example is used as a cooperative task to show the performance of this type of system.

A methodology for granularity-based control of parallelism in logic programs

Several types of parallelism can be exploited in logic programs while preserving correctness and efficiency, i.e. ensuring that the parallel execution obtains the same results as the sequential one and the amount of work performed is not greater. However, such results do not take into account a number of overheads which appear in practice, such as process creation and scheduling, which can induce a slow-down, or, at least, limit speedup, if they are not controlled in some way. This paper describes a methodology whereby the granularity of parallel tasks, i.e. the work available under them, is efficiently estimated and used to limit parallelism so that the effect of such overheads is controlled. The run-time overhead associated with the approach is usually quite small, since as much work is done at compile time as possible. Also,a number of run-time optimizations are proposed. Moreover, a static analysis of the overhead associated with the granularity control process is performed in order to decide its convenience. The performance improvements resulting from the incorporation of grain size control are shown to be quite good, specially for systems with medium to large parallel execution overheads.