BPMN-based Process-Driven Applications (PDA) require less coding since they are not only based on source code, but also on executable process models. Automated testing of such model-driven applications gains growing relevance, and it becomes a key enabler if we want to found their development on continuous integration (CI) techniques.While process analysts are typically responsible for test case specifications from a business perspective, technically skilled process engineers take the responsibility for implementing the required test code. This is time-consuming and, due to their often different skills and backgrounds, might result in communication problems such as information losses and misunderstandings. This paper presents a new approach which enables an analyst to generate executable tests for PDAs without the need for manual coding. It consists of a sophisticated model analysis, a wizard-based specification of test cases, and a subsequent code generation. The resulting tests can easily be integrated into CI pipelines.The concept is underpinned by a user-friendly tool which has been evaluated in case studies and in real-world implementation projects from different industry sectors. During the evaluation, the prototype proved a more efficient test creation process and a higher test quality.

Constraint-logic object-oriented programming facilitates the integrated development of business software that occasionally solves constraint-logic problems or makes other use of structured search. So far, work in constraint-logic object-oriented programming has been limited to considering constraints that only involve logic variables of primitive types; in particular, boolean, integer, and floating-point numbers. However, the availability of object-oriented features calls for the option to use logic variables in lieu of objects as well. Therefore, support for reference-type logic variables (or free objects) is required. With the work at hand, we add support for free objects to a Java-based constraint-logic object-oriented language, Muli. Allowing free objects in statements and expressions results in novel interactions with objects at run time, for instance, non-deterministic execution of polymorphic method invocations (taking arbitrary class hierarchies into account) and non-deterministic type operations. At run time, this is supported by a dynamic type constraint that restricts the possible types of a free object at non-deterministic choices.

Ant Colony Optimization (ACO) is a well known population-based algorithm used for solving combinatorial optimization problems, such as the Traveling Salesman Problem (TSP). The parallelization of ACO becomes necessary when tackling bigger instances of the TSP due to the high number of calculations performed. Many parallel approaches have been already proposed for ACO, in particular for contemporary high-performance hardware, such as GPUs. Typically, the ants are treated in parallel, since they are largely independent. In the case of the TSP, this concerns in particular the tour construction phase. Furthermore, strategies for parallelizing the pheromone deposit and evaporation phase were proposed. The achieved overall speedup hence depends on a combination of different parallelization strategies, where the impact of each strategy depends on the characteristics of the considered application problem and the hardware used. In the present paper, we aim to compare and analyze the performance of ACO implementations using distinct parallelization strategies when solving TSP instances of different magnitudes. At first, a comparison is made between a coarse-grain and a fine-grain parallel ACO. Furthermore the impact of the parallelization of the pheromone deposit process is also analyzed. The results show that there is no overall best parallelization strategy. Also, they highlight the importance of key-points that lead to a reduction of the execution time, such as the occupancy of the GPU and the work load shared among threads.

This paper proposes a mechanism of dynamic adjustment of the population size of population based metaheuristics in order to balance its efficacy and efficiency. In this approach, an external trajectory based metaheuristic (MH) is used to dynamically adjust the population size of an inner population based metaheuristic. A Particle Swarm Optmization (PSO) implemented for a Compute Unified Device Architecture platform (CUDA), called CUDA-PSO, is used as inner MH, while a sequential Simulated Annealing (SA) is used as an external one. The main objective of this paper is to evaluate the SA capabilities of finding a good balance between efficiency and efficacy during the CUDA-PSO execution and to assess its adaptability to different hardwares without any prior information about the computing platform. The results show that the new approach was able to find a good balance in most cases. Also, it was observed that this approach is able to adapt its operation to different hardwares.

The manual generation of test cases for unit tests is tedious. We have developed the tool Muggl, which generates test cases based on symbolic execution and constraint solving. Solving constraints for this purpose is no trivial task and greatly attributes to the total runtime. Hence, we developed a solver for linear constraints adapted to the special needs of Muggl. It takes into account the particularities of constraint retrieval through symbolic execution. Specifically, it is capable of incremental addition and backtracking of constraints. Moreover, we have developed an approach to avoid rounding errors.

Algorithmic skeletons encapsulate typical parallel programming patterns such that they can be easily applied by users. Existing skeleton libraries usually work on distributed memory machines. We present an extension of our skeleton library Muesli which now allows to use the same application without modifications on a variety of parallel machines ranging from multi-processor distributed memory to many-core shared memory machines and combinations of those such as clusters of multi-core nodes. Internally, the skeletons are based on MPI and Open MP. We demonstrate the efficiency of our approach by providing experimental results.

We present a tool for the automated generation of unit tests. It symbolically executes Java bytecode in order to find execution paths through a program. To efficiently accomplish this task, it uses constraint solving, choice-point generation and backtracking. As the number of test cases found might be very high and most of them are redundant, we propose a novel way to eliminate test cases based on their contribution to the global coverage of the control-flow and data-flow. Besides discussing the techniques used to achieve this, we present experimental results to prove the feasibility of our approach.

We employ the narrowing-based execution mechanism of the functional logic programming language Curry in order to automatically generate a system of test cases for glass-box testing of Curry programs. The test cases for a given function are computed by narrowing a call to that function with initially uninstantiated arguments. The generated test cases are produced w.r.t. a selected code-coverage criterion such as control-flow coverage. Besides an adaption of the notion of control-flow coverage to functional (logic) programming, we present a novel coverage criterion for this programming paradigm. A particular difficulty of the adaption is the handling of laziness.

Abstract Message passing based on libraries such as MPI is typically used to program parallel machines with distributed memory. This is efficient, but error prone. Algorithmic skeletons are intended to simplify parallel programming by increasing expressive power. The idea is to offer typical parallel programming patterns as polymorphic higher‐order functions which are efficiently implemented in parallel. The present paper describes how C++ templates and operator overloading can be used in order to provide the main features needed for algorithmic skeletons, namely higher‐order functions, partial applications and parametric polymorphism. Experimental results based on a draft implementation of our C++ skeleton library show that higher expressive power can be gained without a significant performance penalty. Copyright © 2005 John Wiley & Sons, Ltd.

We present Skil, an imperative language enhanced with higher order functions and currying, as well as with a polymorphic type system. The high level of Skil allows the integration of algorithmic skeletons, i.e. of higher order functions representing parallel computation patterns. At the same time, the language can be efficiently implemented. After describing a series of skeletons which work with distributed arrays, we give two examples of parallel programs implemented on the basis of skeletons, namely shortest paths in graphs and Gaussian elimination. Run time measurements show that we approach the efficiency of message passing C up to a factor between 1 and 2.5.