Test generation through programming in UDITA

@article{Gligori2010TestGT,
  title={Test generation through programming in UDITA},
  author={Milo{\vs} Gligori{\'c} and Tihomir Gvero and Vilas Jagannath and Sarfraz Khurshid and Viktor Kuncak and Darko Marinov},
  journal={2010 ACM/IEEE 32nd International Conference on Software Engineering},
  year={2010},
  volume={1},
  pages={225-234}
}
We present an approach for describing tests using non-deterministic test generation programs. To write such programs, we introduce UDITA, a Java-based language with non-deterministic choice operators and an interface for generating linked structures. We also describe new algorithms that generate concrete tests by efficiently exploring the space of all executions of non-deterministic UDITA programs. We implemented our approach and incorporated it into the official, publicly available repository… 
JQF: coverage-guided property-based testing in Java
TLDR
JQF is a platform for performing coverage-guided fuzz testing in Java that has been successful in discovering 42 previously unknown bugs in widely used open-source software such as OpenJDK, Apache Commons, and the Google Closure Compiler.
Programming and execution models for parallel bounded exhaustive testing
TLDR
This work presents the first programming and execution models, dubbed Tempo, for parallel exploration of hybrid test generation programs, and describes two different strategies for mapping the computation to parallel hardware and implement them both for GPUs and CPUs.
Fuzzing the Rust Typechecker Using CLP (T)
TLDR
This work describes how to automatically generate well-typed programs that use sophisticated type systems by phrasing the problem of well-TYped program generation in terms of Constraint Logic Programming (CLP), and how to specifically target the typechecker implementation for testing, unlike all existing work which ignores the typecheckinger.
Deductive Synthesis and Repair
TLDR
This thesis explores techniques for the development of recursive functional programs over unbounded domains that are proved correct according to their high-level specifications and formulates program repair in the framework of deductive synthesis and uses the existing program structure as a hint to guide synthesis.
Fuzzing the Rust Typechecker Using CLP
TLDR
This work describes how to automatically generate well-typed programs that use sophisticated type systems by phrasing the problem of well-TYped program generation in terms of Constraint Logic Programming (CLP), and how to specifically target the typechecker implementation for testing, unlike all existing work which ignores the typecheckinger.
Efficient generation of test data structures using constraint logic programming and program transformation
TLDR
This paper uses Constraint Logic Programming (CLP) to systematically develop generators of structurally complex test data structures and proposes a program transformation technique whose goal is to make the evaluation of these CLP-based generators much more efficient.
Unifying execution of imperative generators and declarative specifications
  • Pengyu Nie
  • Computer Science
    Proc. ACM Program. Lang.
  • 2020
TLDR
Deuterium introduces a novel, type-safe way to write method contracts entirely in Java, as a combination of imperative generators and declarative specifications (written in a first-order relational logic with transitive closure).
Scaling Testing of Refactoring Engines
  • Melina Mongiovi
  • Computer Science
    2014 IEEE International Conference on Software Maintenance and Evolution
  • 2014
TLDR
This paper improves expressiveness of the program generator for testing more kinds of refactorings, such as Extract Function, and reduces in 96% the time to test the refactoring implementations while missing only 3% of the bugs.
Scaling Testing of Refactoring Engines
TLDR
This paper improves expressiveness of the program generator for testing more kinds of refactorings, such as Extract Function, and reduces in 96% the time to test the refactoring implementations while missing only 3% of the bugs.
Test input generation using dynamic programming
TLDR
A novel input generation technique that takes constraints written as recursive predicates in the underlying programming language and uses dynamic programming to solve the constraints efficiently to effectively find bugs in production versions of Google Chrome and Apple Safari web browsers is presented.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 64 REFERENCES
Test input generation for java containers using state matching
TLDR
Techniques for automated test input generation of Java container classes, using state matching based techniques and random selection for generating test inputs, are described and abstract matching turns out to be a powerful approach for generatingtest inputs to obtain high predicate coverage.
On Delayed Choice Execution for Falsification
TLDR
The basis of the approach is the delayed-choice technique for improving the execution of guarded commands, which supports copy-propagation of symbolic values but avoids the cost of full-blown symbolic execution.
Model Checking Programs
TLDR
A verification and testing environment for Java, called Java PathFinder (JPF), which integrates model checking, program analysis and testing, and uses state compression to handle big states and partial order and symmetry reduction, slicing, abstraction, and runtime analysis techniques to reduce the state space.
TestEra: Specification-Based Testing of Java Programs Using SAT
TLDR
TestEra requires as input a Java method, a formal specification of the pre- and post-conditions of that method, and a bound that limits the size of the test cases to be generated, and automatically generates all nonisomorphic test inputs up to the given bound.
Test input generation with java PathFinder
TLDR
The main contribution of this work is to show how efficient white-box test input generation can be done for code manipulating complex data, taking into account complex method preconditions.
Optimizing Generation of Object Graphs in Java PathFinder
TLDR
Modifications of JPF are presented that reduce the search time of the Korat algorithm by over an order of magnitude and are presented as a general-purpose model checker.
Generalized Symbolic Execution for Model Checking and Testing
TLDR
A source to source translation to instrument a program is defined, which enables standard model checkers to perform symbolic execution of the program, and a novel symbolic execution algorithm is given that handles dynamically allocated structures, method preconditions and concurrency.
DART: directed automated random testing
TLDR
DART is a new tool for automatically testing software that combines three main techniques, automated extraction of the interface of a program with its external environment using static source-code parsing, and dynamic analysis of how the program behaves under random testing and automatic generation of new test inputs to direct systematically the execution along alternative program paths.
Execution Generated Test Cases: How to Make Systems Code Crash Itself
This paper presents a technique that uses code to automatically generate its own test cases at run time by using a combination of symbolic and concrete (i.e regular) execution The input values to a
Automated testing of refactoring engines
TLDR
The core of the technique is a framework for iterative generation of structurally complex test inputs that instantiate the framework to generate abstract syntax trees that represent Java programs that represent refactoring engines.
...
1
2
3
4
5
...