3 files changed, 226 insertions, 0 deletions
diff --git a/lldb/test/lang/objc/objc-property/Makefile b/lldb/test/lang/objc/objc-property/Makefile
new file mode 100644
index 00000000000..a1608fe5a66
--- /dev/null
+++ b/lldb/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/lldb/test/lang/objc/objc-property/TestObjCProperty.py b/lldb/test/lang/objc/objc-property/TestObjCProperty.py
new file mode 100644
index 00000000000..fbcb79560d3
--- /dev/null
+++ b/lldb/test/lang/objc/objc-property/TestObjCProperty.py
@@ -0,0 +1,129 @@
+"""
+Use lldb Python API to verify that expression evaluation for property references uses the correct getters and setters
+"""
+
+import os, time
+import re
+import unittest2
+import lldb, lldbutil
+from lldbtest import *
+
+class ObjCDynamicValueTestCase(TestBase):
+
+    mydir = os.path.join("lang", "objc", "objc-property")
+
+    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
+    @python_api_test
+    def test_get_dynamic_objc_vals_with_dsym(self):
+        """Test that expr uses the correct property getters and setters"""
+        self.buildDsym()
+        self.do_test_properties()
+
+    @python_api_test
+    def test_get_objc_dynamic_vals_with_dwarf(self):
+        """Test that expr uses the correct property getters and setters"""
+        self.buildDwarf()
+        self.do_test_properties()
+
+    def setUp(self):
+        # Call super's setUp().                                                                                                           
+        TestBase.setUp(self)
+
+        # Find the line number to break for main.c.                                                                                       
+
+        self.source_name = 'main.m'
+
+    def run_to_main (self):
+        """Test that expr uses the correct property getters and setters"""
+        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, os.getcwd())
+
+        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]
+        return thread
+
+    def do_test_properties (self):
+
+        thread = self.run_to_main()
+
+        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))
+
+        #
+        # This doesn't work correctly yet, because the clang Sema::HandleExprPropertyRefExpr
+        # doesn't complete the class before looking up the property.
+        #
+        #unbacked_value = frame.EvaluateExpression("mine.unbackedInt", False)
+        #unbacked_error = unbacked_value.GetError()
+        #self.assertTrue (unbacked_error.Success())
+        
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()
diff --git a/lldb/test/lang/objc/objc-property/main.m b/lldb/test/lang/objc/objc-property/main.m
new file mode 100644
index 00000000000..4ce78eccde5
--- /dev/null
+++ b/lldb/test/lang/objc/objc-property/main.m
@@ -0,0 +1,91 @@
+#import <Foundation/Foundation.h>
+
+@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;
+@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;
+
+  NSLog (@"Results for %p: nonexistant: %d backed: %d unbacked: %d accessCount: %d.",
+         mine,
+         nonexistant,
+         backedInt,
+         unbackedInt,
+         [mine getAccessCount]);
+  return 0;
+
+}
+