Android gtest runner: Use first test list result rather than merging

build/android/pylib/local/device/local_device_gtest_run.py

 # Copyright 2014 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.
 
 import itertools
 import os
 import posixpath
 
 from devil.android import device_errors
 from devil.android import device_temp_file
@@ skipping 211 matching lines @@
   #override
   def _GetTests(self):
     @local_device_test_run.handle_shard_failures
     def list_tests(dev):
       tests = self._delegate.Run(
           None, dev, flags='--gtest_list_tests', timeout=10)
       tests = gtest_test_instance.ParseGTestListTests(tests)
       tests = self._test_instance.FilterTests(tests)
       return tests
 
-    test_lists = self._env.parallel_devices.pMap(list_tests).pGet(None)
-    tests = list(sorted(set().union(*[set(tl) for tl in test_lists if tl])))
-    return tests
+    # Result should be the same for all devices, so just use the first one.
+    return list_tests(self._env.devices[0])

[jbudorick, 2015/10/08 14:35:41]

The problem with this is handling the case where listing the test fails on one
device.

[agrieve, 2015/10/08 15:49:29]

Wondered if that was it.

Okay if I change this to add such a comment and just use the first non-None
result? (and add back in sorting)

[jbudorick, 2015/10/08 15:52:45]

Definitely add a comment, and I think that using the first non-None result
should be ok. I debated between that and the current implementation when I wrote
this not that long ago, and I do think the results should be the same on
successful execution.

 
   #override
   def _RunTest(self, device, test):
     # Run the test.
     timeout = (self._test_instance.shard_timeout
                * self.GetTool(device).GetTimeoutScale())
     output = self._delegate.Run(
         test, device, timeout=timeout, retries=0)
     for s in self._servers[str(device)]:
       s.Reset()
     if self._test_instance.app_files:
       self._delegate.PullAppFiles(device, self._test_instance.app_files,
                                   self._test_instance.app_file_dir)
     self._delegate.Clear(device)
 
     # Parse the output.
     # TODO(jbudorick): Transition test scripts away from parsing stdout.
     results = self._test_instance.ParseGTestOutput(output)
     return results
 
   #override
   def TearDown(self):
     @local_device_test_run.handle_shard_failures
     def individual_device_tear_down(dev):
       for s in self._servers.get(str(dev), []):
         s.TearDown()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)