1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.test.runner; 18 19 import android.util.Log; 20 21 import org.junit.runner.Description; 22 import org.junit.runner.notification.Failure; 23 24 import java.io.PrintStream; 25 import java.lang.reflect.Method; 26 import java.util.LinkedList; 27 import java.util.List; 28 29 /** 30 * A class for loading JUnit3 and JUnit4 test classes given a set of potential class names. 31 */ 32 public class TestLoader { 33 34 private static final String LOG_TAG = "TestLoader"; 35 36 private List<Class<?>> mLoadedClasses = new LinkedList<Class<?>>(); 37 private List<Failure> mLoadFailures = new LinkedList<Failure>(); 38 39 private PrintStream mWriter; 40 41 /** 42 * Create a {@link TestLoader}. 43 * 44 * @param writer a {@link PrintStream} used for reporting errors. 45 */ TestLoader(PrintStream writer)46 public TestLoader(PrintStream writer) { 47 mWriter = writer; 48 } 49 50 /** 51 * Loads the test class from the given class name. 52 * <p/> 53 * Will store the result internally. Successfully loaded classes can be retrieved via 54 * {@link #getLoadedClasses()}, failures via {@link #getLoadFailures()}. 55 * 56 * @param className the class name to attempt to load 57 * @return the loaded class or null. 58 */ loadClass(String className)59 public Class<?> loadClass(String className) { 60 Class<?> loadedClass = doLoadClass(className); 61 if (loadedClass != null) { 62 mLoadedClasses.add(loadedClass); 63 } 64 return loadedClass; 65 } 66 doLoadClass(String className)67 private Class<?> doLoadClass(String className) { 68 try { 69 return Class.forName(className); 70 } catch (ClassNotFoundException e) { 71 String errMsg = String.format("Could not find class: %s", className); 72 Log.e(LOG_TAG, errMsg); 73 mWriter.println(errMsg); 74 Description description = Description.createSuiteDescription(className); 75 Failure failure = new Failure(description, e); 76 mLoadFailures.add(failure); 77 } 78 return null; 79 } 80 81 /** 82 * Loads the test class from the given class name. 83 * <p/> 84 * Similar to {@link #loadClass(String, PrintStream))}, but will ignore classes that are 85 * not tests. 86 * 87 * @param className the class name to attempt to load 88 * @return the loaded class or null. 89 */ loadIfTest(String className)90 public Class<?> loadIfTest(String className) { 91 Class<?> loadedClass = doLoadClass(className); 92 if (loadedClass != null && isTestClass(loadedClass)) { 93 mLoadedClasses.add(loadedClass); 94 return loadedClass; 95 } 96 return null; 97 } 98 99 /** 100 * @return whether this {@link TestLoader} contains any loaded classes or load failures. 101 */ isEmpty()102 public boolean isEmpty() { 103 return mLoadedClasses.isEmpty() && mLoadFailures.isEmpty(); 104 } 105 106 /** 107 * Get the {@link List) of classes successfully loaded via 108 * {@link #loadTest(String, PrintStream)} calls. 109 */ getLoadedClasses()110 public List<Class<?>> getLoadedClasses() { 111 return mLoadedClasses; 112 } 113 114 /** 115 * Get the {@link List) of {@link Failure} that occurred during 116 * {@link #loadTest(String, PrintStream)} calls. 117 */ getLoadFailures()118 public List<Failure> getLoadFailures() { 119 return mLoadFailures; 120 } 121 122 /** 123 * Determines if given class is a valid test class. 124 * 125 * @param loadedClass 126 * @return <code>true</code> if loadedClass is a test 127 */ isTestClass(Class<?> loadedClass)128 private boolean isTestClass(Class<?> loadedClass) { 129 // TODO: try to find upstream junit calls to replace these checks 130 if (junit.framework.Test.class.isAssignableFrom(loadedClass)) { 131 return true; 132 } 133 // TODO: look for a 'suite' method? 134 if (loadedClass.isAnnotationPresent(org.junit.runner.RunWith.class)) { 135 return true; 136 } 137 for (Method testMethod : loadedClass.getMethods()) { 138 if (testMethod.isAnnotationPresent(org.junit.Test.class)) { 139 return true; 140 } 141 } 142 Log.v(LOG_TAG, String.format("Skipping class %s: not a test", loadedClass.getName())); 143 return false; 144 } 145 } 146