How to recognize test classes in a project

Question

I'm using the following code to recognize test classes in a project, the whole idea is to find test classes and to compare the amount of test code with the production code! Here is a piece of my code which is responsible to find test class and count the lines:

     for (File f : list) {
        if (f.isDirectory()) {
            walk(f.getAbsolutePath());
        }

        if (f.getName().endsWith(".java")) {

            System.out.println("File:" + f.getName());
            countFiles++;

            Scanner testScanner = new Scanner(f);
            while (testScanner.hasNextLine()) {

                String test = testScanner.nextLine();
                if (test.contains("org.junit") || test.contains("org.mockito") || test.contains("org.easymock")) {
                    hasTestLines = true;
                    //      break;
                }
                testCounter++;
            }

But after running the code on several projects, I realized that the idea of finding test classes that contain Unit or EasyMock or Mockito is not the best practice to find test classes, as several projects use their own test methods! So the question is there a better way than mine to define test classes?

Thanks

Answer 1

could'nt you just load classes and pass them as parameter to a test runner like

org.junit.runner.JUnitCore.runClasses(TestClass1.class, ...);

and work with the output of the test runner.

Now the test runner searches for test methods in a class.

If the class doesn't contain any, it will not succeed and therefore be a production class. (assumed that all test classes succeed !)

In my implementation I just count the number of classes, but you can extend it to count the number of lines and then compare them.

here the implementation:

 public void compareTestAndProduction () {

    // pattern to split the name of class from it's extension
    String pattern = "(.*)(?=.class)";

    // package to proove
    String packageName = "stackoverflow.test";

    // relative path of package
    String packagePath = "stackoverflow/test";

    // counter for number of test classes
    int testCounter = 0;

   // counter for number of production classes
    int codeCounter = 0;

    // classloader for test and production classes
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

    try {
        // load package resources to file
        Enumeration enumeration = classLoader.getResources(packagePath);
        URL url = (URL) enumeration.nextElement();
        File classFiles = new File(url.getFile());

        // read all subfiles in File
        // which contains the package dir and all classes
        for (File classFile : classFiles.listFiles()) {
            String classNameWithExtension = classFile.getName();
            // proov if name of class is no directory
            if (classNameWithExtension.endsWith(".class")) {
                // extend the class with the package name
                // and get rid of the extension .class
                String className = packageName + "." + classNameWithExtension.split("[.]")[0];
                
                // load class
                Class c = classLoader.loadClass(className);
                
                // run the class with a test runnner
                // which will search class for test methods
                Result result = org.junit.runner.JUnitCore.runClasses(c.newInstance().getClass());

                // if testmethods found
                // and they are successful
                // raise testcounter
                if(result.wasSuccessful())
                    testCounter++;
                else codeCounter++;


            }
        }
        System.out.println("Test classes:\n" + testCounter);
        System.out.println("Production classes:\n" + codeCounter);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

In my case

Test classes:

1

Production classes:

2

Answer 2

In java normally production codes are kept in src/main/java and test code in src/test/java

Answer 3

Not sure what you want to achieve but test and actual code should be kept separate. You can use plugins like emma, cobertura, sonar for code coverage.

However if you are doing some exercise then see following options.

The test classes could have a Test prefix or suffix.

OR

The test classes implements/extends an interface e.g. TestCase.

OR

The test classes uses annotation at the top e.g. @TestCase.

OR

The test class having methods which are annotated e.g. @Test.

Answer 4

As long as you and your collaborators are consistent in how you make custom test classes, i.e. if you all name a test class as SomeClassTest or TestSomeClass, or perhaps you even use static methods for testing. But as long as you're consistent you should only have to look for in this example the word "test" in the title. Or if you use static method, probably a bit trickier.