¿Cómo puedo programación ejecutar todas las pruebas JUnit en mi aplicación Java?

Question

A partir de Eclipse que se puede ejecutar fácilmente todas las pruebas JUnit en mi solicitud.

I gustaría ser capaz de ejecutar las pruebas en sistemas de destino de la jarra de aplicación, sin Eclipse (o Ant o Maven o cualquier otra herramienta de desarrollo).

Puedo ver cómo ejecutar una prueba específica o suite desde la línea de comandos.

Podría crear manualmente una suite lista de todas las pruebas en mi solicitud, pero que parece propenso a errores -. Estoy seguro de que en algún momento voy a crear una prueba y olvide añadirlo a la suite

El plug-in de Eclipse JUnit tiene un asistente para crear un conjunto de pruebas, pero por alguna razón que no "ve" mis clases de prueba. Se puede estar buscando JUnit 3 pruebas, no JUnit 4 anotada pruebas.

Podría escribir una herramienta que crea automáticamente la suite mediante el escaneo de los archivos de origen.

O podría escribir código para la aplicación escaneará su propio archivo jar para pruebas (ya sea por convención de nombres o mediante la búsqueda de la anotación @test).

Parece que debe haber una manera más fácil. ¿Qué me falta?

Answer 1

Me encontré con un pequeño problema con mi última solución. Si me encontré con "todas las pruebas" de Eclipse corrieron dos veces porque se quedaron las pruebas individuales y la suite. Podría haber trabajado en todo eso, pero luego me di cuenta que había una solución más simple:

package suneido;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class RunAllTests {

    public static void run(String jarfile) {
        String[] tests = findTests(jarfile);
        org.junit.runner.JUnitCore.main(tests);
    }

    private static String[] findTests(String jarfile) {
        ArrayList<String> tests = new ArrayList<String>();
        try {
            JarFile jf = new JarFile(jarfile);
            for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements();) {
                String name = e.nextElement().getName();
                if (name.startsWith("suneido/") && name.endsWith("Test.class")
                        && !name.contains("$"))
                    tests.add(name.replaceAll("/", ".")
                            .substring(0, name.length() - 6));
            }
            jf.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return tests.toArray(new String[0]);
    }

    public static void main(String[] args) {
        run("jsuneido.jar");
    }

}

Answer 2

De acuerdo con un reciente hilo en la lista de correo JUnit, ClasspathSuite puede recoger y ejecutar todas las pruebas JUnit en la ruta de clase. No es precisamente lo que quiere, ya que es una anotación de nivel de clase, pero la fuente está disponible, por lo que puede ser capaz de extender su mecanismo de descubrimiento interno.

Answer 3

Basado en http://burtbeckwith.com/blog/?p=52 Se me ocurrió lo siguiente. Parece funcionar bien.

puedo ejecutarlo desde dentro de mi código con:

org.junit.runner.JUnitCore.main("suneido.AllTestsSuite");

Un punto débil es que se basa en una convención de nomenclatura (sufijo "Test") para identificar las pruebas. Otro punto débil es que el nombre del archivo JAR está codificado.

package suneido;

import java.io.IOException;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.model.InitializationError;

/**
 * Discovers all JUnit tests in a jar file and runs them in a suite.
 */
@RunWith(AllTestsSuite.AllTestsRunner.class)
public final class AllTestsSuite {
    private final static String JARFILE = "jsuneido.jar";

    private AllTestsSuite() {
    }

    public static class AllTestsRunner extends Suite {

        public AllTestsRunner(final Class<?> clazz) throws InitializationError {
            super(clazz, findClasses());
        }

        private static Class<?>[] findClasses() {
            List<String> classFiles = new ArrayList<String>();
            findClasses(classFiles);
            List<Class<?>> classes = convertToClasses(classFiles);
            return classes.toArray(new Class[classes.size()]);
        }

        private static void findClasses(final List<String> classFiles) {
            JarFile jf;
            try {
                jf = new JarFile(JARFILE);
                for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements();) {
                    String name = e.nextElement().getName();
                    if (name.startsWith("suneido/") && name.endsWith("Test.class")
                            && !name.contains("$"))
                        classFiles.add(name.replaceAll("/", ".")
                                .substring(0, name.length() - 6));
                }
                jf.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        private static List<Class<?>> convertToClasses(
                final List<String> classFiles) {
            List<Class<?>> classes = new ArrayList<Class<?>>();
            for (String name : classFiles) {
                Class<?> c;
                try {
                    c = Class.forName(name);
                }
                catch (ClassNotFoundException e) {
                    throw new AssertionError(e);
                }
                if (!Modifier.isAbstract(c.getModifiers())) {
                    classes.add(c);
                }
            }
            return classes;
        }
    }

}

Answer 4

No he probado esto como el momento, pero se encontró con este blog recientemente: http: // burtbeckwith.com/blog/?p=52

El autor proporciona una clase que descubre todas sus junits y los ejecuta, por lo que si esta ranura en su proyecto que puede proporcionar la capacidad necesaria?

Espero que esto ayude.

Answer 5

Obtener el proyecto Java y aprobar el proyecto

JUnitLaunchShortcut jUnitLaunchShortcut = new JUnitLaunchShortcut();
jUnitLaunchShortcut.launch("Pass the Java Project containing JUnits Classes", "run");

Answer 6

También es posible usar ANT que tiene de tareas integrado. Escribe Ant script y ejecutarlo en la máquina de destino. ANT podría crear informe como resultado.