"""
Test using LLDB data formatters with frozen objects coming from the expression parser.
"""

from __future__ import print_function


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


class ExprFormattersTestCase(TestBase):

    mydir = TestBase.compute_mydir(__file__)

    def setUp(self):
        # Call super's setUp().
        TestBase.setUp(self)
        # Find the line number to break for main.cpp.
        self.line = line_number('main.cpp',
                                '// Stop here')

    @skipIfFreeBSD  # llvm.org/pr24691 skipping to avoid crashing the test runner
    @expectedFailureAll(
        oslist=['freebsd'],
        bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor')
    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
    @skipIfTargetAndroid()  # skipping to avoid crashing the test runner
    @expectedFailureAndroid('llvm.org/pr24691')  # we hit an assertion in clang
    def test(self):
        """Test expr + formatters for good interoperability."""
        self.build()

        # This is the function to remove the custom formats in order to have a
        # clean slate for the next test case.
        def cleanup():
            self.runCmd('type summary clear', check=False)
            self.runCmd('type synthetic clear', check=False)

        # Execute the cleanup function during test case tear down.
        self.addTearDownHook(cleanup)

        """Test expr + formatters for good interoperability."""
        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)

        lldbutil.run_break_set_by_file_and_line(
            self, "main.cpp", self.line, loc_exact=True)

        self.runCmd("run", RUN_SUCCEEDED)
        self.runCmd("command script import formatters.py")
        self.runCmd("command script import foosynth.py")

        if self.TraceOn():
            self.runCmd("frame variable foo1 --show-types")
            self.runCmd("frame variable foo1.b --show-types")
            self.runCmd("frame variable foo1.b.b_ref --show-types")

        self.filecheck("expression --show-types -- *(new foo(47))", __file__,
                '-check-prefix=EXPR-TYPES-NEW-FOO')
        # EXPR-TYPES-NEW-FOO: (foo) ${{.*}} = {
        # EXPR-TYPES-NEW-FOO-NEXT:   (int) a = 47
        # EXPR-TYPES-NEW-FOO-NEXT:   (int *) a_ptr = 0x
        # EXPR-TYPES-NEW-FOO-NEXT:   (bar) b = {
        # EXPR-TYPES-NEW-FOO-NEXT:     (int) i = 94
        # EXPR-TYPES-NEW-FOO-NEXT:     (int *) i_ptr = 0x
        # EXPR-TYPES-NEW-FOO-NEXT:     (baz) b = {
        # EXPR-TYPES-NEW-FOO-NEXT:       (int) h = 97
        # EXPR-TYPES-NEW-FOO-NEXT:       (int) k = 99
        # EXPR-TYPES-NEW-FOO-NEXT:     }
        # EXPR-TYPES-NEW-FOO-NEXT:     (baz &) b_ref = 0x
        # EXPR-TYPES-NEW-FOO-NEXT:   }
        # EXPR-TYPES-NEW-FOO-NEXT: }

        self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")

        self.expect("expression new int(12)",
                    substrs=['(int *) $', ' = 0x'])

        self.runCmd(
            "type summary add -s \"${var%pointer} -> ${*var%decimal}\" \"int *\"")

        self.expect("expression new int(12)",
                    substrs=['(int *) $', '= 0x', ' -> 12'])

        self.expect("expression foo1.a_ptr",
                    substrs=['(int *) $', '= 0x', ' -> 13'])

        self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1')
        # EXPR-FOO1: (foo) $
        # EXPR-FOO1-SAME: a = 12
        # EXPR-FOO1-SAME: a_ptr = {{[0-9]+}} -> 13
        # EXPR-FOO1-SAME: i = 24
        # EXPR-FOO1-SAME: i_ptr = {{[0-9]+}} -> 25
        # EXPR-FOO1-SAME: b_ref = {{[0-9]+}}
        # EXPR-FOO1-SAME: h = 27
        # EXPR-FOO1-SAME: k = 29

        self.filecheck("expression --ptr-depth=1 -- new foo(47)", __file__,
                '-check-prefix=EXPR-PTR-DEPTH1')
        # EXPR-PTR-DEPTH1: (foo *) $
        # EXPR-PTR-DEPTH1-SAME: a = 47
        # EXPR-PTR-DEPTH1-SAME: a_ptr = {{[0-9]+}} -> 48
        # EXPR-PTR-DEPTH1-SAME: i = 94
        # EXPR-PTR-DEPTH1-SAME: i_ptr = {{[0-9]+}} -> 95

        self.filecheck("expression foo2", __file__, '-check-prefix=EXPR-FOO2')
        # EXPR-FOO2: (foo) $
        # EXPR-FOO2-SAME: a = 121
        # EXPR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
        # EXPR-FOO2-SAME: i = 242
        # EXPR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
        # EXPR-FOO2-SAME: h = 245
        # EXPR-FOO2-SAME: k = 247

        object_name = self.res.GetOutput()
        object_name = object_name[7:]
        object_name = object_name[0:object_name.find(' =')]

        self.filecheck("frame variable foo2", __file__, '-check-prefix=VAR-FOO2')
        # VAR-FOO2: (foo) foo2
        # VAR-FOO2-SAME: a = 121
        # VAR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
        # VAR-FOO2-SAME: i = 242
        # VAR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
        # VAR-FOO2-SAME: h = 245
        # VAR-FOO2-SAME: k = 247

        # The object is the same as foo2, so use the EXPR-FOO2 checks.
        self.filecheck("expression $" + object_name, __file__,
                '-check-prefix=EXPR-FOO2')

        self.runCmd("type summary delete foo")
        self.runCmd(
            "type synthetic add --python-class foosynth.FooSyntheticProvider foo")

        self.expect("expression --show-types -- $" + object_name,
                    substrs=['(foo) $', ' = {', '(int) *i_ptr = 243'])

        self.runCmd("n")
        self.runCmd("n")

        self.runCmd("type synthetic delete foo")
        self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")

        self.expect(
            "expression foo2",
            substrs=[
                '(foo) $',
                'a = 7777',
                'a_ptr = ',
                ' -> 122',
                'i = 242',
                'i_ptr = ',
                ' -> 8888'])

        self.expect("expression $" + object_name + '.a',
                    substrs=['7777'])

        self.expect("expression *$" + object_name + '.b.i_ptr',
                    substrs=['8888'])

        self.expect(
            "expression $" +
            object_name,
            substrs=[
                '(foo) $',
                'a = 121',
                'a_ptr = ',
                ' -> 122',
                'i = 242',
                'i_ptr = ',
                ' -> 8888',
                'h = 245',
                'k = 247'])

        self.runCmd("type summary delete foo")
        self.runCmd(
            "type synthetic add --python-class foosynth.FooSyntheticProvider foo")

        self.expect("expression --show-types -- $" + object_name,
                    substrs=['(foo) $', ' = {', '(int) *i_ptr = 8888'])

        self.runCmd("n")

        self.runCmd("type synthetic delete foo")
        self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")

        self.expect(
            "expression $" +
            object_name,
            substrs=[
                '(foo) $',
                'a = 121',
                'a_ptr = ',
                ' -> 122',
                'i = 242',
                'i_ptr = ',
                ' -> 8888',
                'k = 247'])

        process = self.dbg.GetSelectedTarget().GetProcess()
        thread = process.GetThreadAtIndex(0)
        frame = thread.GetSelectedFrame()

        frozen = frame.EvaluateExpression("$" + object_name + ".a_ptr")

        a_data = frozen.GetPointeeData()

        error = lldb.SBError()
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                0) == 122,
            '*a_ptr = 122')

        self.runCmd("n")
        self.runCmd("n")
        self.runCmd("n")

        self.expect("frame variable numbers",
                    substrs=['1', '2', '3', '4', '5'])

        self.expect("expression numbers",
                    substrs=['1', '2', '3', '4', '5'])

        frozen = frame.EvaluateExpression("&numbers")

        a_data = frozen.GetPointeeData(0, 1)

        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                0) == 1,
            'numbers[0] == 1')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                4) == 2,
            'numbers[1] == 2')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                8) == 3,
            'numbers[2] == 3')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                12) == 4,
            'numbers[3] == 4')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                16) == 5,
            'numbers[4] == 5')

        frozen = frame.EvaluateExpression("numbers")

        a_data = frozen.GetData()

        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                0) == 1,
            'numbers[0] == 1')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                4) == 2,
            'numbers[1] == 2')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                8) == 3,
            'numbers[2] == 3')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                12) == 4,
            'numbers[3] == 4')
        self.assertTrue(
            a_data.GetUnsignedInt32(
                error,
                16) == 5,
            'numbers[4] == 5')
