Remove TestMyFirstWatchpoint and TestStepOverWatchpoint from basic_process category

[labath]

Summary

Does anyone care about these tests being in the basic_process category?
The getCategories function is interfering with the filesystem-based
watchpoint category kicking in. If there's any interest in keeping it,
then I can certainly make it happen. However, I haven't seen anyone
using these, so I'm thinking, if that's the case, why bother?

[clayborg]

No objections from me as I don't use these categories.

[jingham]

Setting categories on directories seems much less useful if you then have to scan through all the tests and see if any of the tests in the directories you've added categories to implement getCategories then add the new category to the return from getCategories list as well.

So it seems to me either getCategories should add to the directory category list that's already been computed, or we should remove it altogether.

There are only a few other tests that implement getCategories (all to set it to basic_process). So it does look like this is more degrees of freedom than we actually need. Maybe we should just remove it altogether? I don't feel too strongly, but if we're going to remove it from these tests we should probably remove it everywhere or we'll make somebody else have to figure this out again down the line.

[labath]

I agree that we have too many ways of specifying categories. I think that the file-based and getCategories() way are redundant, particularly, as we tend to only have one test file per directory anyway. For very fine grained annotations, we can use the @add_test_categories decorator (which is already cumulative). I'll put up a patch to remove getCategories().

[labath]

This removes the getCategories function altogether. I've moved the
filesystem-based category computation (which was implemented as a getCategories
base case) into the consumer, so that it is impossible to override. I've
converted the existing getCategories usages to either @add_test_categories (if
they affected a single test) or to .categories.

[jingham]

Very nice, thanks!

lldb/trunk/packages/Python/lldbsuite/test/example/TestSequenceFunctions.py

def test_choice(self):
         element = random.choice(self.seq)
         self.assertTrue(element in self.seq)
 
     def test_sample(self):
         self.assertRaises(ValueError, random.sample, self.seq, 20)
         for element in random.sample(self.seq, 5):
             self.assertTrue(element in self.seq)
 
-    def getCategories(self):
-        return []
-
 if __name__ == '__main__':
     unittest.main()

lldb/trunk/packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ExprDoesntDeadlockTestCase(TestBase):
 
-    def getCategories(self):
-        return ['basic_process']
-
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17946')
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="Windows doesn't have pthreads, test needs to be ported")
+    @add_test_categories(["basic_process"])
     def test_with_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/load_unload/.categories

+basic_process

lldb/trunk/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
 class LoadUnloadTestCase(TestBase):
 
-    def getCategories(self):
-        return ['basic_process']
-
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number(
             'main.cpp',

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/step_until/.categories

+basic_process

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/step_until/TestStepUntil.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def getCategories(self):
-        return ['basic_process']
-
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
         self.less_than_two = line_number('main.c', 'Less than 2')
         self.greater_than_two = line_number('main.c', 'Greater than or equal to 2.')
         self.back_out_in_main = line_number('main.c', 'Back out in main')

lldb/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class HelloWatchpointTestCase(TestBase):
 
-    def getCategories(self):
-        return ['basic_process']
-
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source,
                                 '// Watchpoint variable declaration.')
         self.exe_name = 'a.out'
         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @add_test_categories(["basic_process"])
     def test_hello_watchpoint_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

 """Test stepping over watchpoints."""
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStepOverWatchpoint(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def getCategories(self):
-        return ['basic_process']
-
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             'aarch64',
             'arm'],
         bugnumber="llvm.org/pr26031")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     @expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34027183>")  # watchpoint tests aren't working on arm64
+    @add_test_categories(["basic_process"])
     def test(self):
         """Test stepping over watchpoints."""
         self.build()
         exe = os.path.join(os.getcwd(), 'a.out')
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 

lldb/trunk/packages/Python/lldbsuite/test/lang/c/step-target/.categories

+basic_process

lldb/trunk/packages/Python/lldbsuite/test/lang/c/step-target/TestStepTarget.py

 """Test the 'step target' feature."""
 
 from __future__ import print_function
 
 import os
 import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStepTarget(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def getCategories(self):
-        return ['basic_process']
-
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
         self.end_line = line_number(self.main_source, "All done")
 
     @add_test_categories(['pyapi'])

lldb/trunk/packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def getCategories(self):
-        return ['basic_process']
-
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
-    @add_test_categories(['pyapi'])
+    @add_test_categories(['pyapi', 'basic_process'])
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932')
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
     def test_and_python_api(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 

lldb/trunk/packages/Python/lldbsuite/test/lang/objc/objc-stepping/TestObjCStepping.py

 """Test stepping through ObjC method dispatch in various forms."""
 
 from __future__ import print_function
 
 
 import os
 import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestObjCStepping(TestBase):
 
-    def getCategories(self):
-        return ['basic_process']
-
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "stepping-tests.m"
         self.source_randomMethod_line = line_number(
             self.main_source, '// Source randomMethod start line.')
         self.sourceBase_randomMethod_line = line_number(
             self.main_source, '// SourceBase randomMethod start line.')
         self.source_returnsStruct_start_line = line_number(
             self.main_source, '// Source returnsStruct start line.')
         self.sourceBase_returnsStruct_start_line = line_number(
             self.main_source, '// SourceBase returnsStruct start line.')
         self.stepped_past_nil_line = line_number(
             self.main_source, '// Step over nil should stop here.')
 
     @skipUnlessDarwin
-    @add_test_categories(['pyapi'])
+    @add_test_categories(['pyapi', 'basic_process'])
     def test_with_python_api(self):
         """Test stepping through ObjC method dispatch in various forms."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

class TestBase(Base):
     # Maximum allowed attempts when launching the inferior process.
     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
     maxLaunchCount = 3
 
     # Time to wait before the next launching attempt in second(s).
     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
     timeWaitNextLaunch = 1.0
 
-    # Returns the list of categories to which this test case belongs
-    # by default, look for a ".categories" file, and read its contents
-    # if no such file exists, traverse the hierarchy - we guarantee
-    # a .categories to exist at the top level directory so we do not end up
-    # looping endlessly - subclasses are free to define their own categories
-    # in whatever way makes sense to them
-    def getCategories(self):
-        import inspect
-        import os.path
-        folder = inspect.getfile(self.__class__)
-        folder = os.path.dirname(folder)
-        while folder != '/':
-            categories_file_name = os.path.join(folder, ".categories")
-            if os.path.exists(categories_file_name):
-                categories_file = open(categories_file_name, 'r')
-                categories = categories_file.readline()
-                categories_file.close()
-                categories = str.replace(categories, '\n', '')
-                categories = str.replace(categories, '\r', '')
-                return categories.split(',')
-            else:
-                folder = os.path.dirname(folder)
-                continue
-
     def generateSource(self, source):
         template = source + '.template'
         temp = os.path.join(os.getcwd(), template)
         with open(temp, 'r') as f:
             content = f.read()
             
         public_api_dir = os.path.join(
             os.environ["LLDB_SRC"], "include", "lldb", "API")

lldb/trunk/packages/Python/lldbsuite/test/test_result.py

class LLDBTestResult(unittest2.TextTestResult):
 
     def getDescription(self, test):
         doc_first_line = test.shortDescription()
         if self.descriptions and doc_first_line:
             return '\n'.join((str(test), self.indentation + doc_first_line))
         else:
             return str(test)
 
+    @staticmethod
+    def _getFileBasedCategories(test):
+        """
+        Returns the list of categories to which this test case belongs by
+        looking for a ".categories" file. We start at the folder the test is in
+        an traverse the hierarchy upwards - we guarantee a .categories to exist
+        at the top level directory so we do not end up looping endlessly.
+        """
+        import inspect
+        import os.path
+        folder = inspect.getfile(test.__class__)
+        folder = os.path.dirname(folder)
+        while folder != '/':
+            categories_file_name = os.path.join(folder, ".categories")
+            if os.path.exists(categories_file_name):
+                categories_file = open(categories_file_name, 'r')
+                categories = categories_file.readline()
+                categories_file.close()
+                categories = str.replace(categories, '\n', '')
+                categories = str.replace(categories, '\r', '')
+                return categories.split(',')
+            else:
+                folder = os.path.dirname(folder)
+                continue
+
+
     def getCategoriesForTest(self, test):
         """
         Gets all the categories for the currently running test method in test case
         """
         test_categories = []
         test_method = getattr(test, test._testMethodName)
         if test_method is not None and hasattr(test_method, "categories"):
             test_categories.extend(test_method.categories)
 
-        test_categories.extend(test.getCategories())
+        test_categories.extend(self._getFileBasedCategories(test))
 
         return test_categories
 
     def hardMarkAsSkipped(self, test):
         getattr(test, test._testMethodName).__func__.__unittest_skip__ = True
         getattr(
             test,
             test._testMethodName).__func__.__unittest_skip_why__ = "test case does not fall in any category of interest for this run"

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/.categories

+lldb-mi

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/lldbmi_testcase.py

 """
 Base class for lldb-mi test cases.
 """
 
 from __future__ import print_function
 
 
 from lldbsuite.test.lldbtest import *
 
 
 class MiTestCaseBase(Base):
 
     mydir = None
     myexe = "a.out"
     mylog = "child.log"
 
-    def getCategories(self):
-        return ['lldb-mi']
-
     @classmethod
     def classCleanup(cls):
         TestBase.RemoveTempFile(cls.myexe)
         TestBase.RemoveTempFile(cls.mylog)
 
     def setUp(self):
         Base.setUp(self)
         self.buildDefault()