From 684aa0235c757a614963deaa4337202b1bc6c997 Mon Sep 17 00:00:00 2001
From: Marcelo Lira <marcelo.lira@openbossa.org>
Date: Fri, 30 Oct 2009 17:11:00 -0300
Subject: added new test cases to check if a value-type object passed as
 reference to regular, virtual and reimplemented virtual methods are being
 altered in place

---
 tests/libsample/reference.cpp         | 14 +++++++++++++-
 tests/libsample/reference.h           |  9 ++++++++-
 tests/samplebinding/reference_test.py | 27 +++++++++++++++++++++++++++
 3 files changed, 48 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/libsample/reference.cpp b/tests/libsample/reference.cpp
index c61672849..08805dc5b 100644
--- a/tests/libsample/reference.cpp
+++ b/tests/libsample/reference.cpp
@@ -40,7 +40,7 @@ using namespace std;
 void
 Reference::show() const
 {
-    cout << "Reference.objId: " << m_objId;
+    cout << "Reference.objId: " << m_objId << ", address: " << this;
 }
 
 int
@@ -67,3 +67,15 @@ Reference::callUsesConstReferenceVirtual(const Reference& r, int inc)
     return usesConstReferenceVirtual(r, inc);
 }
 
+void
+Reference::alterReferenceIdVirtual(Reference& r)
+{
+    r.setObjId(r.objId() * Reference::multiplier());
+}
+
+void
+Reference::callAlterReferenceIdVirtual(Reference& r)
+{
+    alterReferenceIdVirtual(r);
+}
+
diff --git a/tests/libsample/reference.h b/tests/libsample/reference.h
index 6b20ef262..c8c3f46ce 100644
--- a/tests/libsample/reference.h
+++ b/tests/libsample/reference.h
@@ -35,6 +35,8 @@
 #ifndef REFERENCE_H
 #define REFERENCE_H
 
+#include "str.h"
+
 class Reference
 {
 public:
@@ -42,7 +44,7 @@ public:
             : m_objId(objId) {}
     ~Reference() {}
 
-    double objId() { return m_objId; }
+    int objId() { return m_objId; }
     void setObjId(int objId) { m_objId = objId; }
 
     static int usesReference(Reference& r) { return r.m_objId; }
@@ -54,8 +56,13 @@ public:
     int callUsesReferenceVirtual(Reference& r, int inc);
     int callUsesConstReferenceVirtual(const Reference& r, int inc);
 
+    virtual void alterReferenceIdVirtual(Reference& r);
+    void callAlterReferenceIdVirtual(Reference& r);
+
     void show() const;
 
+    static int multiplier() { return 10; }
+
 private:
     int m_objId;
 };
diff --git a/tests/samplebinding/reference_test.py b/tests/samplebinding/reference_test.py
index af1adee89..4157b3425 100755
--- a/tests/samplebinding/reference_test.py
+++ b/tests/samplebinding/reference_test.py
@@ -38,6 +38,7 @@ class ExtendedReference(Reference):
         self.uses_const_reference_virtual_called = False
         self.reference_inc = 1
         self.const_reference_inc = 2
+        self.multiplier = 333
 
     def usesReferenceVirtual(self, ref, inc):
         self.uses_reference_virtual_called = True
@@ -47,6 +48,10 @@ class ExtendedReference(Reference):
         self.uses_const_reference_virtual_called = True
         return ref.objId() + inc + self.const_reference_inc
 
+    def alterReferenceIdVirtual(self, ref):
+        ref.setObjId(ref.objId() * self.multiplier)
+
+
 class ReferenceTest(unittest.TestCase):
     '''Test case for methods that receive references to objects.'''
 
@@ -62,6 +67,28 @@ class ReferenceTest(unittest.TestCase):
         r = Reference(objId)
         self.assertEqual(Reference.usesConstReference(r), objId)
 
+    def testModificationOfReference(self):
+        '''Tests if the identity of a reference argument is preserved when passing it to be altered in C++.'''
+        objId = 123
+        r1 = Reference(objId)
+        r1.alterReferenceIdVirtual(r1)
+        self.assertEqual(r1.objId(), objId * Reference.multiplier())
+
+    def testModificationOfReferenceCallingAVirtualIndirectly(self):
+        '''Tests if the identity of a reference argument is preserved when passing it to be altered in C++ through a method that calls a virtual method.'''
+        objId = 123
+        r1 = Reference(objId)
+        r1.callAlterReferenceIdVirtual(r1)
+        self.assertEqual(r1.objId(), objId * Reference.multiplier())
+
+    def testModificationOfReferenceCallingAReimplementedVirtualIndirectly(self):
+        '''Test if a Python override of a virtual method with a reference parameter called from C++ alters the argument properly.'''
+        objId = 123
+        r = Reference(objId)
+        er = ExtendedReference()
+        result = er.callAlterReferenceIdVirtual(r)
+        self.assertEqual(r.objId(), objId * er.multiplier)
+
     def testReimplementedVirtualMethodCallWithReferenceParameter(self):
         '''Test if a Python override of a virtual method with a reference parameter is correctly called from C++.'''
         inc = 9
-- 
cgit v1.2.3