1 /*
2  * Copyright (C) 2008 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 android.test.suitebuilder;
18 
19 import junit.framework.TestCase;
20 
21 import java.lang.annotation.Annotation;
22 import java.lang.reflect.Constructor;
23 import java.lang.reflect.InvocationTargetException;
24 import java.lang.reflect.Method;
25 
26 /**
27  * Represents a test to be run. Can be constructed without instantiating the TestCase or even
28  * loading the class.
29  *
30  * @deprecated New tests should be written using the
31  * <a href="{@docRoot}tools/testing-support-library/index.html">Android Testing Support Library</a>.
32  */
33 @Deprecated
34 public class TestMethod {
35 
36     private final String enclosingClassname;
37     private final String testMethodName;
38     private final Class<? extends TestCase> enclosingClass;
39 
TestMethod(Method method, Class<? extends TestCase> enclosingClass)40     public TestMethod(Method method, Class<? extends TestCase> enclosingClass) {
41         this(method.getName(), enclosingClass);
42     }
43 
TestMethod(String methodName, Class<? extends TestCase> enclosingClass)44     public TestMethod(String methodName, Class<? extends TestCase> enclosingClass) {
45         this.enclosingClass = enclosingClass;
46         this.enclosingClassname = enclosingClass.getName();
47         this.testMethodName = methodName;
48     }
49 
TestMethod(TestCase testCase)50     public TestMethod(TestCase testCase) {
51         this(testCase.getName(), testCase.getClass());
52     }
53 
getName()54     public String getName() {
55         return testMethodName;
56     }
57 
getEnclosingClassname()58     public String getEnclosingClassname() {
59         return enclosingClassname;
60     }
61 
getAnnotation(Class<T> annotationClass)62     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
63         try {
64             return getEnclosingClass().getMethod(getName()).getAnnotation(annotationClass);
65         } catch (NoSuchMethodException e) {
66             return null;
67         }
68     }
69 
70     @SuppressWarnings("unchecked")
getEnclosingClass()71     public Class<? extends TestCase> getEnclosingClass() {
72         return enclosingClass;
73     }
74 
createTest()75     public TestCase createTest()
76             throws InvocationTargetException, IllegalAccessException, InstantiationException {
77         return instantiateTest(enclosingClass, testMethodName);
78     }
79 
80     @SuppressWarnings("unchecked")
instantiateTest(Class testCaseClass, String testName)81     private TestCase instantiateTest(Class testCaseClass, String testName)
82             throws InvocationTargetException, IllegalAccessException, InstantiationException {
83         Constructor[] constructors = testCaseClass.getConstructors();
84 
85         if (constructors.length == 0) {
86             return instantiateTest(testCaseClass.getSuperclass(), testName);
87         } else {
88             for (Constructor constructor : constructors) {
89                 Class[] params = constructor.getParameterTypes();
90                 if (noargsConstructor(params)) {
91                     TestCase test = ((Constructor<? extends TestCase>) constructor).newInstance();
92                     // JUnit will run just the one test if you call
93                     // {@link TestCase#setName(String)}
94                     test.setName(testName);
95                     return test;
96                 } else if (singleStringConstructor(params)) {
97                     return ((Constructor<? extends TestCase>) constructor)
98                             .newInstance(testName);
99                 }
100             }
101         }
102         throw new RuntimeException("Unable to locate a constructor for "
103                 + testCaseClass.getName());
104     }
105 
singleStringConstructor(Class[] params)106     private boolean singleStringConstructor(Class[] params) {
107         return (params.length == 1) && (params[0].equals(String.class));
108     }
109 
noargsConstructor(Class[] params)110     private boolean noargsConstructor(Class[] params) {
111         return params.length == 0;
112     }
113 
114     @Override
equals(Object o)115     public boolean equals(Object o) {
116         if (this == o) {
117             return true;
118         }
119         if (o == null || getClass() != o.getClass()) {
120             return false;
121         }
122 
123         TestMethod that = (TestMethod) o;
124 
125         if (enclosingClassname != null
126                 ? !enclosingClassname.equals(that.enclosingClassname)
127                 : that.enclosingClassname != null) {
128             return false;
129         }
130         if (testMethodName != null
131                 ? !testMethodName.equals(that.testMethodName)
132                 : that.testMethodName != null) {
133             return false;
134         }
135         return true;
136     }
137 
138     @Override
hashCode()139     public int hashCode() {
140         int result;
141         result = (enclosingClassname != null ? enclosingClassname.hashCode() : 0);
142         result = 31 * result + (testMethodName != null ? testMethodName.hashCode() : 0);
143         return result;
144     }
145 
146     @Override
toString()147     public String toString() {
148         return enclosingClassname + "." + testMethodName;
149     }
150 }
151