[lldb] Restructure test folders to match LLDB command hierarchy

Summary:
As discussed on lldb-dev, this patch moves some LLDB tests into a hierarchy that more closely
resembles the commands we use in the LLDB interpreter. This patch should only move tests
that use the command interpreter and shouldn't touch any tests that primarily test the SB API.

Reviewers: #lldb, jfb, JDevlieghere

Reviewed By: #lldb, JDevlieghere

Subscribers: dexonsmith, arphaman, JDevlieghere, lldb-commits

Tags: #lldb

Differential Revision: https://reviews.llvm.org/D67033

llvm-svn: 370605

5 files changed, 390 insertions, 0 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/Makefile b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/Makefile
new file mode 100644
index 00000000000..8a7102e347a
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/TestFormatters.py b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/TestFormatters.py
new file mode 100644
index 00000000000..b13d6555f33
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/TestFormatters.py
@@ -0,0 +1,287 @@
+"""
+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
+    @expectedFailureNetBSD
+    @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')
diff --git a/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/foosynth.py b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/foosynth.py
new file mode 100644
index 00000000000..7b1284d2a76
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/foosynth.py
@@ -0,0 +1,33 @@
+import lldb
+
+
+class FooSyntheticProvider:
+
+    def __init__(self, valobj, dict):
+        self.valobj = valobj
+        self.update()
+
+    def update(self):
+        self.adjust_for_architecture()
+
+    def num_children(self):
+        return 1
+
+    def get_child_at_index(self, index):
+        if index != 0:
+            return None
+        return self.i_ptr.Dereference()
+
+    def get_child_index(self, name):
+        if name == "*i_ptr":
+            return 0
+        return None
+
+    def adjust_for_architecture(self):
+        self.lp64 = (
+            self.valobj.GetTarget().GetProcess().GetAddressByteSize() == 8)
+        self.is_little = (self.valobj.GetTarget().GetProcess(
+        ).GetByteOrder() == lldb.eByteOrderLittle)
+        self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+        self.bar = self.valobj.GetChildMemberWithName('b')
+        self.i_ptr = self.bar.GetChildMemberWithName('i_ptr')
diff --git a/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/formatters.py b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/formatters.py
new file mode 100644
index 00000000000..dae84988af9
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/formatters.py
@@ -0,0 +1,17 @@
+def foo_SummaryProvider(valobj, dict):
+    a = valobj.GetChildMemberWithName('a')
+    a_ptr = valobj.GetChildMemberWithName('a_ptr')
+    bar = valobj.GetChildMemberWithName('b')
+    i = bar.GetChildMemberWithName('i')
+    i_ptr = bar.GetChildMemberWithName('i_ptr')
+    b_ref = bar.GetChildMemberWithName('b_ref')
+    b_ref_ptr = b_ref.AddressOf()
+    b_ref = b_ref_ptr.Dereference()
+    h = b_ref.GetChildMemberWithName('h')
+    k = b_ref.GetChildMemberWithName('k')
+    return 'a = ' + str(a.GetValueAsUnsigned(0)) + ', a_ptr = ' + \
+        str(a_ptr.GetValueAsUnsigned(0)) + ' -> ' + str(a_ptr.Dereference().GetValueAsUnsigned(0)) + \
+        ', i = ' + str(i.GetValueAsUnsigned(0)) + \
+        ', i_ptr = ' + str(i_ptr.GetValueAsUnsigned(0)) + ' -> ' + str(i_ptr.Dereference().GetValueAsUnsigned(0)) + \
+        ', b_ref = ' + str(b_ref.GetValueAsUnsigned(0)) + \
+        ', h = ' + str(h.GetValueAsUnsigned(0)) + ' , k = ' + str(k.GetValueAsUnsigned(0))
diff --git a/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/main.cpp b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/main.cpp
new file mode 100644
index 00000000000..1b8ce48041f
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/commands/expression/formatters/main.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <string>
+
+struct baz
+    {
+        int h;
+        int k;
+        baz(int a, int b) : h(a), k(b) {}
+    };
+
+struct bar
+	{
+		int i;
+		int* i_ptr;
+        baz b;
+        baz& b_ref;
+		bar(int x) : i(x),i_ptr(new int(x+1)),b(i+3,i+5),b_ref(b) {}
+	};
+	
+struct foo
+	{
+		int a;
+		int* a_ptr;
+		bar b;
+		
+		foo(int x) : a(x),
+		a_ptr(new int(x+1)),
+		b(2*x) {}
+		
+	};
+	
+int main(int argc, char** argv)
+{
+	foo foo1(12);
+	foo foo2(121);
+	
+	foo2.a = 7777; // Stop here
+	*(foo2.b.i_ptr) = 8888;
+    foo2.b.b.h = 9999;
+	
+	*(foo1.a_ptr) = 9999;
+	foo1.b.i = 9999;
+	
+	int numbers[5] = {1,2,3,4,5};
+	
+	return 0;
+	
+}