# This test makes sure that lldb-server supports and properly handles
# QPassSignals GDB protocol package.
from __future__ import print_function

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

class TestGdbRemote_QPassSignals(gdbremote_testcase.GdbRemoteTestCaseBase):

    mydir = TestBase.compute_mydir(__file__)

    def expect_signal(self, expected_signo):
        self.test_sequence.add_log_lines(["read packet: $vCont;c#a8",
                                          {"direction": "send",
                                           "regex": r"^\$T([0-9a-fA-F]{2}).*#[0-9a-fA-F]{2}$",
                                           "capture": {1: "hex_exit_code"}},
                                          ],
                                         True)

        context = self.expect_gdbremote_sequence()
        self.assertIsNotNone(context)

        hex_exit_code = context.get("hex_exit_code")
        self.assertIsNotNone(hex_exit_code)
        self.assertEqual(int(hex_exit_code, 16), expected_signo)

    def expect_exit_code(self, exit_code):
        self.test_sequence.add_log_lines(
            ["read packet: $vCont;c#a8",
             "send packet: $W{0:02x}#00".format(exit_code)],
            True)
        self.expect_gdbremote_sequence()


    def ignore_signals(self, signals):
        def signal_name_to_hex(signame):
            return format(lldbutil.get_signal_number(signame), 'x')
        signals_str = ";".join(map(signal_name_to_hex, signals))

        self.test_sequence.add_log_lines(["read packet: $QPassSignals:"
                                          + signals_str + " #00",
                                          "send packet: $OK#00"],
                                         True)

        context = self.expect_gdbremote_sequence()
        self.assertIsNotNone(context)

    @llgs_test
    @skipUnlessPlatform(["linux", "android"])
    def test_q_pass_signals(self):
        self.init_llgs_test()
        self.build()
        self.set_inferior_startup_launch()
        procs = self.prep_debug_monitor_and_inferior()
        expected_signals = ["SIGSEGV",
            "SIGALRM", "SIGFPE", "SIGBUS", "SIGINT", "SIGHUP"]
        signals_to_ignore = ["SIGUSR1", "SIGUSR2"]
        self.ignore_signals(signals_to_ignore)
        for signal_name in expected_signals:
            signo = lldbutil.get_signal_number(signal_name)
            self.expect_signal(signo)
        self.expect_exit_code(len(signals_to_ignore))

    @llgs_test
    @skipUnlessPlatform(["linux", "android"])
    def test_change_signals_at_runtime(self):
        self.init_llgs_test()
        self.build()
        self.set_inferior_startup_launch()
        procs = self.prep_debug_monitor_and_inferior()
        expected_signals = ["SIGSEGV", "SIGUSR1", "SIGUSR2",
            "SIGALRM", "SIGHUP"]
        signals_to_ignore = ["SIGFPE", "SIGBUS", "SIGINT"]

        for signal_name in expected_signals:
            signo = lldbutil.get_signal_number(signal_name)
            self.expect_signal(signo)
            if signal_name == "SIGALRM":
                self.ignore_signals(signals_to_ignore)
        self.expect_exit_code(len(signals_to_ignore))

    @llgs_test
    def test_default_signals_behavior(self):
        self.init_llgs_test()
        self.build()
        self.set_inferior_startup_launch()
        procs = self.prep_debug_monitor_and_inferior()
        expected_signals = ["SIGSEGV", "SIGUSR1", "SIGUSR2",
            "SIGALRM", "SIGFPE", "SIGBUS", "SIGINT", "SIGHUP"]
        for signal_name in expected_signals:
            signo = lldbutil.get_signal_number(signal_name)
            self.expect_signal(signo)
        self.expect_exit_code(0)


    @llgs_test
    @skipUnlessPlatform(["linux", "android"])
    def test_support_q_pass_signals(self):
        self.init_llgs_test()
        self.build()

        # Start up the stub and start/prep the inferior.
        self.set_inferior_startup_launch()
        procs = self.prep_debug_monitor_and_inferior()
        self.add_qSupported_packets()

        # Run the packet stream.
        context = self.expect_gdbremote_sequence()
        self.assertIsNotNone(context)

        # Retrieve the qSupported features and check QPassSignals+
        supported_dict = self.parse_qSupported_response(context)
        self.assertEqual(supported_dict["QPassSignals"], "+")