"""
Test number of threads.
"""


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


class CreateDuringStepTestCase(TestBase):
    @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.assertGreaterEqual(
                current_line,
                self.breakpoint,
                "Stepped to unexpected line, " + str(current_line),
            )
            self.assertLessEqual(
                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.assertStopReason(
            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)
