Remove serial test support from test-webkitpy.

Tools/Scripts/webkitpy/test/main_unittest.py

 # Copyright (C) 2012 Google, Inc.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 1.  Redistributions of source code must retain the above copyright
 #     notice, this list of conditions and the following disclaimer.
 # 2.  Redistributions in binary form must reproduce the above copyright
 #     notice, this list of conditions and the following disclaimer in the
 #     documentation and/or other materials provided with the distribution.
@@ skipping 23 matching lines @@
 STUBS_CLASS = __name__ + ".TestStubs"
 
 
 class TestStubs(unittest.TestCase):
     def test_empty(self):
         pass
 
     def integration_test_empty(self):
         pass
 
-    def serial_test_empty(self):
-        pass
-
-    def serial_integration_test_empty(self):
-        pass
-
 
 class TesterTest(unittest.TestCase):
 
     def test_no_tests_found(self):
         tester = Tester()
         errors = StringIO.StringIO()
 
         # Here we need to remove any existing log handlers so that they
         # don't log the messages webkitpy.test while we're testing it.
         root_logger = logging.getLogger()
@@ skipping 16 matching lines @@
         self.assertIn('No tests to run', errors.getvalue())
         self.assertIn('No tests to run', logs)
 
     def _find_test_names(self, args):
         tester = Tester()
         tester._options, args = tester._parse_args(args)
         return tester._test_names(_Loader(), args)
 
     def test_individual_names_are_not_run_twice(self):
         args = [STUBS_CLASS + '.test_empty']
-        parallel_tests, serial_tests = self._find_test_names(args)
-        self.assertEqual(parallel_tests, args)
-        self.assertEqual(serial_tests, [])
+        tests = self._find_test_names(args)
+        self.assertEqual(tests, args)
 
     def test_integration_tests_are_not_found_by_default(self):
-        parallel_tests, serial_tests = self._find_test_names([STUBS_CLASS])
-        self.assertEqual(parallel_tests, [
-            STUBS_CLASS + '.test_empty',
-            ])
-        self.assertEqual(serial_tests, [
-            STUBS_CLASS + '.serial_test_empty',
-            ])
+        tests = self._find_test_names([STUBS_CLASS])
+        self.assertEqual(tests, [STUBS_CLASS + '.test_empty'])
 
     def test_integration_tests_are_found(self):
-        parallel_tests, serial_tests = self._find_test_names(['--integration-tests', STUBS_CLASS])
-        self.assertEqual(parallel_tests, [
+        tests = self._find_test_names(['--integration-tests', STUBS_CLASS])
+        self.assertEqual(tests, [
             STUBS_CLASS + '.integration_test_empty',
             STUBS_CLASS + '.test_empty',
             ])
-        self.assertEqual(serial_tests, [
-            STUBS_CLASS + '.serial_integration_test_empty',
-            STUBS_CLASS + '.serial_test_empty',
-            ])
 
     def test_coverage_works(self):
         # This is awkward; by design, running test-webkitpy -c will
         # create a .coverage file in Tools/Scripts, so we need to be
         # careful not to clobber an existing one, and to clean up.
         # FIXME: This design needs to change since it means we can't actually
         # run this method itself under coverage properly.
         filesystem = FileSystem()
         executive = Executive()
         module_path = filesystem.path_to_module(self.__module__)
         script_dir = module_path[0:module_path.find('webkitpy') - 1]
         coverage_file = filesystem.join(script_dir, '.coverage')
         coverage_file_orig = None
         if filesystem.exists(coverage_file):
             coverage_file_orig = coverage_file + '.orig'
             filesystem.move(coverage_file, coverage_file_orig)
 
         try:
             proc = executive.popen([sys.executable, filesystem.join(script_dir, 'test-webkitpy'), '-c', STUBS_CLASS + '.test_empty'],
                                 stdout=executive.PIPE, stderr=executive.PIPE)
             out, _ = proc.communicate()
             retcode = proc.returncode
             self.assertEqual(retcode, 0)
             self.assertIn('Cover', out)
         finally:
             if coverage_file_orig:
                 filesystem.move(coverage_file_orig, coverage_file)
             elif filesystem.exists(coverage_file):
                 filesystem.remove(coverage_file)