UDITA: Language for Test Generation

Welcome to the UDITA project homepage. UDITA is a language that allows users to combine the expressive strengths of both filtering (declarative) and generating (imperative) test abstractions to create more expressive composable test generation programs. UDITA also provides execution mechanisms to ensure that greater expressiveness also leads to greater efficiency.

On This Page

• Publications
• Supplemental Experimental Results
• Red Black Tree Source
• How to use UDITA

Publicationsback to the top

Test Generation through Programming in UDITA

By Milos Gligoric, Tihomir Gvero, Vilas Jagannath, Sarfraz Khurshid, Viktor Kuncak, and Darko Marinov.
32nd International Conference on Software Engineering
(ICSE 2010), pages 225-234, Cape Town, South Africa, May 2010. pdf.

On Test Generation through Programming in UDITA

By Milos Gligoric, Tihomir Gvero, Vilas Jagannath, Sarfraz Khurshid, Viktor Kuncak, and Darko Marinov.
In EPFL Technical Report LARA-REPORT-005, September 2009. web page.

Supplemental Experimental Resultsback to the top

Bugs found using UDITA

We found bugs in Eclipse (3.3.2), NetBeans (6.5), Sun javac (1.6.0_16) and Java PathFinder (4.0, SVN revision 1849) using UDITA based test generation programs. The bug reports for those bugs are as follows:

Eclipse bug reports

• Bug 289306: [use supertype] incorrectly changes method return type to return type of overridden method
• Bug 289307: [infer type arguments] Refactoring incorrectly infers the generic type of a returned variable (recursive List>)

NetBeans bug reports

• Issue 172345: Rename refactoring leads to compilation error when applied on a method in a complex class hierarchy
• Issue 172346: Use Super Type Where Possible refactoring leads to a compilation error when applied to a class in a complex class hierarcy

Sun javac bug reports

Both these bug reports have been submitted to Sun and are being considered for addition into their bug database.

• Valid program that uses multiple interface inheritance is not accepted:
The following program is valid and should be compiled successfully by javac:

interface C {
  public C m(); 
}
interface B {
  public B m(); 
}
interface A extends B, C {
  public A m(); 
}

However javac does not accept the program and gives the following error:

types C and B are incompatible; both define m(), but with unrelated return types

• Valid program that uses an inner class along with inheritance is not accepted:
The following program is valid and should be compiled successfully by javac:

public class A {
    private void m(){}
    class B extends A {
        void m(int i){ 
            m();
        }
    }
}

However javac does not accept the program and gives the following error:

m(int) in A.B cannot be applied to ()

JPF bug reports and patches

• Bug 2857234: java.lang.reflect.Field.getBoolean OutOfBoundException
• Bug 2859785: Field.set() throws an exception when setting a static long
• Bug 2859790: Class.cast() method throws an exception when casting array
• Class.toString() bug: We patched this bug and sent the patch to JPF developers. The patch can be accessed here.
• Class.getField() NoSuchFieldFoundException bug: We also patched this bug and sent the patch to JPF developers. The patch can be accessed here.

Red Black Tree Sourceback to the top

Another case study we used to evaluate UDITA was a Red Black Tree implementation. You can find the Java and C# sources for the implementation along with all the versions of it with seeded bugs here.

How to use UDITA?back to the top

Here are the instructions for running UDITA to test JPF itself (more specifically, to test conformance of the JPF's JVM to a regular JVM). Note that these instructions were written for the old JPF repository hosted on SourceForge; JPF was meanwhile moved to NASA servers and SourceForge repository was discontinued.

• Check out one of the latest revisions of JPF from SourceForge:

  svn co -r1849 https://javapathfinder.svn.sourceforge.net/svnroot/javapathfinder/trunk jpf-test
  cd jpf-test
  

• Apply the following patch on top of JPF (which changes some core classes and thus was not included in the old JPF repository):

  wget http://mir.cs.illinois.edu/udita/jpf-patch-to-read-rsc-files
  patch -p0 <jpf-patch-to-read-rsc-files
  

• Add the following UDITA generators for testing JPF (these generators depend on two jar files for AST libraries from Eclipse and were not included into the JPF repository since they are large and not used in any other JPF extension):

  wget http://mir.cs.illinois.edu/udita/jpf-udita.tgz
  tar xfvz jpf-udita.tgz
  

• Run the main script that compiles everything, runs the UDITA generators to create test programs, and runs JPF and JVM to compare their outputs:

  ./run-jpfvsjvm-generators-and-testing

The above downloads also get the files needed for generating programs for testing refactoring engines in Eclipse and NetBeans and for comparing ASTGen and UDITA:

• To generate programs used for comparing ASTGen and UDITA, run the following script:

  ./run-astgen-comparison-generators

• To generate programs used for testing Eclipse and NetBeans, run the following script:

  ./run-new-refactorings-test-generators