Examples with RealSystem org.junit.internal.RealSystem used on opensource projects

Example 1 with RealSystem

use of org.junit.internal.RealSystem in project junit4 by junit-team.

the class JUnitCore method main.

/**
     * Run the tests contained in the classes named in the <code>args</code>.
     * If all tests run successfully, exit with a status of 0. Otherwise exit with a status of 1.
     * Write feedback while tests are running and write
     * stack traces for all failed tests after the tests all complete.
     *
     * @param args names of classes in which to find tests to run
     */
public static void main(String... args) {
    Result result = new JUnitCore().runMain(new RealSystem(), args);
    System.exit(result.wasSuccessful() ? 0 : 1);
}

Example 2 with RealSystem

use of org.junit.internal.RealSystem in project jmeter by apache.

the class AllTests method main.

/**
     * Starts a run through all unit tests found in the specified classpaths.
     * The first argument should be a list of paths to search. The second
     * argument is optional and specifies a properties file used to initialize
     * logging. The third argument is also optional, and specifies a class that
     * implements the UnitTestManager interface. This provides a means of
     * initializing your application with a configuration file prior to the
     * start of any unit tests.
     * 
     * @param args
     *            the command line arguments
     */
public static void main(String[] args) {
    if (args.length < 1) {
        System.out.println("You must specify a comma-delimited list of paths to search " + "for unit tests");
        return;
    }
    String home = new File(System.getProperty("user.dir")).getParent();
    System.out.println("Setting JMeterHome: " + home);
    JMeterUtils.setJMeterHome(home);
    initializeManager(args);
    log.info("JMeterVersion={}", JMeterUtils.getJMeterVersion());
    System.out.println("JMeterVersion=" + JMeterUtils.getJMeterVersion());
    logprop("java.version", true);
    logprop("java.vm.name");
    logprop("java.vendor");
    logprop("java.home", true);
    logprop("file.encoding", true);
    // Display actual encoding used (will differ if file.encoding is not recognised)
    System.out.println("default encoding=" + Charset.defaultCharset());
    log.info("default encoding={}", Charset.defaultCharset());
    logprop("user.home");
    logprop("user.dir", true);
    logprop("user.language");
    logprop("user.region");
    logprop("user.country");
    logprop("user.variant");
    log.info("Locale={}", Locale.getDefault());
    System.out.println("Locale=" + Locale.getDefault());
    logprop("os.name", true);
    logprop("os.version", true);
    logprop("os.arch");
    logprop("java.class.version");
    String cp = System.getProperty("java.class.path");
    String[] cpe = JOrphanUtils.split(cp, java.io.File.pathSeparator);
    StringBuilder sb = new StringBuilder(3000);
    sb.append("java.class.path=");
    for (String path : cpe) {
        sb.append("\n");
        sb.append(path);
        if (new File(path).exists()) {
            sb.append(" - OK");
        } else {
            sb.append(" - ??");
        }
    }
    log.info(sb.toString());
    try {
        int maxKeyLen = Cipher.getMaxAllowedKeyLength("AES");
        System.out.println("JCE max key length = " + maxKeyLen);
    } catch (NoSuchAlgorithmException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    System.out.println("+++++++++++");
    logprop("java.awt.headless", true);
    logprop("java.awt.graphicsenv", true);
    System.out.println("------------");
    try {
        System.out.println("Searching junit tests in : " + args[0]);
        List<String> tests = findJMeterJUnitTests(args[0]);
        Class<?>[] classes = asClasses(tests);
        JUnitCore jUnitCore = new JUnitCore();
        // this listener is in the internal junit package
        // if it breaks, replace it with a custom text listener
        RunListener listener = new TextListener(new RealSystem());
        jUnitCore.addListener(listener);
        Request request = Request.classes(new Computer(), classes);
        if (GraphicsEnvironment.isHeadless()) {
            request = request.filterWith(new ExcludeCategoryFilter(NeedGuiTests.class));
        }
        Result result = jUnitCore.run(request);
        System.exit(result.wasSuccessful() ? 0 : 1);
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(1);
    }
}

Example 3 with RealSystem

use of org.junit.internal.RealSystem in project h2o-3 by h2oai.

the class H2OTestRunner method run.

public Result run(String[] args) throws Exception {
    // List all classes - adapted from JUnitCore code
    List<Class<?>> classes = new ArrayList<Class<?>>();
    List<Failure> missingClasses = new ArrayList<Failure>();
    for (String arg : args) {
        try {
            classes.add(Class.forName(arg));
        } catch (ClassNotFoundException e) {
            Description description = Description.createSuiteDescription(arg);
            Failure failure = new Failure(description, e);
            missingClasses.add(failure);
        }
    }
    // Create standard JUnitCore
    JUnitCore jcore = new JUnitCore();
    // Create default "system"
    JUnitSystem jsystem = new RealSystem();
    // Setup default listener
    jcore.addListener(new TextListener(jsystem));
    // Add XML generator listener
    jcore.addListener(new XMLTestReporter());
    Result result = jcore.run(classes.toArray(new Class[0]));
    for (Failure each : missingClasses) {
        System.err.println("FAIL Missing class in H2OTestRunner: " + each);
        result.getFailures().add(each);
    }
    return result;
}

Example 4 with RealSystem

use of org.junit.internal.RealSystem in project limelight by slagyr.

the class TestRunner method main.

public static void main(String[] args) throws Exception {
    String[] classNames = loadClassNames();
    JUnitCore.runMainAndExit(new RealSystem(), classNames);
}