"""
Test number of threads.
"""



import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil


class CreateDuringStepTestCase(TestBase):

    mydir = TestBase.compute_mydir(__file__)

    @expectedFailureAll(
        oslist=["linux"],
        bugnumber="llvm.org/pr15824 thread states not properly maintained")
    @expectedFailureAll(
        oslist=lldbplatformutil.getDarwinOSTriples(),
        bugnumber="llvm.org/pr15824 thread states not properly maintained, <rdar://problem/28557237>")
    @expectedFailureAll(
        oslist=["freebsd"],
        bugnumber="llvm.org/pr18190 thread states not properly maintained")
    @expectedFailureAll(
        oslist=["windows"],
        bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
    @expectedFailureNetBSD
    def test_step_inst(self):
        """Test thread creation during step-inst handling."""
        self.build()
        self.create_during_step_base(
            "thread step-inst -m all-threads",
            'stop reason = instruction step')

    @expectedFailureAll(
        oslist=["linux"],
        bugnumber="llvm.org/pr15824 thread states not properly maintained")
    @expectedFailureAll(
        oslist=lldbplatformutil.getDarwinOSTriples(),
        bugnumber="llvm.org/pr15824 thread states not properly maintained, <rdar://problem/28557237>")
    @expectedFailureAll(
        oslist=["freebsd"],
        bugnumber="llvm.org/pr18190 thread states not properly maintained")
    @expectedFailureAll(
        oslist=["windows"],
        bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
    @expectedFailureNetBSD
    def test_step_over(self):
        """Test thread creation during step-over handling."""
        self.build()
        self.create_during_step_base(
            "thread step-over -m all-threads",
            'stop reason = step over')

    @expectedFailureAll(
        oslist=["linux"],
        bugnumber="llvm.org/pr15824 thread states not properly maintained")
    @expectedFailureAll(
        oslist=lldbplatformutil.getDarwinOSTriples(),
        bugnumber="<rdar://problem/28574077>")
    @expectedFailureAll(
        oslist=["freebsd"],
        bugnumber="llvm.org/pr18190 thread states not properly maintained")
    @expectedFailureAll(
        oslist=["windows"],
        bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
    @expectedFailureNetBSD
    def test_step_in(self):
        """Test thread creation during step-in handling."""
        self.build()
        self.create_during_step_base(
            "thread step-in -m all-threads",
            'stop reason = step in')

    def setUp(self):
        # Call super's setUp().
        TestBase.setUp(self)
        # Find the line numbers to break and continue.
        self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
        self.continuepoint = line_number('main.cpp', '// Continue from here')

    def create_during_step_base(self, step_cmd, step_stop_reason):
        """Test thread creation while using step-in."""
        exe = self.getBuildArtifact("a.out")
        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

        # Get the target process
        target = self.dbg.GetSelectedTarget()

        # This should create a breakpoint in the stepping thread.
        self.bkpt = target.BreakpointCreateByLocation("main.cpp", self.breakpoint)

        # Run the program.
        self.runCmd("run", RUN_SUCCEEDED)

        process = target.GetProcess()

        # The stop reason of the thread should be breakpoint.
        stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, self.bkpt)
        self.assertTrue(stepping_thread.IsValid(), "We stopped at the right breakpoint")

        # Get the number of threads
        num_threads = process.GetNumThreads()

        # Make sure we see only two threads
        self.assertEqual(
            num_threads, 2,
            'Number of expected threads and actual threads do not match.')

        # Get the thread objects
        thread1 = process.GetThreadAtIndex(0)
        thread2 = process.GetThreadAtIndex(1)

        current_line = self.breakpoint
        # Keep stepping until we've reached our designated continue point
        while current_line != self.continuepoint:
            if stepping_thread != process.GetSelectedThread():
                process.SetSelectedThread(stepping_thread)

            self.runCmd(step_cmd)

            frame = stepping_thread.GetFrameAtIndex(0)
            current_line = frame.GetLineEntry().GetLine()

            # Make sure we're still where we thought we were
            self.assertTrue(
                current_line >= self.breakpoint,
                "Stepped to unexpected line, " +
                str(current_line))
            self.assertTrue(
                current_line <= self.continuepoint,
                "Stepped to unexpected line, " +
                str(current_line))

        # Update the number of threads
        num_threads = process.GetNumThreads()

        # Check to see that we increased the number of threads as expected
        self.assertEqual(
            num_threads, 3,
            'Number of expected threads and actual threads do not match after thread exit.')

        stop_reason = stepping_thread.GetStopReason()
        self.assertEqual(stop_reason, lldb.eStopReasonPlanComplete, "Stopped for plan completion")

        # Run to completion
        self.runCmd("process continue")

        # At this point, the inferior process should have exited.
        self.assertEqual(
            process.GetState(), lldb.eStateExited,
            PROCESS_EXITED)
