Main.java

import java.io.FileNotFoundException;
import java.io.File;
import java.util.Scanner;

import org.junit.runner.JUnitCore;
import org.junit.runner.Request;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

/**
 * Main file for running automated tests on repl.it.
 * 
 * If no command line argument is given, assumes there is a file name 
 * Tests.txt in the current directory. If a command line argument is
 * given, then that file is used as the tests file. If last argument is 
 * --verbose, then prints the stack trace for failures in addition to 
 * a message.
 *
 * Test file should have one test per line. If a # is present in the line,
 * that is assumed to separate the class name from the test method name.
 * If no # is present, then the line is assumed to represent the class name
 * and all tests in that class will be run.
 *
 * @author Anna Rafferty
 */
public class Main {
  private static boolean verbose = false;

  /**
   * Uses Junit to run the given test and print out either that the test
   * passed or information about the failure(s). If testMethodName is null,
   * this will run all tests in the class named testClassName.
   */
  public static boolean runTest(String testClassName, String testMethodName) {
    try {
      Request request;
      Class testClass = Class.forName(testClassName);
      if(testMethodName == null) {
        request = Request.aClass(testClass);
      } else {
        request = Request.method(testClass, testMethodName);
      }

      Result result = new JUnitCore().run(request);
      java.util.List<Failure> failures = result.getFailures();
      System.out.print(testClassName + getTestMethodDisplayText(testMethodName) + " ");
      if(failures.isEmpty()) {
        System.out.println("passed.");
      } else {
        System.out.println("had failures:");
        for(Failure failure : failures) {
          System.err.println(failure);
          if(verbose) {
            System.err.println(failure.getTrace());
          }
        }
      }
      return result.wasSuccessful();

    } catch(Exception e) {
      System.err.println("Failed to load a test");
      e.printStackTrace();
    }
    return false;
  }
  
  /**
   * Returns an empty string if testMethodName is null, and otherwise
   * prepends # to the string.
   */
  private static String getTestMethodDisplayText(String testMethodName) {
    if(testMethodName == null) {
      return "";
    } else {
      return "#" + testMethodName;
    }
  }

  /**
   * Returns testLine with no leading/trailing spaces and with any
   * test following // (comment) removed.
   */
  private static String removeCommentFromTest(String testLine) {
    int commentStart = testLine.indexOf("//");
    if (commentStart >= 0) {
      testLine = testLine.substring(0,commentStart);
    }
    return testLine.trim();
  }


  /**
   * Runs all tests specified in testNamesFile. See 
   * top of class for proper format for this file.
   */
  public static void runTests(String testNamesFile) {
    Scanner scanner = null;
    try {
      boolean allPassed = true;

      scanner = new Scanner(new File(testNamesFile));
      while(scanner.hasNextLine()) {
        String line = scanner.nextLine();
        line = removeCommentFromTest(line);
        if(line.length() > 0) {
          String[] testClassAndMethod = line.split("#");
          String className = testClassAndMethod[0];
          String methodName = null;
          if (testClassAndMethod.length > 1) {
            methodName = testClassAndMethod[1];
          }
          boolean passed = runTest(className, methodName);
          allPassed = allPassed && passed;
        }
        
      }
      System.out.println("All tests passed: " + allPassed);
    } catch (FileNotFoundException e) {
      System.err.println("Test file not found.");
      e.printStackTrace();
    } finally {
      if(scanner != null) {
        scanner.close();
      }
    }

  }

  /**
   * Runs test in file given by first commandline argument,
   * or if no argument is given, runs tests in Tests.txt.
   * If last argument is --verbose, then prints the stack trace
   * for failures.
   */
  public static void main(String[] args) {
    String testsFile = "Tests.txt";
    if(args.length > 0 && args[args.length - 1].equals("--verbose")) {
      Main.verbose = true;
    }
    if(args.length > 0 && !args[0].startsWith("--")) {
      testsFile = args[0];
    }
    runTests(testsFile);
  }
}