[lldb] Add expect_var_path to test variable path results

[teemperor]

Summary

This adds expect_var_path to test variable paths so we no longer have to
use frame var and find substrs in the command output. The behaviour
is identical with expect_expr (and it also uses the same checking backend),
but it instead calls GetValueForVariablePath to evaluate the string as a variable
path.

Also rewrites a few of the tests that previously used frame variable to use
expect_var_path.

[labath]

Looks good to me. I was looking to find the SB equivalent of the "target variable" command (so we can use this without a running process, just like expect_expr), but I didn't find one. It would be good to add one some day...

lldb/packages/Python/lldbsuite/test/lldbtest.py

2595

Maybe it would be enough to call this expect_var ?

2598–2601

I'm wondering if the result_ prefixes are really needed. They would make the usage shorter, and it seems like the statements would flow just fine without it (expect_var[_path]("my_var", summary="..."))...

2613

assertEqual (and maybe drop the error message)

[teemperor]

lldb/packages/Python/lldbsuite/test/lldbtest.py

2595

expect_var sounds more like a function that can only check a plain variable (and IIRC we had some plans to have a dedicated function for this use case that uses both expr/frame var to access one variable). We could maybe do something like expect_frame_var to make the name more similar to what people know from the command line?

2598–2601

I think the original reason why the expect_expr had the result_ prefixes was that the variable names we use (or maybe will use for other Type/Value properties) in that function are easily colliding with builtin Python stuff (like, type technically works as an argument name but it shadows Python's builtin type function).

But we're anyway already using type in ValueCheck and it's really easier on the eyes, so I'll remove the prefixes.

[labath]

lldb/packages/Python/lldbsuite/test/lldbtest.py

2595

expect_var_path sounds about equally good/bad as expect_frame_var to me. I can see how expect_var may be a bit cryptic, though OTOH, these days we have "v" as an alias to "frame var"..

I don't have strong opinions either way...

[teemperor]

• Addressed feedback

lldb/packages/Python/lldbsuite/test/lldbtest.py

def expect_expr(
                 target = self.dbg.GetDummyTarget()
             eval_result = target.EvaluateExpression(expr, options)
 
         value_check = ValueCheck(type=result_type, value=result_value,
                                  summary=result_summary, children=result_children)
         value_check.check_value(self, eval_result, str(eval_result))
         return eval_result
 
+    def expect_var_path(
+            self,
+            var_path,
+            summary=None,
+            value=None,
+            type=None,
+            children=None
+            ):
+        """
+        Evaluates the given variable path and verifies the result.
+        See also 'frame variable' and SBFrame.GetValueForVariablePath.
+        :param var_path: The variable path as a string.
+        :param summary: The summary that the variable should have. None if the summary should not be checked.
+        :param value: The value that the variable should have. None if the value should not be checked.
+        :param type: The type that the variable result should have. None if the type should not be checked.
+        :param children: The expected children of the variable  as a list of ValueChecks.
+                         None if the children shouldn't be checked.
+        """
+        self.assertTrue(var_path.strip() == var_path,
+                        "Expression contains trailing/leading whitespace: '" + var_path + "'")
+
+        frame = self.frame()
+        eval_result = frame.GetValueForVariablePath(var_path)
+
+        value_check = ValueCheck(type=type, value=value,
+                                 summary=summary, children=children)
+        value_check.check_value(self, eval_result, str(eval_result))
+        return eval_result
+
     def invoke(self, obj, name, trace=False):
         """Use reflection to call a method dynamically with no argument."""
         trace = (True if traceAlways else trace)
 
         method = getattr(obj, name)
         import inspect
         self.assertTrue(inspect.ismethod(method),
                         name + "is a method name of object: " + str(obj))

lldb/test/API/commands/process/launch-with-shellexpand/TestLaunchWithShellExpand.py

def test(self):
                         "Process stopped at 'main' should have a valid thread")
 
         stop_reason = thread.GetStopReason()
 
         self.assertTrue(
             stop_reason == lldb.eStopReasonBreakpoint,
             "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
 
-        self.expect("frame variable argv[1]", substrs=['file1.txt'])
-        self.expect("frame variable argv[2]", substrs=['file2.txt'])
-        self.expect("frame variable argv[3]", substrs=['file3.txt'])
-        self.expect("frame variable argv[4]", substrs=['file4.txy'])
-        self.expect("frame variable argv[5]", substrs=['()'])
-        self.expect("frame variable argv[6]", substrs=['>'])
-        self.expect("frame variable argv[7]", substrs=['<'])
-        self.expect(
-            "frame variable argv[5]",
-            substrs=['file5.tyx'],
-            matching=False)
-        self.expect(
-            "frame variable argv[8]",
-            substrs=['file5.tyx'],
-            matching=False)
+        self.expect_var_path("argv[1]", summary='"file1.txt"')
+        self.expect_var_path("argv[2]", summary='"file2.txt"')
+        self.expect_var_path("argv[3]", summary='"file3.txt"')
+        self.expect_var_path("argv[4]", summary='"file4.txy"')
+        self.expect_var_path("argv[5]", summary='"()"')
+        self.expect_var_path("argv[6]", summary='">"')
+        self.expect_var_path("argv[7]", summary='"<"')
+        self.expect_var_path("argc", value='8')
 
         self.runCmd("process kill")
 
         self.runCmd(
             'process launch -X true -w %s -- "foo bar"' %
             (self.getSourceDir()))
 
         process = self.process()

lldb/test/API/functionalities/archives/TestBSDArchives.py

def test(self):
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Break at a(int) first.
         self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(int) arg = 1'])
-        self.expect("frame variable __a_global", VARIABLES_DISPLAYED_CORRECTLY,
-                    substrs=['(int) __a_global = 1'])
+        self.expect_var_path("__a_global", type="int", value="1")
 
         # Set breakpoint for b() next.
         lldbutil.run_break_set_by_symbol(
             self, "b", num_expected_locations=1, sym_exact=True)
 
         # Continue the program, we should break at b(int) next.
         self.runCmd("continue")
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
         self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(int) arg = 2'])
-        self.expect("frame variable __b_global", VARIABLES_DISPLAYED_CORRECTLY,
-                    substrs=['(int) __b_global = 2'])
+        self.expect_var_path("__b_global", type="int", value="2")

lldb/test/API/lang/cpp/wchar_t/TestCxxWCharT.py

class CxxWCharTTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def test(self):
         """Test that C++ supports wchar_t correctly."""
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
 
         # Check that we correctly report templates on wchar_t
-        self.expect("frame variable foo_y",
-                    substrs=['(Foo<wchar_t>) foo_y = '])
+        self.expect_var_path("foo_y", type="Foo<wchar_t>")
 
         # Check that we correctly report templates on int
-        self.expect("frame variable foo_x",
-                    substrs=['(Foo<int>) foo_x = '])
+        self.expect_var_path("foo_x", type="Foo<int>")
 
         # Check that we correctly report wchar_t
-        self.expect("frame variable foo_y.object",
-                    substrs=['(wchar_t) foo_y.object = '])
+        self.expect_var_path("foo_y.object", type="wchar_t")
 
         # Check that we correctly report int
-        self.expect("frame variable foo_x.object",
-                    substrs=['(int) foo_x.object = '])
+        self.expect_var_path("foo_x.object", type="int")
 
         # Check that we can run expressions that return wchar_t
         self.expect("expression L'a'", substrs=['(wchar_t) $', "L'a'"])
 
         # Mazel Tov if this works!
         self.expect("frame variable mazeltov",
                     substrs=['(const wchar_t *) mazeltov = ', 'L"מזל טוב"'])