Smart test data generators via logic programming

Test data generation is one of the most technically challenging steps of testing software, but most commercial systems currently incorporate very little automation for this step. This paper presents results from a project that is trying to find ways to incorporate test data generation into practical test processes. The results include a new procedure for automatically generating test data that incorporates ideas from symbolic evaluation, constraint-based testing, and dynamic test data generation. It takes an initial set of values for each input, and dynamically ‘pushes’ the values through the control-flow graph of the program, modifying the sets of values as branches in the program are taken. The result is usually a set of values for each input parameter that has the property that any choice from the sets will cause the path to be traversed. This procedure uses new analysis techniques, offers improvements over previous research results in constraint-based testing, and combines several steps into one coherent process. The dynamic nature of this procedure yields several benefits. Moving through the control flow graph dynamically allows path constraints to be resolved immediately, which is more efficient both in space and time, and more often successful than constraint-based testing. This new procedure also incorporates an intelligent search technique based on bisection. The dynamic nature of this procedure also allows certain improvements to be made in the handling of arrays, loops, and expressions; language features that are traditionally difficult to handle in test data generation systems. The paper presents the test data generation procedure, examples to explain the working of the procedure, and results from a proof-of-concept implementation. Copyright © 1999 John Wiley & Sons, Ltd.

Automated test data generation is a challenging problem for researchers in the area of software testing. Up until now, most of the work on test data generation is at unit level. Until level test data generation involves the execution of test path at unit level where interaction with other components is minimum. Test data generation for unit testing involves a single path and there is no usage of formal and actual parameters. The problem of automated test data generation becomes very challenging when we move to other levels of testing including integration testing and system level testing. At integration level, the variables are passed as arguments to other components and variables change their names; also multiple paths are executed from different components to ensure proper functionality. Recently evolutionary approaches have been proven a powerful tool for test data generation. In this paper, we have proposed a novel approach for test data generation for coupling based integration testing using particle swarm optimization. Up until now, there is no research for test data generation for coupling based integration testing using particle swarm optimization. Our approach takes the coupling path as input, containing different sub paths, and generates the test data using particle swarm optimization. We have also proposed architecture of tool for automation of our approach. In future, we will implement our proposed approach and will perform different experiments to prove its significance.

One of the ways of test data generation is using the path-oriented (path-wise) test data generator. This generator takes the program code and test adequacy criteria as input and generates the test data in order to satisfy the adequacy criteria. One of the problems of this generator in test data generation is the lack of attention to generating the diagnostic test data. In this paper a new approach has been proposed for path-oriented test data generation and by utilizing it, test data is generated automatically realizing the goal of discovering more important errors in the least amount of time. Since that some of the instructions of any programming language are more error-prone, so the paths that contain these instructions are selected for perform test data generation process. Then, the input domains of these paths variables are divided by a divide-and-conquer algorithm to the subdomains. A set of different subdomains is called hyper cuboids, and test data will be generated by these hyper cuboids. We apply our method in some programs, and compare it with some previous methods. Experimental results show proposed approach outperforms same previous approaches.

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

In software testing process, test data generation represents an important step for high quality software, even for mobile devices. As proposed in previous works, a potential source for random data generation is represented by the UI layout files that are used for almost all mobile platforms (Android, iOS, Windows Phone/Mobile). This paper continues the previous work and presents a test data generation system based on Android layout files. The test data generator uses DSL files as input and generates test data that conform to several testing principles. The generated test data could be stored in XML files or any format required by the testing frameworks.

Structural test data generation using a memetic ant colony optimization based on evolution strategies

A software requirement standards by IEC is now in draft stage. The publication has already been nubered as IEC 60183-4 which regulates software analysing digitally measured a.c. and d.c. data. TDG (Test Data Generator) like IEC 61083-2 comes with IEC 61083-4. A software used in accreditation laboratory or higher class has to process TDG data within reference values specified in the IEC standards. Authors could develop fast, precise algorithms to process TDG data. Each technique is summarised as: 1) Digital filter for eliminating superposed noise, 2) Fast Fourier Transform for analysing periodical waveform (steady a.c.), 3) an introduction of fitting curve for a.c current interruption and 4) proposal of low-pass filter used to eliminate high frequency noise. The third yields a set of non-linear equations which can be solved by Levenberg-Marquardt Method. The distilled parameters for short-time a.c. are confirmed to be much smaller than the margins (0.1% in peak value) even with a large noise superposed.

The higher-order logic found in proof assistants such as Coq and various HOL systems provides a convenient setting for the development and verification of pure functional programs. However, to efficiently run these programs, they must be converted (or "extracted") to functional programs in a programming language such as ML or Haskell. With current techniques, this step, which must be trusted, relates similar looking objects that have very different semantic definitions, such as the set-theoretic model of a logic and the operational semantics of a programming language. In this paper, we show how to increase the trustworthiness of this step with an automated technique. Given a functional program expressed in higher-order logic, our technique provides the corresponding program for a functional language defined with an operational semantics, and it provides a mechanically checked theorem relating the two. This theorem can then be used to transfer verified properties of the logical function to the program. We have implemented our technique in the HOL4 theorem prover, translating functions to a core subset of Standard ML, and have applied it to examples including functional data structures, a parser generator, cryptographic algorithms, and a garbage collector.

Languages that integrate functional and logic programming with a complete operational semantics are based on narrowing, a unification-based goal-solving mechanism which subsumes the reduction principle of functional languages and the resolution principle of logic languages. In this article, we present a partial evaluation scheme for functional logic languages based on an automatic unfolding algorithm which builds narrowing trees. The method is formalized within the theoretical framework established by Lloyd and Shepherdson for the partial deduction of logic programs, which we have generalized for dealing with functional computations. A generic specialization algorithm is proposed which does not depend on the eager or lazy nature of the narrower being used. To the best of our knowledge, this is the first generic algorithm for the specialization of functional logic programs. We also discuss the relation to work on partial evaluation in functional programming, term-rewriting systems, and logic programming. Finally, we present some experimental results with an implementation of the algorithm which show in practice that the narrowing-driven partial evaluator effectively combines the propagation of partial data structures (by means of logical variables and unification) with better opportunities for optimization (thanks to the functional dimension).

Standard ML is a strictly typed functional programming language that provides programmers with many powerful features, including parametric polymorphism, pattern matching, and a rich module system. In this paper, we present SMLtoJs, an optimizing compiler that compiles Standard ML programs into JavaScript to be executed in any JavaScript-supported Web browser. SMLtoJs supports all of Standard ML and most of the Standard ML Basis Library, which allows for the SMLtoJs compiler itself to be compiled and executed in a browser. We present the overall structure of SMLtoJs, including the non-JavaScript aware front-end and the JavaScript-specific backend. We also present SMLtoJs's type safe interface for interacting with native JavaScript, such as the DOM api. Finally, we present the details of the JavaScript-specific optimizations, including how SMLtoJs deals with tail recursion, which enable complex Standard ML programs to be compiled into efficient JavaScript.

In search based test data generation, the problem of test data generation is reduced to that of function minimization or maximization.Traditionally, for branch testing, the problem of test data generation has been formulated as a minimization problem.In this paper we define an alternate maximization formulation and experimentally compare it with the minimization formulation.We use genetic algorithm and binary particle swarm optimization as the search technique and in addition to the usual operators we also employ a branch ordering strategy, memory and elitism.Results indicate that there is no significant difference in the performance or the coverage obtained through the two approaches and either could be used in test data generation when coupled with the branch ordering strategy, memory and elitism.

Cost-effective and compact systems are required for modern airborne earth surveillance and observation platforms. Frequency Modulated Continuous Wave (FMCW) technology and synthetic aperture techniques together yield such systems. FMCW systems are very useful for earth surveillance in both civil and military applications. Huge computation power is required for real time Synthetic Aperture Radar (SAR) processing. SAR system should be simulated before actual system development in order to understand, analyze and estimate its performance. In this paper, development of Offline SAR Signal Processor and Test Data Generator is presented. SAR Processor forms focused images using raw data either generated from Test Data Generator or acquired from real FMCW SAR system. For the validation of image formation algorithms before actual system development, synthetic/test data is needed. Test Data Generator development fulfills this purpose.

A new method is presented for the automated random generation of valid content-sensitive test data and corresponding oracle information. The process takes as input a specification of the program under test, expressed as a functional program, and produces as output test cases consisting of test data and oracle information. The test data is guaranteed to be an element of the valid input space defined by the specification. Examples of the process are presented.

A new declarative programming paradigm, constraint functional logic programming (CFLP) is presented, which unifies systematically all features of constraint, functional and logic programming. CFLP extends constraint functional programming (CFP), which supports equation solving over a functional program, to general constraint programming permitting the use of constraints for programming as well as for posing queries. It also generalises constraint logic programming (CLP), by admitting user-defined functions as a purely functional subsystem of a CLP language. This paper presents the motivation for designing CFLP and its semantics. Programming examples are given in the concrete CFLP language Falcon.KeywordsLogic ProgramLogic ProgrammingConstraint ProgrammingConstraint SystemFunctional ProgrammingThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.