[lldb] Remove prefer-dynamic-value test override

[kastiglione]

Summary

Remove the test override of target.prefer-dynamic-value.

Previously, the lldb default was no-dynamic-values. In rG9aa7e8e9ffbe (in
2015), the default was changed to no-run-target, but at that time the tests
were changed to be run with no-dynamic-value. I don't the reasons for not
changing the tests, perhaps to avoid determining which tests to change and how.

Because no-run-target is the lldb default, I think it makes sense to make it
the test default too. It puts the test config closer to what's used in
practice.

This change removes the target.prefer-dynamic-value override, and for those
tests that failed, they have been updated to explicitly use
no-dynamic-values. Future changes could update these tests to use dynamic
values too, or they can be left as is to exercise non-dynamic typing.

[kastiglione]

lldb/test/API/sanity/TestSettingSkipping.py

15–32

these tests had nothing to do with prefer-dynamic-value, they picked something to decorate on. I picked something else to decorate on. I couldn't pick a setting now that configuration.settings is empty.

[mib]

were changed to be run with no-dynamic-value. I don't the reasons for not
changing the tests, perhaps to avoid determining which tests to change and how.

I don't know the reasons ... ?

[mib]

I've had this issue in the past in a test where the variable value would not match what I'd get on an interactive debug session, until I added that flag.

I think this makes sense to have consistency between the interactive session default and the test suite. LGTM!

[augusto2112]

I think this is a good change. One related thing that we could look into fixing is that currently both run-target and no-run-target do the exact same thing. Not sure if we could remove one of them since this could break user's settings, but we could at least document it.

[kastiglione]

Fixed description

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

 compiler = None
 dsymutil = None
 sdkroot = None
 
 # The overriden dwarf verison.
 dwarf_version = 0
 
 # Any overridden settings.
-# Always disable default dynamic types for testing purposes.
-settings = [('target.prefer-dynamic-value', 'no-dynamic-values')]
+settings = []
 
 # Path to the FileCheck testing tool. Not optional.
 filecheck = None
 
 # Path to the yaml2obj tool. Not optional.
 yaml2obj = None
 
 # The arch might dictate some specific CFLAGS to be passed to the toolchain to build

lldb/test/API/commands/expression/po_verbosity/TestPoVerbosity.py

def test(self):
         """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.m", self.line, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         self.expect("expr -O -v -- foo",
                     substrs=['(id) $', ' = 0x', '1 = 2', '2 = 3;'])
         self.expect("expr -O -vfull -- foo",
                     substrs=['(id) $', ' = 0x', '1 = 2', '2 = 3;'])
         self.expect("expr -O -- foo", matching=False,
                     substrs=['(id) $'])
 
         self.expect("expr -O -- 22", matching=False,

lldb/test/API/commands/expression/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

def test(self):
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # Now do a NSArry type query from the 'main.m' compile uint.
         self.expect("expression (NSArray*)array_token",
                     substrs=['(NSArray *) $0 = 0x'])
         # (NSArray *) $0 = 0x00007fff70118398

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCCF.py

def test_coreframeworks_and_run_command(self):
             lldb.SBFileSpec('main.m', False))
 
         # The stop reason of the thread should be breakpoint.
         self.expect(
             "thread list",
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=['stopped', 'stop reason = breakpoint'])
 
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         # check formatters for common Objective-C types
         expect_strings = [
             '(CFGregorianUnits) cf_greg_units = 1 years, 3 months, 5 days, 12 hours, 5 minutes 7 seconds',
             '(CFGregorianDate) cf_greg_date = @"4/10/1985 18:0:0"',
             '(CFRange) cf_range = location=4 length=4',
             '(NSPoint) ns_point = (x = 4, y = 4)',
             '(NSRange) ns_range = location=4, length=4',
             '(NSRect) ns_rect = (origin = (x = 1, y = 1), size = (width = 5, height = 5))',

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCExpr.py

def test_expr_with_run_command(self):
             lldb.SBFileSpec('main.m', False))
 
         # The stop reason of the thread should be breakpoint.
         self.expect(
             "thread list",
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=['stopped', 'stop reason = breakpoint'])
 
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         # 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 format clear', check=False)
             self.runCmd('type summary clear', check=False)
             self.runCmd('type synth clear', check=False)
 
         # Execute the cleanup function during test case tear down.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCKVO.py

class ObjCDataFormatterKVO(ObjCDataFormatterTestCase):
 
     def test_kvo_with_run_command(self):
         """Test the behavior of formatters when KVO is in use."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
             self, '// Set break point at this line.',
             lldb.SBFileSpec('main.m', False))
 
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         # The stop reason of the thread should be breakpoint.
         self.expect(
             "thread list",
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=['stopped', 'stop reason = breakpoint'])
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSContainer.py

 
 class ObjCDataFormatterNSContainer(ObjCDataFormatterTestCase):
 
     def test_nscontainers_with_run_command(self):
         """Test formatters for  NS container classes."""
         self.appkit_tester_impl(self.nscontainers_data_formatter_commands, False)
 
     def nscontainers_data_formatter_commands(self):
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         self.expect(
             'frame variable newArray nsDictionary newDictionary nscfDictionary cfDictionaryRef newMutableDictionary copyDictionary newMutableDictionaryRef cfarray_ref mutable_array_ref',
             substrs=[
                 '(NSArray *) newArray = ',
                 ' @"50 elements"',
                 '(NSDictionary *) nsDictionary = ',
                 ' 2 key/value pairs',
                 '(NSDictionary *) newDictionary = ',

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSData.py

def test_nsdata_with_run_command(self):
         self.appkit_tester_impl(self.nsdata_data_formatter_commands, True)
 
     @skipUnlessDarwin
     def test_nsdata_with_run_command_no_const(self):
         """Test formatters for  NSData."""
         self.appkit_tester_impl(self.nsdata_data_formatter_commands, False)
 
     def nsdata_data_formatter_commands(self):
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         self.expect(
             'frame variable immutableData mutableData data_ref mutable_data_ref mutable_string_ref concreteData concreteMutableData',
             substrs=[
                 '(NSData *) immutableData = ', ' 5 bytes',
                 '(NSData *) mutableData = ', ' 14 bytes',
                 '(CFDataRef) data_ref = ', '@"5 bytes"',
                 '(CFMutableDataRef) mutable_data_ref = ', '@"5 bytes"',
                 '(CFMutableStringRef) mutable_string_ref = ',
                 ' @"Wish ya knew"', '(NSData *) concreteData = ',
                 ' 100000 bytes', '(NSMutableData *) concreteMutableData = ',
                 ' 100000 bytes'
             ])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSNumber.py

def test_nsnumber_with_run_command(self):
         self.appkit_tester_impl(self.nscontainers_data_formatter_commands, True)
 
     @skipUnlessDarwin
     def test_nsnumber_with_run_command_no_const(self):
         """Test formatters for  NS container classes."""
         self.appkit_tester_impl(self.nscontainers_data_formatter_commands, False)
 
     def nscontainers_data_formatter_commands(self):
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         self.expect(
             'frame variable newArray nsDictionary newDictionary nscfDictionary cfDictionaryRef newMutableDictionary cfarray_ref mutable_array_ref',
             substrs=[
                 '(NSArray *) newArray = ', '@"50 elements"',
                 '(NSDictionary *) nsDictionary = ', ' 2 key/value pairs',
                 '(NSDictionary *) newDictionary = ', ' 12 key/value pairs',
                 '(CFDictionaryRef) cfDictionaryRef = ', ' 2 key/value pairs',
                 '(NSDictionary *) newMutableDictionary = ', ' 21 key/value pairs',

lldb/test/API/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py

def appkit_tester_impl(self, commands):
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():

lldb/test/API/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py

def test_rdar11086338_with_run_command(self):
                 '[1] = 0x',
                 '[2] = 0x',
                 '[3] = 0x'])
         self.expect(
             'frame variable empty_arr --ptr-depth 1',
             substrs=[
                 '@"0 elements"'])
         self.expect(
-            'frame variable arr --ptr-depth 1 -d no-run-target',
+            'frame variable arr --ptr-depth 1',
             substrs=[
                 '@"6 elements"',
                 '@"hello"',
                 '@"world"',
                 '@"this"',
                 '@"is"',
                 '@"me"',
                 '@"http://www.apple.com'])
         self.expect(
-            'frame variable other_arr --ptr-depth 1 -d no-run-target',
+            'frame variable other_arr --ptr-depth 1',
             substrs=[
                 '@"4 elements"',
                 '(int)5',
                 '@"a string"',
                 '@"6 elements"'])
         self.expect(
-            'frame variable other_arr --ptr-depth 2 -d no-run-target',
+            'frame variable other_arr --ptr-depth 2',
             substrs=[
                 '@"4 elements"',
                 '@"6 elements" {',
                 '@"hello"',
                 '@"world"',
                 '@"this"',
                 '@"is"',
                 '@"me"',

lldb/test/API/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py

def run_tests(self):
                 '4 key/value pairs',
                 '[0] = ',
                 'key = 0x',
                 'value = 0x',
                 '[1] = ',
                 '[2] = ',
                 '[3] = '])
         self.expect(
-            'frame variable dictionary --ptr-depth 1 --dynamic-type no-run-target',
+            'frame variable dictionary --ptr-depth 1',
             substrs=[
                 '3 key/value pairs',
                 '@"bar"',
                 '@"2 elements"',
                 '@"baz"',
                 '2 key/value pairs'])
         self.expect(
-            'frame variable mutabledict --ptr-depth 1 --dynamic-type no-run-target',
+            'frame variable mutabledict --ptr-depth 1',
             substrs=[
                 '4 key/value pairs',
                 '(int)23',
                 '@"123"',
                 '@"http://www.apple.com"',
                 '@"sourceofstuff"',
                 '3 key/value pairs'])
         self.expect(
-            'frame variable mutabledict --ptr-depth 2 --dynamic-type no-run-target',
+            'frame variable mutabledict --ptr-depth 2',
             substrs=[
                 '4 key/value pairs',
                 '(int)23',
                 '@"123"',
                 '@"http://www.apple.com"',
                 '@"sourceofstuff"',
                 '3 key/value pairs',
                 '@"bar"',
                 '@"2 elements"'])
         self.expect(
-            'frame variable mutabledict --ptr-depth 3 --dynamic-type no-run-target',
+            'frame variable mutabledict --ptr-depth 3',
             substrs=[
                 '4 key/value pairs',
                 '(int)23',
                 '@"123"',
                 '@"http://www.apple.com"',
                 '@"sourceofstuff"',
                 '3 key/value pairs',
                 '@"bar"',

lldb/test/API/lang/cpp/diamond/TestCppDiamond.py

class TestCase(TestBase):
     def test_with_sbvalue(self):
         """
         Test that virtual base classes work in when SBValue objects are
         used to explore the class.
         """
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// breakpoint 1", lldb.SBFileSpec("main.cpp"))
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         j1 = self.frame().FindVariable("j1")
         j1_Derived1 = j1.GetChildAtIndex(0)
         j1_Derived2 = j1.GetChildAtIndex(1)
         j1_Derived1_VBase = j1_Derived1.GetChildAtIndex(0)
         j1_Derived2_VBase = j1_Derived2.GetChildAtIndex(0)
         j1_Derived1_VBase_m_value = j1_Derived1_VBase.GetChildAtIndex(0)
         j1_Derived2_VBase_m_value = j1_Derived2_VBase.GetChildAtIndex(0)
 

lldb/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.py

def test_with_python_api(self):
 
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, "Created a process.")
         self.assertEqual(
             process.GetState(), lldb.eStateStopped,
             "Stopped it too.")
 
+        self.runCmd('settings set target.prefer-dynamic-value no-dynamic-values')
+
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
         self.assertEqual(len(thread_list), 1)
         thread = thread_list[0]
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame, "frame 0 is valid")
 

lldb/test/API/lang/objc/exceptions/TestObjCExceptions.py

def test_objc_exceptions_at_throw(self):
         self.expect(
             'frame variable e1',
             substrs=[
                 '(NSException *) e1 = ',
                 '"SomeReason"'
             ])
 
         self.expect(
-            'frame variable --dynamic-type no-run-target *e1',
+            'frame variable *e1',
             substrs=[
                 '(NSException) *e1 = ',
                 'name = ', '"ExceptionName"',
                 'reason = ', '"SomeReason"',
                 'userInfo = ', '1 key/value pair',
                 'reserved = ', 'nil',
             ])
 
def test_objc_exceptions_at_throw(self):
         self.expect(
             'frame variable e2',
             substrs=[
                 '(NSException *) e2 = ',
                 '"SomeReason"'
             ])
 
         self.expect(
-            'frame variable --dynamic-type no-run-target *e2',
+            'frame variable *e2',
             substrs=[
                 '(NSException) *e2 = ',
                 'name = ', '"ThrownException"',
                 'reason = ', '"SomeReason"',
                 'userInfo = ', '1 key/value pair',
                 'reserved = ',
             ])
 

lldb/test/API/lang/objc/foundation/TestObjCMethods.py

def test_data_type_and_expr(self):
             num_expected_locations=1,
             sym_exact=True)
 #        self.expect("breakpoint set -n '-[MyString description]", BREAKPOINT_CREATED,
 # startstr = "Breakpoint created: 1: name = '-[MyString description]',
 # locations = 1")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # The backtrace should show we stop at -[MyString description].
         self.expect("thread backtrace", "Stop at -[MyString description]",
                     substrs=["a.out`-[MyString description]"])
 
         # Lookup objc data type MyString and evaluate some expressions.
 
         self.expect("image lookup -t NSString", DATA_TYPES_DISPLAYED_CORRECTLY,
                     substrs=['name = "NSString"',

lldb/test/API/lang/objc/foundation/TestObjCMethodsString.py

class FoundationTestCaseString(TestBase):
 
     def test_NSString_expr_commands(self):
         """Test expression commands for NSString."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
                 self, '// Break here for NSString tests',
                 lldb.SBFileSpec('main.m', False))
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # Test_NSString:
         self.runCmd("thread backtrace")
         self.expect("expression (int)[str length]",
                     patterns=["\(int\) \$.* ="])
         self.expect("expression (int)[str_id length]",
                     patterns=["\(int\) \$.* ="])
         self.expect("expression (id)[str description]",
                     patterns=["\(id\) \$.* = 0x"])

lldb/test/API/lang/objc/foundation/TestRuntimeTypes.py

def test_break(self):
         lldbutil.run_break_set_by_symbol(
             self,
             '-[MyString description]',
             num_expected_locations=1,
             sym_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # The backtrace should show we stop at -[MyString description].
         self.expect("thread backtrace", "Stop at -[MyString description]",
                     substrs=["a.out`-[MyString description]"])
 
         # Use runtime information about NSString.
 
         # The length property should be usable.
         self.expect("expression str.length", VARIABLES_DISPLAYED_CORRECTLY,

lldb/test/API/lang/objc/objc-new-syntax/TestObjCNewSyntaxLiteral.py

def test_integer_literals(self):
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["1"])
 
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_float_literal(self):
         self.runToBreakpoint()
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         self.expect("expr -- @123.45", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["NSNumber", "123.45"])
 
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_expressions_in_literals(self):
         self.runToBreakpoint()
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         self.expect(
             "expr --object-description -- @( 1 + 3 )",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["4"])
         self.expect(
             "expr -- @((char*)\"Hello world\" + 6)",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "NSString",
                 "world"])

lldb/test/API/lang/objc/real-definition/TestRealDefinition.py

def test_frame_var_after_stop_at_interface(self):
 
         # Break inside the foo function which takes a bar_ptr argument.
         self.expect('breakpoint set -p "// Set breakpoint in main"')
         self.runCmd("continue", RUN_SUCCEEDED)
 
         # Run at stop at main
         lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # This should display correctly.
         self.expect(
             "frame variable foo->_bar->_hidden_ivar",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "(NSString *)",
                 "foo->_bar->_hidden_ivar = 0x"])
 
def test_frame_var_after_stop_at_implementation(self):
             lldb.SBFileSpec("Bar.m", False))
 
         self.expect('breakpoint set -p "// Set breakpoint in main"')
         self.runCmd("continue", RUN_SUCCEEDED)
 
         # Run at stop at main
         lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
+        self.runCmd("settings set target.prefer-dynamic-value no-dynamic-values")
+
         # This should display correctly.
         self.expect(
             "frame variable foo->_bar->_hidden_ivar",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "(NSString *)",
                 "foo->_bar->_hidden_ivar = 0x"])

lldb/test/API/sanity/TestSettingSkipping.py

 """
 This is a sanity check that verifies that test can be sklipped based on settings.
 """
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 
 
 class SettingSkipSanityTestCase(TestBase):
 
   NO_DEBUG_INFO_TESTCASE = True
 
-  @skipIf(setting=('target.prefer-dynamic-value', 'no-dynamic-values'))
+  @skipIf(py_version=('>=', (3, 0)))
   def testSkip(self):
     """This setting is on by default"""
     self.assertTrue(False, "This test should not run!")
 
-  @skipIf(setting=('target.prefer-dynamic-value', 'run-target'))
+  @skipIf(py_version=('<', (3, 0)))
   def testNoMatch(self):
     self.assertTrue(True, "This test should run!")
 
   @skipIf(setting=('target.i-made-this-one-up', 'true'))
   def testNotExisting(self):
     self.assertTrue(True, "This test should run!")
 
-  @expectedFailureAll(setting=('target.prefer-dynamic-value', 'no-dynamic-values'))
+  @expectedFailureAll(py_version=('>=', (3, 0)))
   def testXFAIL(self):
     self.assertTrue(False, "This test should run and fail!")
 
-  @expectedFailureAll(setting=('target.prefer-dynamic-value', 'run-target'))
+  @expectedFailureAll(py_version=('<', (3, 0)))
   def testNotXFAIL(self):
     self.assertTrue(True, "This test should run and succeed!")