lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoBreakpointsOneSignal.py


import unittest2

from lldbsuite.test.decorators import *
from lldbsuite.test.concurrent_base import ConcurrentEventsBase
from lldbsuite.test.lldbtest import TestBase


@skipIfWindows
class ConcurrentTwoBreakpointsOneSignal(ConcurrentEventsBase):

    mydir = ConcurrentEventsBase.compute_mydir(__file__)

    # Atomic sequences are not supported yet for MIPS in LLDB.
    @skipIf(triple='^mips')
    @expectedFlakeyNetBSD
    @expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],
                        bugnumber="llvm.org/pr49433")
    def test(self):
        """Test two threads that trigger a breakpoint and one signal thread. """
        self.build()
        self.do_thread_actions(num_breakpoint_threads=2, num_signal_threads=1)
Breakup TestConcurrentEvents.py into separate test subdirs per test method This change breaks up the monolithic TestConcurrentEvents.py into a separate subdir per test method. This allows them to run concurrently, reduces the chance of a timeout occurring during normal operation, and allows us to home in on any test methods that may be locking up. This is step one in the process of squashing timeouts in these test methods. The reason for breaking each test method into its own file is to make it very clear to us if there are a subset of the tests that do in fact lock up frequently. This will limit how much hunting we need to do to recreate it. The reason for putting each file in a separate subdirectory is so that our concurrent test runner can run multiple test files at the same time. The unit of serialization in the LLDB test suite is the test directory, so moving them into separate directories enables the test runner to do more at the same time. This change introduces usage of VPATH from gnu make. I use that to facilitate keeping a single copy of the main.cpp in the parent concurrent_events directory. Initially I had tried specifying the source file as ../main.cpp, but our current makefile rules get confused by that and then also build the output into the parent directory, which defeats the ability to run each of the test methods concurrently. In the event that not all systems support VPATH, I can do a bit of surgery on the Makefile rules and attempt to make it smarter with regards to relative paths to source files used in the build. llvm-svn: 276478 2016-07-22 21:50:55 +00:00
			`import unittest2`

			`from lldbsuite.test.decorators import *`
			`from lldbsuite.test.concurrent_base import ConcurrentEventsBase`
			`from lldbsuite.test.lldbtest import TestBase`


			`@skipIfWindows`
			`class ConcurrentTwoBreakpointsOneSignal(ConcurrentEventsBase):`

			`mydir = ConcurrentEventsBase.compute_mydir(__file__)`

			`# Atomic sequences are not supported yet for MIPS in LLDB.`
[LLDB][MIPS] Skip some test case which were causing LLDB to go into infinite loop Reviewers: clayborg, labath Subscribers: jaydeep, bhushan, slthakur, llvm-commits Differential Revision: https://reviews.llvm.org/D24549 llvm-svn: 283732 2016-10-10 10:02:09 +00:00			`@skipIf(triple='^mips')`
[lldb] [test] Update test status for NetBSD 2020-12-20 11:32:19 +01:00			`@expectedFlakeyNetBSD`
[lldb] [test] Update XFAILs for FreeBSD/aarch64 2021-03-03 15:57:51 +01:00			`@expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],`
			`bugnumber="llvm.org/pr49433")`
Use shorter names in TestConcurrentEvents tests Otherwise, they tend to generate filename too long errors. They already contain the same test name in the directory, file, and class names, so no information is really lost here. llvm-svn: 284987 2016-10-24 16:20:43 +00:00			`def test(self):`
Breakup TestConcurrentEvents.py into separate test subdirs per test method This change breaks up the monolithic TestConcurrentEvents.py into a separate subdir per test method. This allows them to run concurrently, reduces the chance of a timeout occurring during normal operation, and allows us to home in on any test methods that may be locking up. This is step one in the process of squashing timeouts in these test methods. The reason for breaking each test method into its own file is to make it very clear to us if there are a subset of the tests that do in fact lock up frequently. This will limit how much hunting we need to do to recreate it. The reason for putting each file in a separate subdirectory is so that our concurrent test runner can run multiple test files at the same time. The unit of serialization in the LLDB test suite is the test directory, so moving them into separate directories enables the test runner to do more at the same time. This change introduces usage of VPATH from gnu make. I use that to facilitate keeping a single copy of the main.cpp in the parent concurrent_events directory. Initially I had tried specifying the source file as ../main.cpp, but our current makefile rules get confused by that and then also build the output into the parent directory, which defeats the ability to run each of the test methods concurrently. In the event that not all systems support VPATH, I can do a bit of surgery on the Makefile rules and attempt to make it smarter with regards to relative paths to source files used in the build. llvm-svn: 276478 2016-07-22 21:50:55 +00:00			`"""Test two threads that trigger a breakpoint and one signal thread. """`
[lldb] Remove lldbtest.getBuildFlags It was being used only in some very old tests (which pass even without it) and its implementation is highly questionable. These days we have different mechanisms for requesting a build with a particular kind of c++ library (USE_LIB(STD)CPP in the makefile). 2021-12-30 11:22:26 +01:00			`self.build()`
Breakup TestConcurrentEvents.py into separate test subdirs per test method This change breaks up the monolithic TestConcurrentEvents.py into a separate subdir per test method. This allows them to run concurrently, reduces the chance of a timeout occurring during normal operation, and allows us to home in on any test methods that may be locking up. This is step one in the process of squashing timeouts in these test methods. The reason for breaking each test method into its own file is to make it very clear to us if there are a subset of the tests that do in fact lock up frequently. This will limit how much hunting we need to do to recreate it. The reason for putting each file in a separate subdirectory is so that our concurrent test runner can run multiple test files at the same time. The unit of serialization in the LLDB test suite is the test directory, so moving them into separate directories enables the test runner to do more at the same time. This change introduces usage of VPATH from gnu make. I use that to facilitate keeping a single copy of the main.cpp in the parent concurrent_events directory. Initially I had tried specifying the source file as ../main.cpp, but our current makefile rules get confused by that and then also build the output into the parent directory, which defeats the ability to run each of the test methods concurrently. In the event that not all systems support VPATH, I can do a bit of surgery on the Makefile rules and attempt to make it smarter with regards to relative paths to source files used in the build. llvm-svn: 276478 2016-07-22 21:50:55 +00:00			`self.do_thread_actions(num_breakpoint_threads=2, num_signal_threads=1)`