[Android] Rewrite base test result classes.

build/android/pylib/base/shard_unittest.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Unittests for shard.py."""
 
 import os
 import sys
 import unittest
 
 sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)),
                 os.pardir, os.pardir))
 
 # Mock out android_commands.GetAttachedDevices().
 from pylib import android_commands
 android_commands.GetAttachedDevices = lambda: ['0', '1']
 
+from base_test_result import BaseTestResult

[craigdh, 2013/03/23 00:41:39]

Don't import classes. Should be import base_test_result then
base_test_result.ClassName everywhere else.

[frankf, 2013/03/23 01:32:59]

Done.

+from base_test_result import TestRunResults
+from base_test_result import TestType
 import shard
-import test_result
 
 
 class TestException(Exception):
   pass
 
 
 class MockRunner(object):
   """A mock TestRunner."""
   def __init__(self, device='0', shard_index=0):
     self.device = device
     self.shard_index = shard_index
     self.setups = 0
     self.teardowns = 0
 
   def RunTest(self, test):
-    return (test_result.TestResults.FromRun(
-                ok=[test_result.BaseTestResult(test, '')]),
-            None)
+    results = TestRunResults()
+    results.AddResult(BaseTestResult(test, TestType.PASS))
+    return (results, None)
 
   def SetUp(self):
     self.setups += 1
 
   def TearDown(self):
     self.teardowns += 1
 
 
 class MockRunnerFail(MockRunner):
   def RunTest(self, test):
-    return (test_result.TestResults.FromRun(
-                failed=[test_result.BaseTestResult(test, '')]),
-            test)
+    results = TestRunResults()
+    results.AddResult(BaseTestResult(test, TestType.FAIL))
+    return (results, test)
 
 
 class MockRunnerFailTwice(MockRunner):
   def __init__(self, device='0', shard_index=0):
     super(MockRunnerFailTwice, self).__init__(device, shard_index)
     self._fails = 0
 
   def RunTest(self, test):
     self._fails += 1
+    results = TestRunResults()
     if self._fails <= 2:
-      return (test_result.TestResults.FromRun(
-                  failed=[test_result.BaseTestResult(test, '')]),
-              test)
+      results.AddResult(BaseTestResult(test, TestType.FAIL))
+      return (results, test)
     else:
-      return (test_result.TestResults.FromRun(
-                  ok=[test_result.BaseTestResult(test, '')]),
-            None)
+      results.AddResult(BaseTestResult(test, TestType.PASS))
+      return (results, None)
 
 
 class MockRunnerException(MockRunner):
   def RunTest(self, test):
     raise TestException
 
 
 class TestFunctions(unittest.TestCase):
   """Tests for shard._RunTestsFromQueue."""
   @staticmethod
   def _RunTests(mock_runner, tests):
     results = []
     tests = shard._TestCollection([shard._Test(t) for t in tests])
     shard._RunTestsFromQueue(mock_runner, tests, results)
-    return test_result.TestResults.FromTestResults(results)
+    run_results = TestRunResults()
+    for r in results:
+      run_results.AddTestRunResults(r)
+    return run_results
 
   def testRunTestsFromQueue(self):
     results = TestFunctions._RunTests(MockRunner(), ['a', 'b'])
-    self.assertEqual(len(results.ok), 2)
-    self.assertEqual(len(results.GetAllBroken()), 0)
+    self.assertEqual(len(results.GetPass()), 2)
+    self.assertEqual(len(results.GetNotPass()), 0)
 
   def testRunTestsFromQueueRetry(self):
     results = TestFunctions._RunTests(MockRunnerFail(), ['a', 'b'])
-    self.assertEqual(len(results.ok), 0)
-    self.assertEqual(len(results.failed), 2)
+    self.assertEqual(len(results.GetPass()), 0)
+    self.assertEqual(len(results.GetFail()), 2)
 
   def testRunTestsFromQueueFailTwice(self):
     results = TestFunctions._RunTests(MockRunnerFailTwice(), ['a', 'b'])
-    self.assertEqual(len(results.ok), 2)
-    self.assertEqual(len(results.GetAllBroken()), 0)
+    self.assertEqual(len(results.GetPass()), 2)
+    self.assertEqual(len(results.GetNotPass()), 0)
 
   def testSetUp(self):
     runners = []
     counter = shard._ThreadSafeCounter()
     shard._SetUp(MockRunner, '0', runners, counter)
     self.assertEqual(len(runners), 1)
     self.assertEqual(runners[0].setups, 1)
 
   def testThreadSafeCounter(self):
     counter = shard._ThreadSafeCounter()
@@ skipping 11 matching lines @@
     for runner in runners:
       self.assertEqual(runner.setups, 1)
     self.assertEqual(set([r.device for r in runners]),
                      set(['0', '1']))
     self.assertEqual(set([r.shard_index for r in runners]),
                      set([0, 1]))
 
   def testRun(self):
     runners = [MockRunner('0'), MockRunner('1')]
     results = shard._RunAllTests(runners, self.tests)
-    self.assertEqual(len(results.ok), len(self.tests))
+    self.assertEqual(len(results.GetPass()), len(self.tests))
 
   def testTearDown(self):
     runners = [MockRunner('0'), MockRunner('1')]
     shard._TearDownRunners(runners)
     for runner in runners:
       self.assertEqual(runner.teardowns, 1)
 
   def testRetry(self):
     runners = shard._CreateRunners(MockRunnerFail, ['0', '1'])
     results = shard._RunAllTests(runners, self.tests)
-    self.assertEqual(len(results.failed), len(self.tests))
+    self.assertEqual(len(results.GetFail()), len(self.tests))
 
   def testReraise(self):
     runners = shard._CreateRunners(MockRunnerException, ['0', '1'])
     with self.assertRaises(TestException):
       shard._RunAllTests(runners, self.tests)
 
 
 class TestShard(unittest.TestCase):
   """Tests for shard.Shard."""
   @staticmethod
   def _RunShard(runner_factory):
     return shard.ShardAndRunTests(runner_factory, ['0', '1'], ['a', 'b', 'c'])
 
   def testShard(self):
     results = TestShard._RunShard(MockRunner)
-    self.assertEqual(len(results.ok), 3)
+    self.assertEqual(len(results.GetPass()), 3)
 
   def testFailing(self):
     results = TestShard._RunShard(MockRunnerFail)
-    self.assertEqual(len(results.ok), 0)
-    self.assertEqual(len(results.failed), 3)
+    self.assertEqual(len(results.GetPass()), 0)
+    self.assertEqual(len(results.GetFail()), 3)
 
 
 if __name__ == '__main__':
   unittest.main()