1. /*     */   private int parseArgs(String[] args)
2. /*     */   {
3. /* 105 */     for (int i = 0; i < args.length; i++) {
4. /* 106 */       if (args[i].equals("-e")) {
5. /* 107 */         if (i + 2 < args.length) {
6. /* 108 */           String key = args[(++i)];
7. /* 109 */           String value = args[(++i)];
8. /* 110 */           if ("class".equals(key)) {
9. /* 111 */             addTestClasses(value);
10. /* 112 */           } else if ("debug".equals(key)) {
11. /* 113 */             this.mDebug = (("true".equals(value)) || ("1".equals(value)));
12. /* 114 */           } else if ("runner".equals(key)) {
13. /* 115 */             this.mRunnerClassName = value;
14. /*     */           } else {
15. /* 117 */             this.mParams.putString(key, value);
16. /*     */           }
17. /*     */         } else {
18. /* 120 */           return -1;
19. /*     */         }
20. /* 122 */       } else if (args[i].equals("-c")) {
21. /* 123 */         if (i + 1 < args.length) {
22. /* 124 */           addTestClasses(args[(++i)]);
23. /*     */         } else {
24. /* 126 */           return -2;
25. /*     */         }
26. /* 128 */       } else if (args[i].equals("--monkey")) {
27. /* 129 */         this.mMonkey = true;
28. /* 130 */       } else if (args[i].equals("-s")) {
29. /* 131 */         this.mParams.putString("outputFormat", "simple");
30. /*     */       } else {
31. /* 133 */         return -99;
32. /*     */       }
33. /*     */     }
34. /* 136 */     return 0;
35. /*     */   }

1. /*     */   protected UiAutomatorTestRunner getRunner() {
2. /* 140 */     if (this.mRunner != null) {
3. /* 141 */       return this.mRunner;
4. /*     */     }
5. /*     */
6. /* 144 */     if (this.mRunnerClassName == null) {
7. /* 145 */       this.mRunner = new UiAutomatorTestRunner();
8. /* 146 */       return this.mRunner;
9. /*     */     }
10. /*     */
11. /* 149 */     Object o = null;
12. /*     */     try {
13. /* 151 */       Class<?> clazz = Class.forName(this.mRunnerClassName);
14. /* 152 */       o = clazz.newInstance();
15. /*     */     } catch (ClassNotFoundException cnfe) {
16. /* 154 */       System.err.println("Cannot find runner: " + this.mRunnerClassName);
17. /* 155 */       System.exit(-4);
18. /*     */     } catch (InstantiationException ie) {
19. /* 157 */       System.err.println("Cannot instantiate runner: " + this.mRunnerClassName);
20. /* 158 */       System.exit(-4);
21. /*     */     } catch (IllegalAccessException iae) {
22. /* 160 */       System.err.println("Constructor of runner " + this.mRunnerClassName + " is not accessibile");
23. /* 161 */       System.exit(-4);
24. /*     */     }
25. /*     */     try {
26. /* 164 */       UiAutomatorTestRunner runner = (UiAutomatorTestRunner)o;
27. /* 165 */       this.mRunner = runner;
28. /* 166 */       return runner;
29. /*     */     } catch (ClassCastException cce) {
30. /* 168 */       System.err.println("Specified runner is not subclass of " + UiAutomatorTestRunner.class.getSimpleName());
31. /*     */
32. /* 170 */       System.exit(-4);
33. /*     */     }
34. /*     */
35. /* 173 */     return null;
36. /*     */   }

传进来的参数就是我们刚才通过parseArgs方法设置的那些变量，run方法会把这些变量保存起来以便下面使用，紧跟着它就会调用一个start方法,这个方法非常重要，从建立每个测试方法对应的junit.framwork.TestCase对象到真正执行测试都在这个方法完成，所以也比较长，我们挑重要的部分进行分析，首先我们看以下代码：

这里面调用了TestCaseCollector这个类的addTestClasses的方法，从这个类的名字我们可以猜测到它就是专门收集测试用例用的，那么我们往下跟踪下看它是怎么收集测试用例的：

这里传进来的就是我们上面保存起来的收集了每个class名字的字串列表。里面执行了一个for循环来把每一个类的字串拿出来，然后调用addTestClass:

这里可能你会奇怪为什么会查看类名字串里面是否有＃号呢？其实在文章开头的时候我就有提出来，-c或者－e class指定的类名是可以支持 $className/$methodName来指定执行该className的methodName这个方法的，比如我可以指定-c majcit.com.UIAutomatorDemo.SettingsSample#testSetLanEng来指定只是测试该类里面的testSetLanEng这个方法。如果用户没有指定的话该methodName变量就设置成null，然后调用重载方法addTestClass方法：

• 84行：最终会调用 java.lang.ClassLoader的loadClass方法，通过指定类的名字来把该测试脚本类装载进来并赋予给clazz这个Class<?>变量，注意这里这个测试类还没有实例化的，真正实例化的地方是在下面的addSingleTestMethod中
• 85－86行：如果用户用＃号指定测试某一个类的某个方法，那么就直接传入参数clazz和要测试的methodName来调用addSingleTestMehod来组建我们需要的TestCase
• 88-91行：如果用户没用＃号指定测试某个类的某个方法，那么就需要循环取出该类的所有测试方法，然后每个方法调用一次addSingleTestMethod.

上面UiAutomatorTestRunner的start方法在调用完TestCaseCollector来建立TestCase列表后，会尝试建立AccessibilityService的连接，来看是否应该把UiAutomation设置成Monkey运行模式:

这里会初始化一个UiAutomationShellWrapper的类，其实这个类如其名，就是UiAutomation的一个Wrapper，初始化好后最终会调用UiAutomation的connect方法来连接上AccessibilityService服务，然后就可以调用AccessibilityService相应的API来把UiAutomation设置成Monkey模式来运行了。而在我们的例子中我们没有指定monkey模式的参数，所以是不会设置monkey模式的。

3.6 初始化UiDevice和UiAutomationBridge

• 初始化一个UiDevice对象
• 每执行一个测试方法之前必须给该脚本传入该UiDevice对象。大家写过UiAutomator脚本的应该都知道UiDevce不是调用构造函数而是通过getUiDevice获得的，而getUiDevice其实就是我们的测试脚本的父类UiAutomatorTestCase的方法，往后我们会看到它们是怎么联系起来的

在尝试设置monkey模式之后，UiAutomatorTestRunner会去实例化一个UiDevice，实例化后会通过以下步骤对其进行初始化：

• 首先获取上一小节提到的UiAutomationShellWrapper这个Wrapper里面的UiAutomation实例，注意这个实例在上一小节中已经连接上AccessiblityService的了
• 以这个连接好的UiAutomation为参数构造一个ShellUiAutomatorBridge，注意这里不是UiAutiomatorBridge。ShellUiAutomatorBridge时继承于UiAutomatorBridge的一个子类，里面实现了额外的几个不需要通过UiAutomation的操作，比如getRotation等是通过WindowManager来实现的
• 最后通过调用UiDevice的initialize这个方法传入ShellUiAutomatorBridge的实例来初始化我们的UiDevice
• 完成以上的初始化后，我们就拥有了一个已经通过UiAutomation连接上设备的AccessibilityService的UiDevice了，这样我们就可以随意调用AccessibilityService API来为我们服务了

这里提到的一些类也许对你会有点陌生，本人接下来会另外开文章去进行描述。

• 每个测试用例中的每个测试方法对应的junit.framework.TestCase建立好
• 已经连接上AccessibilityService的UiDevice准备好

1. package majcit.com.UIAutomatorDemo;
2. import com.android.uiautomator.core.UiDevice;
3. import com.android.uiautomator.core.UiObject;
4. import com.android.uiautomator.core.UiObjectNotFoundException;
5. import com.android.uiautomator.core.UiScrollable;
6. import com.android.uiautomator.core.UiSelector;
7. import com.android.uiautomator.testrunner.UiAutomatorTestCase;
8. public class UISelectorFindElementTest extends UiAutomatorTestCase {
9. public void testDemo() throws UiObjectNotFoundException {
10. UiDevice device = getUiDevice();
11. device.pressHome();

1. /*     */
2. /*     */   protected void start()
3. /*     */   {
4. ...
5. /* 158 */       for (TestCase testCase : testCases) {
6. /* 159 */         prepareTestCase(testCase);
7. /* 160 */         testCase.run(testRunResult);
8. /*     */       }
9. ...
10. }

1. /*     */   protected void prepareTestCase(TestCase testCase)
2. /*     */   {
3. /* 427 */     ((UiAutomatorTestCase)testCase).setAutomationSupport(this.mAutomationSupport);
4. /* 428 */     ((UiAutomatorTestCase)testCase).setUiDevice(this.mUiDevice);
5. /* 429 */     ((UiAutomatorTestCase)testCase).setParams(this.mParams);
6. /*     */   }

1. /*     */   void setUiDevice(UiDevice uiDevice)
2. /*     */   {
3. /* 100 */     this.mUiDevice = uiDevice;
4. /*     */   }

1. /*     */   public UiDevice getUiDevice()
2. /*     */   {
3. /*  72 */     return this.mUiDevice;
4. /*     */   }

1. protected void runTest() throws Throwable {
2. assertNotNull(fName); // Some VMs crash when calling getMethod(null,null);
3. Method runMethod= null;
4. try {
5. // use getMethod to get all public inherited
6. // methods. getDeclaredMethods returns all
7. // methods of this class but excludes the
8. // inherited ones.
9. runMethod= getClass().getMethod(fName, (Class[])null);
10. } catch (NoSuchMethodException e) {
11. fail("Method \""+fName+"\" not found");
12. }
13. if (!Modifier.isPublic(runMethod.getModifiers())) {
14. fail("Method \""+fName+"\" should be public");
15. }
16. try {
17. runMethod.invoke(this, (Object[])new Class[0]);
18. }
19. catch (InvocationTargetException e) {
20. e.fillInStackTrace();
21. throw e.getTargetException();
22. }
23. catch (IllegalAccessException e) {
24. e.fillInStackTrace();
25. throw e;
26. }
27. }