"""
Test that the run locker really does work to keep
us from running SB API that should only be run
while stopped.  This test is mostly concerned with
what happens between launch and first stop.
"""

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


class TestRunLocker(TestBase):
    NO_DEBUG_INFO_TESTCASE = True

    def setUp(self):
        # Call super's setUp().
        TestBase.setUp(self)
        self.main_source_file = lldb.SBFileSpec("main.c")

    @expectedFailureAll(oslist=["windows"])
    def test_run_locker(self):
        """Test that the run locker is set correctly as we're running"""
        self.build()
        target = lldbutil.run_to_breakpoint_make_target(self)
        launch_info = target.GetLaunchInfo()

        error = lldb.SBError()
        # We are trying to do things when the process is running, so
        # we have to run the debugger asynchronously.
        self.dbg.SetAsync(True)

        main_bp = target.BreakpointCreateByName("main")

        listener = lldb.SBListener("test-run-lock-listener")
        launch_info.SetListener(listener)
        process = target.Launch(launch_info, error)
        self.assertSuccess(error, "Launched the process")

        event = lldb.SBEvent()

        event_result = listener.WaitForEvent(10, event)
        self.assertTrue(event_result, "timed out waiting for launch")
        state_type = lldb.SBProcess.GetStateFromEvent(event)
        # We don't always see a launching...
        if state_type == lldb.eStateLaunching:
            event_result = listener.WaitForEvent(10, event)
            self.assertTrue(
                event_result, "Timed out waiting for running after launching"
            )
            state_type = lldb.SBProcess.GetStateFromEvent(event)

        # We may be in eStateStopped if we hit the breakpoint already.
        if state_type != lldb.eStateStopped:
            self.assertState(
                state_type, lldb.eStateRunning, "Didn't get a running event"
            )
            event_result = listener.WaitForEvent(10, event)
            self.assertTrue(event_result, "timed out waiting for breakpoint stop")
            state_type = lldb.SBProcess.GetStateFromEvent(event)

        self.assertState(state_type, lldb.eStateStopped, "Stop at main stopped")
        main_bp.SetEnabled(False)
        process.Continue()

        event_result = listener.WaitForEvent(10, event)
        self.assertTrue(event_result, "timed out waiting for process resume")
        state_type = lldb.SBProcess.GetStateFromEvent(event)

        self.assertState(state_type, lldb.eStateRunning, "Continue after main() bp")

        # Okay, now the process is running, make sure we can't do things
        # you aren't supposed to do while running, and that we get some
        # actual error:
        val = target.EvaluateExpression("SomethingToCall()")
        # There was a bug [#93313] in the printing that would cause repr to crash, so I'm
        # testing that separately.
        self.assertIn(
            "can't evaluate expressions when the process is running",
            repr(val),
            "repr works",
        )
        error = val.GetError()
        self.assertTrue(error.Fail(), "Failed to run expression")
        self.assertIn(
            "can't evaluate expressions when the process is running",
            error.GetCString(),
            "Stopped by stop locker",
        )

        # This should also fail if we try to use the script interpreter directly:
        interp = self.dbg.GetCommandInterpreter()
        result = lldb.SBCommandReturnObject()
        ret = interp.HandleCommand(
            "script var = lldb.target.EvaluateExpression('SomethingToCall()'); var.GetError().GetCString()",
            result,
        )
        self.assertIn(
            "can't evaluate expressions when the process is running", result.GetOutput()
        )