Vendor import of lldb trunk r256945:

https://llvm.org/svn/llvm-project/lldb/trunk@256945

3 files changed, 220 insertions, 0 deletions

diff --git a/packages/Python/lldbsuite/test/lang/objc/objc-property/Makefile b/packages/Python/lldbsuite/test/lang/objc/objc-property/Makefile
new file mode 100644
index 0000000..a1608fe
--- /dev/null
+++ b/packages/Python/lldbsuite/test/lang/objc/objc-property/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+OBJC_SOURCES := main.m
+LDFLAGS = $(CFLAGS) -lobjc -framework Foundation
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/lang/objc/objc-property/TestObjCProperty.py b/packages/Python/lldbsuite/test/lang/objc/objc-property/TestObjCProperty.py
new file mode 100644
index 0000000..c22a1f1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/lang/objc/objc-property/TestObjCProperty.py
@@ -0,0 +1,114 @@
+"""
+Use lldb Python API to verify that expression evaluation for property references uses the correct getters and setters
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class ObjCPropertyTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().                                                                                                           
+        TestBase.setUp(self)
+
+        # Find the line number to break for main.c.                                                                                       
+        self.source_name = 'main.m'
+
+    @skipUnlessDarwin
+    @add_test_categories(['pyapi'])
+    def test_objc_properties(self):
+        """Test that expr uses the correct property getters and setters"""
+        if self.getArchitecture() == 'i386':
+            self.skipTest("requires modern objc runtime")
+
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        # Create a target from the debugger.
+
+        target = self.dbg.CreateTarget (exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Set up our breakpoints:
+        
+        main_bkpt = target.BreakpointCreateBySourceRegex ("Set a breakpoint here.", lldb.SBFileSpec (self.source_name))
+        self.assertTrue(main_bkpt and
+                        main_bkpt.GetNumLocations() == 1,
+                        VALID_BREAKPOINT)
+
+        # Now launch the process, and do not stop at the entry point.
+        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+
+        self.assertTrue(process.GetState() == lldb.eStateStopped,
+                        PROCESS_STOPPED)
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint (process, main_bkpt)
+        self.assertTrue (len(threads) == 1)
+        thread = threads[0]
+        frame = thread.GetFrameAtIndex(0)
+
+        mine = frame.FindVariable ("mine")
+        self.assertTrue (mine.IsValid())
+        access_count = mine.GetChildMemberWithName ("_access_count")
+        self.assertTrue (access_count.IsValid())
+        start_access_count = access_count.GetValueAsUnsigned (123456)
+        self.assertTrue (start_access_count != 123456)
+
+        #
+        # The first set of tests test calling the getter & setter of
+        # a property that actually only has a getter & setter and no
+        # @property.
+        #
+        nonexistant_value = frame.EvaluateExpression("mine.nonexistantInt", False)
+        nonexistant_error = nonexistant_value.GetError()
+        self.assertTrue (nonexistant_error.Success())
+        nonexistant_int = nonexistant_value.GetValueAsUnsigned (123456)
+        self.assertTrue (nonexistant_int == 6)
+        
+        # Calling the getter function would up the access count, so make sure that happened.
+        
+        new_access_count = access_count.GetValueAsUnsigned (123456)
+        self.assertTrue (new_access_count - start_access_count == 1)
+        start_access_count = new_access_count
+
+        #
+        # Now call the setter, then make sure that
+        nonexistant_change = frame.EvaluateExpression("mine.nonexistantInt = 10", False)
+        nonexistant_error = nonexistant_change.GetError()
+        self.assertTrue (nonexistant_error.Success())
+
+        # Calling the setter function would up the access count, so make sure that happened.
+        
+        new_access_count = access_count.GetValueAsUnsigned (123456)
+        self.assertTrue (new_access_count - start_access_count == 1)
+        start_access_count = new_access_count
+
+        #
+        # Now we call the getter of a property that is backed by an ivar,
+        # make sure it works and that we actually update the backing ivar.
+        #
+
+        backed_value = frame.EvaluateExpression("mine.backedInt", False)
+        backed_error = backed_value.GetError()
+        self.assertTrue (backed_error.Success())
+        backing_value = mine.GetChildMemberWithName ("_backedInt")
+        self.assertTrue (backing_value.IsValid())
+        self.assertTrue (backed_value.GetValueAsUnsigned (12345) == backing_value.GetValueAsUnsigned(23456))
+
+        unbacked_value = frame.EvaluateExpression("mine.unbackedInt", False)
+        unbacked_error = unbacked_value.GetError()
+        self.assertTrue (unbacked_error.Success())
+
+        idWithProtocol_value = frame.EvaluateExpression("mine.idWithProtocol", False)
+        idWithProtocol_error = idWithProtocol_value.GetError()
+        self.assertTrue (idWithProtocol_error.Success())
+        self.assertTrue (idWithProtocol_value.GetTypeName() == "id")
diff --git a/packages/Python/lldbsuite/test/lang/objc/objc-property/main.m b/packages/Python/lldbsuite/test/lang/objc/objc-property/main.m
new file mode 100644
index 0000000..2ef142b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/lang/objc/objc-property/main.m
@@ -0,0 +1,100 @@
+#import <Foundation/Foundation.h>
+
+@protocol MyProtocol
+
+-(const char *)hello;
+
+@end
+
+@interface BaseClass : NSObject
+{
+  int _backedInt;
+  int _access_count;
+}
+
+- (int) nonexistantInt;
+- (void) setNonexistantInt: (int) in_int;
+
+- (int) myGetUnbackedInt;
+- (void) mySetUnbackedInt: (int) in_int;
+
+- (int) getAccessCount;
+
++(BaseClass *) baseClassWithBackedInt: (int) inInt andUnbackedInt: (int) inOtherInt;
+
+@property(getter=myGetUnbackedInt,setter=mySetUnbackedInt:) int unbackedInt;
+@property int backedInt;
+@property (nonatomic, assign) id <MyProtocol> idWithProtocol;
+@end
+
+@implementation BaseClass
+@synthesize unbackedInt;
+@synthesize backedInt = _backedInt;
+
++ (BaseClass *) baseClassWithBackedInt: (int) inInt andUnbackedInt: (int) inOtherInt
+{
+  BaseClass *new = [[BaseClass alloc] init];
+  
+  new->_backedInt = inInt;
+  new->unbackedInt = inOtherInt;
+
+  return new;
+}
+
+- (int) myGetUnbackedInt
+{
+  // NSLog (@"Getting BaseClass::unbackedInt - %d.\n", unbackedInt);
+  _access_count++;
+  return unbackedInt;
+}
+
+- (void) mySetUnbackedInt: (int) in_int
+{
+  // NSLog (@"Setting BaseClass::unbackedInt from %d to %d.", unbackedInt, in_int);
+  _access_count++;
+  unbackedInt = in_int;
+}
+
+- (int) nonexistantInt
+{
+  // NSLog (@"Getting BaseClass::nonexistantInt - %d.\n", 5);
+  _access_count++;
+  return 6;
+}
+
+- (void) setNonexistantInt: (int) in_int
+{
+  // NSLog (@"Setting BaseClass::nonexistantInt from 7 to %d.", in_int);
+  _access_count++;
+}
+
+- (int) getAccessCount
+{
+  return _access_count;
+}
+@end
+
+int
+main ()
+{
+  BaseClass *mine = [BaseClass baseClassWithBackedInt: 10 andUnbackedInt: 20];
+  
+  // Set a breakpoint here.
+  int nonexistant = mine.nonexistantInt;
+
+  int backedInt = mine.backedInt;
+
+  int unbackedInt = mine.unbackedInt;
+
+  id idWithProtocol = mine.idWithProtocol;
+
+  NSLog (@"Results for %p: nonexistant: %d backed: %d unbacked: %d accessCount: %d.",
+         mine,
+         nonexistant,
+         backedInt,
+         unbackedInt,
+         [mine getAccessCount]);
+  return 0;
+
+}
+