src/vogar/target/TestRunner.java - platform/external/vogar - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package vogar.target;

 import com.google.common.annotations.VisibleForTesting;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Properties;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.annotation.Nullable;
 import vogar.Result;
 import vogar.RunnerType;
 import vogar.TestProperties;
 import vogar.monitor.TargetMonitor;
 import vogar.target.junit.JUnitRunnerFactory;

 /**
  * Runs an action, in process on the target.
  */
 public final class TestRunner {

     private final String qualifiedClassOrPackageName;

     /** the monitor port if a monitor is expected, or null for no monitor */
     @VisibleForTesting final Integer monitorPort;

     /** use an atomic reference so the runner can null it out when it is encountered. */
     private final AtomicReference<String> skipPastReference;
     private final int timeoutSeconds;

     private final RunnerFactory runnerFactory;
     private final boolean profile;
     private final int profileDepth;
     private final int profileInterval;
     private final File profileFile;
     private final boolean profileThreadGroup;
     private final String[] args;
     private boolean useSocketMonitor;

     public TestRunner(Properties properties, List<String> argsList) {
         qualifiedClassOrPackageName = properties.getProperty(TestProperties.TEST_CLASS_OR_PACKAGE);
         timeoutSeconds = Integer.parseInt(properties.getProperty(TestProperties.TIMEOUT));

         int monitorPort = Integer.parseInt(properties.getProperty(TestProperties.MONITOR_PORT));
         String skipPast = null;
         boolean profile = Boolean.parseBoolean(properties.getProperty(TestProperties.PROFILE));
         int profileDepth = Integer.parseInt(properties.getProperty(TestProperties.PROFILE_DEPTH));
         int profileInterval
                 = Integer.parseInt(properties.getProperty(TestProperties.PROFILE_INTERVAL));
         File profileFile = new File(properties.getProperty(TestProperties.PROFILE_FILE));
         boolean profileThreadGroup
                 = Boolean.parseBoolean(properties.getProperty(TestProperties.PROFILE_THREAD_GROUP));

         for (Iterator<String> i = argsList.iterator(); i.hasNext(); ) {
             String arg = i.next();
             if (arg.equals("--monitorPort")) {
                 i.remove();
                 monitorPort = Integer.parseInt(i.next());
                 i.remove();
             }
             if (arg.equals("--skipPast")) {
                 i.remove();
                 skipPast = i.next();
                 i.remove();
             }
         }

         // Select the RunnerFactory instances to use based on the selected runner type.
         RunnerType runnerType =
                 RunnerType.valueOf(properties.getProperty(TestProperties.RUNNER_TYPE));
         List<RunnerFactory> runnerFactories = new ArrayList<>();
         if (runnerType.supportsCaliper()) {
             runnerFactories.add(new CaliperRunnerFactory(argsList));
         }
         if (runnerType.supportsJUnit()) {
             runnerFactories.add(new JUnitRunnerFactory());
         }
         if (runnerType.supportsMain()) {
             runnerFactories.add(new MainRunnerFactory());
         }
         runnerFactory = new CompositeRunnerFactory(runnerFactories);

         this.monitorPort = monitorPort;
         this.skipPastReference = new AtomicReference<>(skipPast);
         this.profile = profile;
         this.profileDepth = profileDepth;
         this.profileInterval = profileInterval;
         this.profileFile = profileFile;
         this.profileThreadGroup = profileThreadGroup;
         this.args = argsList.toArray(new String[argsList.size()]);
     }

     /**
      * Load the properties that were either encapsulated in the APK (if using
      * {@link vogar.android.ActivityMode}), or encapsulated in the JAR compiled by Vogar (in other
      * modes).
      *
      * @return The {@link Properties} that were loaded.
      */
     public static Properties loadProperties() {
         try {
             InputStream in = getPropertiesStream();
             Properties properties = new Properties();
             properties.load(in);
             in.close();
             return properties;
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * Configure this test runner to await an incoming socket connection when
      * writing test results. Otherwise all communication happens over
      * System.out.
      */
     public void useSocketMonitor() {
         this.useSocketMonitor = true;
     }

     /**
      * Attempt to load the test properties file from both the application and system classloader.
      * This is necessary because sometimes we run tests from the boot classpath.
      */
     private static InputStream getPropertiesStream() throws IOException {
         for (Class<?> classToLoadFrom : new Class<?>[] { TestRunner.class, Object.class }) {
             InputStream propertiesStream = classToLoadFrom.getResourceAsStream(
                     "/" + TestProperties.FILE);
             if (propertiesStream != null) {
                 return propertiesStream;
             }
         }
         throw new IOException(TestProperties.FILE + " missing!");
     }

     public void run() throws IOException {
         final TargetMonitor monitor = useSocketMonitor
                 ? TargetMonitor.await(monitorPort)
                 : TargetMonitor.forPrintStream(System.out);

         PrintStream monitorPrintStream = new PrintStreamDecorator(System.out) {
             @Override public void print(String str) {
                 monitor.output(str != null ? str : "null");
             }
         };
         System.setOut(monitorPrintStream);
         System.setErr(monitorPrintStream);

         try {
             run(monitor);
         } catch (Throwable internalError) {
             internalError.printStackTrace(monitorPrintStream);
         } finally {
             monitor.close();
         }
     }

     private void run(final TargetMonitor monitor) {
         TestEnvironment testEnvironment = new TestEnvironment();
         testEnvironment.reset();

         String classOrPackageName;
         String qualification;

         // Check whether the class or package is qualified and, if so, strip it off and pass it
         // separately to the runners. For instance, may qualify a junit class by appending
         // #method_name, where method_name is the name of a single test of the class to run.
         int hash_position = qualifiedClassOrPackageName.indexOf("#");
         if (hash_position != -1) {
             classOrPackageName = qualifiedClassOrPackageName.substring(0, hash_position);
             qualification = qualifiedClassOrPackageName.substring(hash_position + 1);
         } else {
             classOrPackageName = qualifiedClassOrPackageName;
             qualification = null;
         }

         Set<Class<?>> classes = new ClassFinder().find(classOrPackageName);

         // if there is more than one class in the set, this must be a package. Since we're
         // running everything in the package already, remove any class called AllTests.
         if (classes.size() > 1) {
             Set<Class<?>> toRemove = new HashSet<>();
             for (Class<?> klass : classes) {
                 if (klass.getName().endsWith(".AllTests")) {
                     toRemove.add(klass);
                 }
             }
             classes.removeAll(toRemove);
         }


         Profiler profiler = null;
         if (profile) {
             try {
                 profiler = Profiler.getInstance();
             } catch (Exception e) {
                 System.out.println("Profiling is disabled: " + e);
             }
         }
         if (profiler != null) {
             profiler.setup(profileThreadGroup, profileDepth, profileInterval);
         }
         for (Class<?> klass : classes) {
             TargetRunner targetRunner;
             try {
                 targetRunner = runnerFactory.newRunner(monitor, qualification, klass,
                         skipPastReference, testEnvironment, timeoutSeconds, profile, args);
             } catch (RuntimeException e) {
                 monitor.outcomeStarted(klass.getName());
                 e.printStackTrace();
                 monitor.outcomeFinished(Result.ERROR);
                 return;
             }

             if (targetRunner == null) {
                 monitor.outcomeStarted(klass.getName());
                 System.out.println("Skipping " + klass.getName()
                         + ": no associated runner class");
                 monitor.outcomeFinished(Result.UNSUPPORTED);
                 continue;
             }

             boolean completedNormally = targetRunner.run(profiler);
             if (!completedNormally) {
                 return; // let the caller start another process
             }
         }
         if (profiler != null) {
             profiler.shutdown(profileFile);
         }

         monitor.completedNormally(true);
     }

     public static void main(String[] args) throws IOException {
         new TestRunner(loadProperties(), new ArrayList<>(Arrays.asList(args))).run();
         System.exit(0);
     }

     /**
      * A {@link RunnerFactory} that will traverse a list of {@link RunnerFactory} instances to find
      * one that can be used to run the code.
      */
     private static class CompositeRunnerFactory implements RunnerFactory {

         private final List<? extends RunnerFactory> runnerFactories;

         private CompositeRunnerFactory(List<RunnerFactory> factories) {
             this.runnerFactories = factories;
         }

         @Override @Nullable
         public TargetRunner newRunner(TargetMonitor monitor, String qualification,
                 Class<?> klass, AtomicReference<String> skipPastReference,
                 TestEnvironment testEnvironment, int timeoutSeconds, boolean profile, String[] args) {
             for (RunnerFactory runnerFactory : runnerFactories) {
                 TargetRunner targetRunner = runnerFactory.newRunner(monitor, qualification, klass,
                         skipPastReference, testEnvironment, timeoutSeconds, profile, args);
                 if (targetRunner != null) {
                     return targetRunner;
                 }
             }

             return null;
         }
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package vogar.target;

	import com.google.common.annotations.VisibleForTesting;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.PrintStream;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Properties;
	import java.util.Set;
	import java.util.concurrent.atomic.AtomicReference;
	import javax.annotation.Nullable;
	import vogar.Result;
	import vogar.RunnerType;
	import vogar.TestProperties;
	import vogar.monitor.TargetMonitor;
	import vogar.target.junit.JUnitRunnerFactory;

	/**
	* Runs an action, in process on the target.
	*/
	public final class TestRunner {

	private final String qualifiedClassOrPackageName;

	/** the monitor port if a monitor is expected, or null for no monitor */
	@VisibleForTesting final Integer monitorPort;

	/** use an atomic reference so the runner can null it out when it is encountered. */
	private final AtomicReference<String> skipPastReference;
	private final int timeoutSeconds;

	private final RunnerFactory runnerFactory;
	private final boolean profile;
	private final int profileDepth;
	private final int profileInterval;
	private final File profileFile;
	private final boolean profileThreadGroup;
	private final String[] args;
	private boolean useSocketMonitor;

	public TestRunner(Properties properties, List<String> argsList) {
	qualifiedClassOrPackageName = properties.getProperty(TestProperties.TEST_CLASS_OR_PACKAGE);
	timeoutSeconds = Integer.parseInt(properties.getProperty(TestProperties.TIMEOUT));

	int monitorPort = Integer.parseInt(properties.getProperty(TestProperties.MONITOR_PORT));
	String skipPast = null;
	boolean profile = Boolean.parseBoolean(properties.getProperty(TestProperties.PROFILE));
	int profileDepth = Integer.parseInt(properties.getProperty(TestProperties.PROFILE_DEPTH));
	int profileInterval
	= Integer.parseInt(properties.getProperty(TestProperties.PROFILE_INTERVAL));
	File profileFile = new File(properties.getProperty(TestProperties.PROFILE_FILE));
	boolean profileThreadGroup
	= Boolean.parseBoolean(properties.getProperty(TestProperties.PROFILE_THREAD_GROUP));

	for (Iterator<String> i = argsList.iterator(); i.hasNext(); ) {
	String arg = i.next();
	if (arg.equals("--monitorPort")) {
	i.remove();
	monitorPort = Integer.parseInt(i.next());
	i.remove();
	}
	if (arg.equals("--skipPast")) {
	i.remove();
	skipPast = i.next();
	i.remove();
	}
	}

	// Select the RunnerFactory instances to use based on the selected runner type.
	RunnerType runnerType =
	RunnerType.valueOf(properties.getProperty(TestProperties.RUNNER_TYPE));
	List<RunnerFactory> runnerFactories = new ArrayList<>();
	if (runnerType.supportsCaliper()) {
	runnerFactories.add(new CaliperRunnerFactory(argsList));
	}
	if (runnerType.supportsJUnit()) {
	runnerFactories.add(new JUnitRunnerFactory());
	}
	if (runnerType.supportsMain()) {
	runnerFactories.add(new MainRunnerFactory());
	}
	runnerFactory = new CompositeRunnerFactory(runnerFactories);

	this.monitorPort = monitorPort;
	this.skipPastReference = new AtomicReference<>(skipPast);
	this.profile = profile;
	this.profileDepth = profileDepth;
	this.profileInterval = profileInterval;
	this.profileFile = profileFile;
	this.profileThreadGroup = profileThreadGroup;
	this.args = argsList.toArray(new String[argsList.size()]);
	}

	/**
	* Load the properties that were either encapsulated in the APK (if using
	* {@link vogar.android.ActivityMode}), or encapsulated in the JAR compiled by Vogar (in other
	* modes).
	*
	* @return The {@link Properties} that were loaded.
	*/
	public static Properties loadProperties() {
	try {
	InputStream in = getPropertiesStream();
	Properties properties = new Properties();
	properties.load(in);
	in.close();
	return properties;
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	}

	/**
	* Configure this test runner to await an incoming socket connection when
	* writing test results. Otherwise all communication happens over
	* System.out.
	*/
	public void useSocketMonitor() {
	this.useSocketMonitor = true;
	}

	/**
	* Attempt to load the test properties file from both the application and system classloader.
	* This is necessary because sometimes we run tests from the boot classpath.
	*/
	private static InputStream getPropertiesStream() throws IOException {
	for (Class<?> classToLoadFrom : new Class<?>[] { TestRunner.class, Object.class }) {
	InputStream propertiesStream = classToLoadFrom.getResourceAsStream(
	"/" + TestProperties.FILE);
	if (propertiesStream != null) {
	return propertiesStream;
	}
	}
	throw new IOException(TestProperties.FILE + " missing!");
	}

	public void run() throws IOException {
	final TargetMonitor monitor = useSocketMonitor
	? TargetMonitor.await(monitorPort)
	: TargetMonitor.forPrintStream(System.out);

	PrintStream monitorPrintStream = new PrintStreamDecorator(System.out) {
	@Override public void print(String str) {
	monitor.output(str != null ? str : "null");
	}
	};
	System.setOut(monitorPrintStream);
	System.setErr(monitorPrintStream);

	try {
	run(monitor);
	} catch (Throwable internalError) {
	internalError.printStackTrace(monitorPrintStream);
	} finally {
	monitor.close();
	}
	}

	private void run(final TargetMonitor monitor) {
	TestEnvironment testEnvironment = new TestEnvironment();
	testEnvironment.reset();

	String classOrPackageName;
	String qualification;

	// Check whether the class or package is qualified and, if so, strip it off and pass it
	// separately to the runners. For instance, may qualify a junit class by appending
	// #method_name, where method_name is the name of a single test of the class to run.
	int hash_position = qualifiedClassOrPackageName.indexOf("#");
	if (hash_position != -1) {
	classOrPackageName = qualifiedClassOrPackageName.substring(0, hash_position);
	qualification = qualifiedClassOrPackageName.substring(hash_position + 1);
	} else {
	classOrPackageName = qualifiedClassOrPackageName;
	qualification = null;
	}

	Set<Class<?>> classes = new ClassFinder().find(classOrPackageName);

	// if there is more than one class in the set, this must be a package. Since we're
	// running everything in the package already, remove any class called AllTests.
	if (classes.size() > 1) {
	Set<Class<?>> toRemove = new HashSet<>();
	for (Class<?> klass : classes) {
	if (klass.getName().endsWith(".AllTests")) {
	toRemove.add(klass);
	}
	}
	classes.removeAll(toRemove);
	}


	Profiler profiler = null;
	if (profile) {
	try {
	profiler = Profiler.getInstance();
	} catch (Exception e) {
	System.out.println("Profiling is disabled: " + e);
	}
	}
	if (profiler != null) {
	profiler.setup(profileThreadGroup, profileDepth, profileInterval);
	}
	for (Class<?> klass : classes) {
	TargetRunner targetRunner;
	try {
	targetRunner = runnerFactory.newRunner(monitor, qualification, klass,
	skipPastReference, testEnvironment, timeoutSeconds, profile, args);
	} catch (RuntimeException e) {
	monitor.outcomeStarted(klass.getName());
	e.printStackTrace();
	monitor.outcomeFinished(Result.ERROR);
	return;
	}

	if (targetRunner == null) {
	monitor.outcomeStarted(klass.getName());
	System.out.println("Skipping " + klass.getName()
	+ ": no associated runner class");
	monitor.outcomeFinished(Result.UNSUPPORTED);
	continue;
	}

	boolean completedNormally = targetRunner.run(profiler);
	if (!completedNormally) {
	return; // let the caller start another process
	}
	}
	if (profiler != null) {
	profiler.shutdown(profileFile);
	}

	monitor.completedNormally(true);
	}

	public static void main(String[] args) throws IOException {
	new TestRunner(loadProperties(), new ArrayList<>(Arrays.asList(args))).run();
	System.exit(0);
	}

	/**
	* A {@link RunnerFactory} that will traverse a list of {@link RunnerFactory} instances to find
	* one that can be used to run the code.
	*/
	private static class CompositeRunnerFactory implements RunnerFactory {

	private final List<? extends RunnerFactory> runnerFactories;

	private CompositeRunnerFactory(List<RunnerFactory> factories) {
	this.runnerFactories = factories;
	}

	@Override @Nullable
	public TargetRunner newRunner(TargetMonitor monitor, String qualification,
	Class<?> klass, AtomicReference<String> skipPastReference,
	TestEnvironment testEnvironment, int timeoutSeconds, boolean profile, String[] args) {
	for (RunnerFactory runnerFactory : runnerFactories) {
	TargetRunner targetRunner = runnerFactory.newRunner(monitor, qualification, klass,
	skipPastReference, testEnvironment, timeoutSeconds, profile, args);
	if (targetRunner != null) {
	return targetRunner;
	}
	}

	return null;
	}
	}
	}