Additional fixes for ICE-8204 - Objective-C leaks

5 files changed, 478 insertions, 55 deletions

diff --git a/objective-c/test/Ice/slicing/objects/AllTests.m b/objective-c/test/Ice/slicing/objects/AllTests.m
index 32d74d8212d..8856fe40cd8 100644
--- a/objective-c/test/Ice/slicing/objects/AllTests.m
+++ b/objective-c/test/Ice/slicing/objects/AllTests.m
@@ -13,6 +13,125 @@
 
 #import <Foundation/Foundation.h>
 
+static void breakCycles(id o)
+{
+    if([o isKindOfClass:[TestSlicingObjectsClientD1 class]])
+    {
+        TestSlicingObjectsClientD1* d1 = (TestSlicingObjectsClientD1*)o;
+        d1.pd1 = nil;
+        if(d1.pd1 != d1)
+        {
+            breakCycles(d1.pd1);
+        }
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientD3 class]])
+    {
+        TestSlicingObjectsClientD3* d3 = (TestSlicingObjectsClientD3*)o;
+        d3.pd3 = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientB class]])
+    {
+        TestSlicingObjectsClientB* b = (TestSlicingObjectsClientB*)o;
+        if(b.pb != nil)
+        {
+            b.pb.pb = nil;
+        }
+        b.pb = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientPDerived class]])
+    {
+        TestSlicingObjectsClientPDerived* p = (TestSlicingObjectsClientPDerived*)o;
+        p.pb = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientCompactPDerived class]])
+    {
+        TestSlicingObjectsClientPDerived* p = (TestSlicingObjectsClientPDerived*)o;
+        p.pb = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientPCDerived class]])
+    {
+        TestSlicingObjectsClientPCDerived* p = (TestSlicingObjectsClientPCDerived*)o;
+        NSArray* a = ICE_RETAIN(p.pbs);
+        p.pbs = nil;
+        for(id e in a)
+        {
+            breakCycles(e);
+        }
+        ICE_RELEASE(a);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientCompactPCDerived class]])
+    {
+        TestSlicingObjectsClientCompactPCDerived* p = (TestSlicingObjectsClientCompactPCDerived*)o;
+        NSArray* a = ICE_RETAIN(p.pbs);
+        p.pbs = nil;
+        for(id e in a)
+        {
+            breakCycles(e);
+        }
+        ICE_RELEASE(a);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientPCDerived3 class]])
+    {
+        TestSlicingObjectsClientPCDerived3* p = (TestSlicingObjectsClientPCDerived3*)o;
+        p.pcd3 = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientPNode class]])
+    {
+        TestSlicingObjectsClientPNode* curr = o;
+        while(curr && o != curr.next)
+        {
+            TestSlicingObjectsClientPNode* next = curr.next;
+            curr.next = nil;
+            curr = next;
+        }
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientBaseException class]])
+    {
+        TestSlicingObjectsClientBaseException* e = (TestSlicingObjectsClientBaseException*)o;
+        breakCycles(e.pb);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientDerivedException class]])
+    {
+        TestSlicingObjectsClientDerivedException* e = (TestSlicingObjectsClientDerivedException*)o;
+        breakCycles(e.pd1);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientSS1 class]])
+    {
+        TestSlicingObjectsClientSS1* s = (TestSlicingObjectsClientSS1*)o;
+        breakCycles(s.s);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientSS2 class]])
+    {
+        TestSlicingObjectsClientSS2* s = (TestSlicingObjectsClientSS2*)o;
+        breakCycles(s.s);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientSS class]])
+    {
+        TestSlicingObjectsClientSS* s = (TestSlicingObjectsClientSS*)o;
+        breakCycles(s.c1);
+        breakCycles(s.c2);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsClientForward class]])
+    {
+        TestSlicingObjectsClientForward* f = (TestSlicingObjectsClientForward*)o;
+        f.h = nil;
+    }
+    if([o isKindOfClass:[NSArray class]])
+    {
+        for(id e in o)
+        {
+            breakCycles(e);
+        }
+    }
+    if([o isKindOfClass:[NSDictionary class]])
+    {
+        for(id e in [o allValues])
+        {
+            breakCycles(e);
+        }
+    }
+}
+
 @interface TestSlicingObjectsClientCallback : NSObject
 {
     BOOL called;
@@ -158,6 +277,7 @@
 -(void) SUnknownAsObjectResponse11:(ICEObject*)o
 {
     [self called];
+    [[o ice_getSlicedData] clear];
 }
 
 -(void) SUnknownAsObjectException11:(ICEException*)exc
@@ -171,7 +291,7 @@
     test([[b ice_id:nil] isEqualToString:@"::Test::B"]);
     test([b.sb isEqualToString:@"B1.sb"]);
     test(b.pb == b);
-    b.pb = nil;
+    breakCycles(b);
     [self called];
 }
 
@@ -192,7 +312,7 @@
     test([b2.sb isEqualToString:@"B2.sb"]);
     test(b2.pb == b1);
 
-    b2.pb = nil;
+    breakCycles(b1);
     [self called];
 }
 
@@ -221,8 +341,7 @@
     test([b2.sb isEqualToString:@"D2.sb"]);
     test([[b2 ice_id:nil] isEqualToString:@"::Test::B"]);
 
-    d1.pb = nil;
-    d1.pd1 = nil;
+    breakCycles(d1);
 
     [self called];
 }
@@ -245,6 +364,9 @@
     test([[b2 ice_id:nil] isEqualToString:@"::Test::B"]);
     test([b2.sb isEqualToString:@"D2.sb"]);
     test(b2.pb == d1);
+
+    breakCycles(d1);
+
     [self called];
 }
 
@@ -270,6 +392,9 @@
     TestSlicingObjectsClientD1* d1 = (TestSlicingObjectsClientD1*)b1;
     test([d1.sd1 isEqualToString:@"D1.sd1"]);
     test(d1.pd1 == b2);
+
+    breakCycles(b2);
+
     [self called];
 }
 
@@ -293,6 +418,9 @@
     test([[b2 ice_id:nil] isEqualToString:@"::Test::B"]);      // No factory, must be sliced
     test([b2.sb isEqualToString:@"D2.sb"]);
     test(b2.pb == b1);
+
+    breakCycles(d1);
+
     [self called];
 }
 
@@ -305,6 +433,9 @@
 {
     test(r_ == p1);
     [self called];
+    breakCycles(r_);
+    breakCycles(p1);
+    breakCycles(p2);
 }
 
 -(void) returnTest1Exception:(ICEException*)exc
@@ -316,6 +447,9 @@
 {
     test(r_ == p1);
     [self called];
+    breakCycles(r_);
+    breakCycles(p1);
+    breakCycles(p2);
 }
 
 -(void) returnTest2Exception:(ICEException*)exc
@@ -351,6 +485,10 @@
     test(ret.pb == 0);
     test([[ret ice_id:nil] isEqualToString:@"::Test::D1"]);
     [self called];
+
+    breakCycles(ret);
+    breakCycles(p1);
+    breakCycles(p2);
 }
 
 -(void) paramTest3Exception:(ICEException*)exc
@@ -370,6 +508,9 @@
     test(ret.pb == 0);
     test([[ret ice_id:nil] isEqualToString:@"::Test::B"]);
     [self called];
+
+    breakCycles(ret);
+    breakCycles(b);
 }
 
 -(void) paramTest4Exception:(ICEException*)exc
@@ -414,6 +555,7 @@
     test([e.pb.sb isEqualToString:@"sb"]);
     test(e.pb.pb == e.pb);
     [self called];
+    breakCycles(e.pb);
 }
 
 -(void) throwDerivedAsBaseResponse
@@ -436,6 +578,8 @@
     test([e.pd1.sd1 isEqualToString:@"sd2"]);
     test(e.pd1.pd1 == e.pd1);
     [self called];
+    breakCycles(e.pb);
+    breakCycles(e.pd1);
 }
 
 -(void) throwDerivedAsDerivedResponse
@@ -458,6 +602,8 @@
     test([e.pd1.sd1 isEqualToString:@"sd2"]);
     test(e.pd1.pd1 == e.pd1);
     [self called];
+    breakCycles(e.pb);
+    breakCycles(e.pd1);
 }
 
 -(void) throwUnknownDerivedAsBaseResponse
@@ -474,12 +620,14 @@
     test([e.pb.sb isEqualToString:@"sb d2"]);
     test(e.pb.pb == e.pb);
     [self called];
+    breakCycles(e.pb);
 }
 
 -(void) useForwardResponse:(TestSlicingObjectsClientForward*)f
 {
     test(f);
     [self called];
+    breakCycles(f);
 }
 
 -(void) useForwardException:(ICEException*)exc
@@ -496,6 +644,7 @@
     test([pd.ps isEqualToString:@"preserved"]);
     test([pd.pb isEqual:pd]);
     [self called];
+    breakCycles(res);
 }
 
 -(void) responsePreserved2:(TestSlicingObjectsClientPBase*)res
@@ -503,6 +652,7 @@
     test(![res isKindOfClass:[TestSlicingObjectsClientPCUnknown class]]);
     test(res.pi == 3);
     [self called];
+    breakCycles(res);
 }
 
 -(void) responsePreserved3:(TestSlicingObjectsClientPBase*)res
@@ -513,6 +663,7 @@
     test(![res isKindOfClass:[TestSlicingObjectsClientPCDerived class]]);
     test(res.pi == 3);
     [self called];
+    breakCycles(res);
 }
 
 -(void) responsePreserved4:(TestSlicingObjectsClientPBase*)res
@@ -525,6 +676,7 @@
     test(p2.pi == 3);
     test([[p2.pbs objectAtIndex:0] isEqual:p2]);
     [self called];
+    breakCycles(res);
 }
 
 -(void) responsePreserved5:(TestSlicingObjectsClientPBase*)res
@@ -543,6 +695,7 @@
     test(p3.pcd2 == p3.pi);
     test([p3.pcd3 isEqual:[p3.pbs objectAtIndex:10]]);
     [self called];
+    breakCycles(res);
 }
 
 -(void) responseCompactPreserved1:(TestSlicingObjectsClientPBase*)res
@@ -553,6 +706,7 @@
     test(![res isKindOfClass:[TestSlicingObjectsClientCompactPCDerived class]]);
     test(res.pi == 3);
     [self called];
+    breakCycles(res);
 }
 
 -(void) responseCompactPreserved2:(TestSlicingObjectsClientPBase*)res
@@ -565,6 +719,7 @@
     test(p2.pi == 3);
     test([[p2.pbs objectAtIndex:0] isEqual:p2]);
     [self called];
+    breakCycles(res);
 }
 
 -(void) response
@@ -603,7 +758,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
 
         test([o isKindOfClass:[TestSlicingObjectsClientSBase class]]);
@@ -630,7 +785,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -654,7 +809,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
         test([sb isKindOfClass:[TestSlicingObjectsClientSBSKnownDerived class]]);
         test([((TestSlicingObjectsClientSBSKnownDerived*)sb).sbskd isEqualToString:@"SBSKnownDerived.sbskd"]);
@@ -679,7 +834,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -702,7 +857,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
         if([[test ice_getEncodingVersion] isEqual:ICEEncoding_1_0])
         {
@@ -786,6 +941,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[((ICEUnknownSlicedValue*)o) getUnknownTypeId] isEqualToString:@"::Test::SUnknown"]);
             test([((ICEUnknownSlicedValue*)o) ice_getSlicedData] != nil);
             [test checkSUnknown:o];
+            [[o ice_getSlicedData] clear];
         }
         @catch(ICENoValueFactoryException*)
         {
@@ -794,7 +950,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         @catch(NSException* ex)
         {
             NSLog(@"exception: %@", ex);
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -832,8 +988,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[b ice_id] isEqualToString:@"::Test::B"]);
             test([b.sb isEqualToString:@"B1.sb"]);
             test([b.pb.sb isEqualToString:@"B1.sb"]);
-            b.pb = nil;
-
+            breakCycles(b);
         }
         @catch(...)
         {
@@ -865,7 +1020,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([b2.sb isEqualToString:@"B2.sb"]);
             test(b2.pb == b1);
 
-            b2.pb = nil;
+            breakCycles(b1);
         }
         @catch(...)
         {
@@ -906,8 +1061,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([b2.sb isEqualToString:@"D2.sb"]);
             test([[b2 ice_id] isEqualToString:@"::Test::B"]);
 
-            d1.pb = nil;
-            d1.pd1 = nil;
+            breakCycles(d1);
         }
         @catch(...)
         {
@@ -941,10 +1095,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[b2 ice_id] isEqualToString:@"::Test::B"]);
             test([b2.sb isEqualToString:@"D2.sb"]);
             test(b2.pb == d1);
+
+            breakCycles(d1);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -978,10 +1134,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             TestSlicingObjectsClientD1* d1 = (TestSlicingObjectsClientD1*)b1;
             test([d1.sd1 isEqualToString:@"D1.sd1"]);
             test(d1.pd1 == b2);
+
+            breakCycles(b2);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1015,10 +1173,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[b2 ice_id] isEqualToString:@"::Test::B"]);  // No factory, must be sliced
             test([b2.sb isEqualToString:@"D2.sb"]);
             test(b2.pb == b1);
+
+            breakCycles(d1);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1052,10 +1212,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[b2 ice_id] isEqualToString:@"::Test::B"]);  // No factory, must be sliced
             test([b2.sb isEqualToString:@"D2.sb"]);
             test(b2.pb == b1);
+
+            breakCycles(d1);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1068,10 +1230,14 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             TestSlicingObjectsClientB* p2;
             TestSlicingObjectsClientB* r = [test returnTest1:&p1 p2:&p2];
             test(r == p1);
+
+            breakCycles(p1);
+            breakCycles(p2);
+            breakCycles(r);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1092,10 +1258,13 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             TestSlicingObjectsClientB* p2;
             TestSlicingObjectsClientB* r = [test returnTest2:&p1 p1:&p2];
             test(r == p1);
+
+            breakCycles(p1);
+            breakCycles(p2);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1144,10 +1313,14 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(b1 != d3);
             test(b2 != d1);
             test(b2 != d3);
+
+            breakCycles(b1);
+            breakCycles(d1);
+            breakCycles(d3);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1191,6 +1364,10 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(b1 != d3);
             test(b2 != d1);
             test(b2 != d3);
+
+            breakCycles(b1);
+            breakCycles(d1);
+            breakCycles(d3);
         }
         @catch(NSException*)
         {
@@ -1235,10 +1412,14 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(b1 != d3);
             test(b2 != d1);
             test(b2 != d3);
+
+            breakCycles(b1);
+            breakCycles(d1);
+            breakCycles(d3);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1282,6 +1463,10 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(b1 != d3);
             test(b2 != d1);
             test(b2 != d3);
+
+            breakCycles(b1);
+            breakCycles(d1);
+            breakCycles(d3);
         }
         @catch(NSException*)
         {
@@ -1312,10 +1497,13 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([ret.sb isEqualToString:@"D1.sb (p2 2)"]);
             test(!ret.pb);
             test([[ret ice_id] isEqualToString:@"::Test::D1"]);
+
+            breakCycles(p1);
+            breakCycles(p2);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1347,7 +1535,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1384,10 +1572,15 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[r ice_id] isEqualToString:@"::Test::B"]);
             test([r.sb isEqualToString:@"D3.sb"]);
             test(r.pb == r);
+
+            breakCycles(b1);
+            breakCycles(b2);
+            breakCycles(d3);
+            breakCycles(r);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1419,6 +1612,11 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[r ice_id:nil] isEqualToString:@"::Test::B"]);
             test([r.sb isEqualToString:@"D3.sb"]);
             test(r.pb == r);
+
+            breakCycles(b1);
+            breakCycles(b2);
+            breakCycles(d3);
+            breakCycles(r);
         }
         @catch(NSException*)
         {
@@ -1453,10 +1651,15 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[r ice_id] isEqualToString:@"::Test::B"]);
             test([r.sb isEqualToString:@"D3.sb"]);
             test(r.pb == r);
+
+            breakCycles(d11);
+            breakCycles(d12);
+            breakCycles(d3);
+            breakCycles(r);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1490,6 +1693,11 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[r ice_id:nil] isEqualToString:@"::Test::B"]);
             test([r.sb isEqualToString:@"D3.sb"]);
             test(r.pb == r);
+
+            breakCycles(d11);
+            breakCycles(d12);
+            breakCycles(d3);
+            breakCycles(r);
         }
         @catch(NSException*)
         {
@@ -1551,6 +1759,9 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                 [(TestSlicingObjectsClientMutableBSeq*)ss2.s addObject:ss2d3];
 
                 ss = [test sequenceTest:ss1 p2:ss2];
+
+                breakCycles(ss1);
+                breakCycles(ss2);
             }
 
             test(ss.c1);
@@ -1579,10 +1790,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[ss2b ice_id] isEqualToString:@"::Test::B"]);
             test([[ss2d1 ice_id] isEqualToString:@"::Test::D1"]);
             test([[ss2d3 ice_id] isEqualToString:@"::Test::B"]);
+
+            breakCycles(ss);
         }
         @catch(ICEException*)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1643,6 +1856,9 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                 [test begin_sequenceTest:ss1 p2:ss2 response:^(TestSlicingObjectsClientSS* o) { [cb sequenceTestResponse:o]; } exception:^(ICEException* e) { [cb sequenceTestException:e]; }];
                 [cb check];
                 ss = cb.r;
+
+                breakCycles(ss1);
+                breakCycles(ss2);
             }
 
             test(ss.c1);
@@ -1671,6 +1887,8 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test([[ss2b ice_id:nil] isEqualToString:@"::Test::B"]);
             test([[ss2d1 ice_id:nil] isEqualToString:@"::Test::D1"]);
             test([[ss2d3 ice_id:nil] isEqualToString:@"::Test::B"]);
+
+            breakCycles(ss);
         }
         @catch(ICEException*)
         {
@@ -1725,10 +1943,14 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                 test([d1.sd1 isEqualToString:s]);
                 test(d1.pd1 == d1);
             }
+
+            breakCycles(bin);
+            breakCycles(bout);
+            breakCycles(r);
         }
         @catch(ICEException*)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1782,6 +2004,10 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                 test([d1.sd1 isEqualToString:s]);
                 test(d1.pd1 == d1);
             }
+
+            breakCycles(bin);
+            breakCycles(bout);
+            breakCycles(r);
         }
         @catch(ICEException*)
         {
@@ -1795,7 +2021,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         @try
         {
             [test throwBaseAsBase];
-            test(0);
+            test(NO);
         }
         @catch(TestSlicingObjectsClientBaseException* e)
         {
@@ -1804,10 +2030,11 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(e.pb);
             test([e.pb.sb isEqualToString:@"sb"]);
             test(e.pb.pb == e.pb);
+            breakCycles(e.pb);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1825,7 +2052,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         @try
         {
             [test throwDerivedAsBase];
-            test(0);
+            test(NO);
         }
         @catch(TestSlicingObjectsClientDerivedException* e)
         {
@@ -1840,10 +2067,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(e.pd1.pb == e.pd1);
             test([e.pd1.sd1 isEqualToString:@"sd2"]);
             test(e.pd1.pd1 == e.pd1);
+            breakCycles(e.pb);
+            breakCycles(e.pd1);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1861,7 +2090,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         @try
         {
             [test throwDerivedAsDerived];
-            test(0);
+            test(NO);
         }
         @catch(TestSlicingObjectsClientDerivedException* e)
         {
@@ -1876,10 +2105,12 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(e.pd1.pb == e.pd1);
             test([e.pd1.sd1 isEqualToString:@"sd2"]);
             test(e.pd1.pd1 == e.pd1);
+            breakCycles(e.pb);
+            breakCycles(e.pd1);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1897,7 +2128,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         @try
         {
             [test throwUnknownDerivedAsBase];
-            test(0);
+            test(NO);
         }
         @catch(TestSlicingObjectsClientBaseException* e)
         {
@@ -1906,10 +2137,11 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(e.pb);
             test([e.pb.sb isEqualToString:@"sb d2"]);
             test(e.pb.pb == e.pb);
+            breakCycles(e.pb);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1929,10 +2161,11 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             TestSlicingObjectsClientForward* f;
             [test useForward:&f];
             test(f);
+            breakCycles(f);
         }
         @catch(...)
         {
-            test(0);
+            test(NO);
         }
     }
     tprintf("ok\n");
@@ -1962,6 +2195,9 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
         test(p2.pi == 3);
         test([p2.ps isEqual:@"preserved"]);
         test(p2.pb == p2);
+
+        breakCycles(pd);
+        breakCycles(r);
     }
     @catch(ICEOperationNotExistException*)
     {
@@ -2009,6 +2245,9 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(p2.pi == 3);
             test([[[p2 pbs] objectAtIndex:0] isEqual:p2]);
         }
+
+        breakCycles(pcd);
+        breakCycles(r);
     }
     @catch(ICEOperationNotExistException*)
     {
@@ -2039,6 +2278,9 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(p2.pi == 3);
             test([p2.pbs objectAtIndex:0] == p2);
         }
+
+        breakCycles(pcd);
+        breakCycles(r);
     }
     @catch(ICEOperationNotExistException*)
     {
@@ -2091,6 +2333,9 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
             test(p3.pcd2 == p3.pi);
             test(p3.pcd3 == [p3.pbs objectAtIndex:10]);
         }
+
+        breakCycles(pcd);
+        breakCycles(r);
     }
     @catch(ICEOperationNotExistException*)
     {
@@ -2136,6 +2381,8 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                          response:^(TestSlicingObjectsClientPBase* o) { [cb responsePreserved1:o]; }
                         exception:^(ICEException* ex) { [cb exception:ex]; }];
         [cb check];
+
+        breakCycles(pd);
     }
 
     {
@@ -2176,6 +2423,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                             exception:^(ICEException* ex) { [cb exception:ex]; }];
         }
         [cb check];
+        breakCycles(pcd);
     }
 
     {
@@ -2201,6 +2449,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                             exception:^(ICEException* ex) { [cb exception:ex]; }];
         }
         [cb check];
+        breakCycles(pcd);
     }
 
     {
@@ -2241,6 +2490,7 @@ slicingObjectsAllTests(id<ICECommunicator> communicator)
                             exception:^(ICEException* ex) { [cb exception:ex]; }];
         }
         [cb check];
+        breakCycles(pcd);
     }
 
     tprintf("ok\n");
diff --git a/objective-c/test/Ice/slicing/objects/Server.m b/objective-c/test/Ice/slicing/objects/Server.m
index 395d044780d..da0c325be56 100644
--- a/objective-c/test/Ice/slicing/objects/Server.m
+++ b/objective-c/test/Ice/slicing/objects/Server.m
@@ -18,7 +18,7 @@ run(id<ICECommunicator> communicator)
     [properties setProperty:@"Ice.Warn.Dispatch" value:@"0"];
     [[communicator getProperties] setProperty:@"TestAdapter.Endpoints" value:@"default -p 12010"];
     id<ICEObjectAdapter> adapter = [communicator createObjectAdapter:@"TestAdapter"];
-    ICEObject* object = [TestSlicingObjectsServerI testIntf];
+    ICEObject* object = [TestSlicingObjectsServerI serverI];
     [adapter add:object identity:[ICEUtil stringToIdentity:@"Test"]];
     [adapter activate];
 
diff --git a/objective-c/test/Ice/slicing/objects/SlicingObjectsTestServer.ice b/objective-c/test/Ice/slicing/objects/SlicingObjectsTestServer.ice
index 286d46bc70f..58554b03b0a 100644
--- a/objective-c/test/Ice/slicing/objects/SlicingObjectsTestServer.ice
+++ b/objective-c/test/Ice/slicing/objects/SlicingObjectsTestServer.ice
@@ -201,6 +201,7 @@ class SBSUnknownDerived extends SBase
 class SUnknown
 {
     string su;
+    SUnknown cycle;
 }
 
 class D2 extends B
diff --git a/objective-c/test/Ice/slicing/objects/TestI.h b/objective-c/test/Ice/slicing/objects/TestI.h
index 2dd44b877ab..83316193331 100644
--- a/objective-c/test/Ice/slicing/objects/TestI.h
+++ b/objective-c/test/Ice/slicing/objects/TestI.h
@@ -12,6 +12,7 @@
 @interface TestSlicingObjectsServerI : TestSlicingObjectsServerTestIntf<TestSlicingObjectsServerTestIntf>
 {
 @private
-    TestSlicingObjectsServerPSUnknownException* ex_;
+    NSMutableArray* objects_;
 }
++(id) serverI;
 @end
diff --git a/objective-c/test/Ice/slicing/objects/TestI.m b/objective-c/test/Ice/slicing/objects/TestI.m
index 5e272ed7153..8b5a76e6dd3 100644
--- a/objective-c/test/Ice/slicing/objects/TestI.m
+++ b/objective-c/test/Ice/slicing/objects/TestI.m
@@ -11,7 +11,151 @@
 #import <slicing/objects/TestI.h>
 #import <TestCommon.h>
 
+static void breakCycles(id o)
+{
+    if([o isKindOfClass:[TestSlicingObjectsServerD1 class]])
+    {
+        TestSlicingObjectsServerD1* d1 = (TestSlicingObjectsServerD1*)o;
+        if(d1.pd1 != d1)
+        {
+            breakCycles(d1.pd1);
+        }
+        d1.pd1 = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerD2 class]])
+    {
+        TestSlicingObjectsServerD2* d2 = (TestSlicingObjectsServerD2*)o;
+        d2.pd2 = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerD4 class]])
+    {
+        TestSlicingObjectsServerD4* d4 = (TestSlicingObjectsServerD4*)o;
+        d4.p1 = nil;
+        d4.p2 = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerB class]])
+    {
+        TestSlicingObjectsServerB* b = (TestSlicingObjectsServerB*)o;
+        if(b.pb != nil)
+        {
+            b.pb.pb = nil;
+        }
+        b.pb = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerPreserved class]])
+    {
+        TestSlicingObjectsServerPreserved* p = (TestSlicingObjectsServerPreserved*)o;
+        [[p ice_getSlicedData] clear];
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerPDerived class]])
+    {
+        TestSlicingObjectsServerPDerived* p = (TestSlicingObjectsServerPDerived*)o;
+        p.pb = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerCompactPDerived class]])
+    {
+        TestSlicingObjectsServerPDerived* p = (TestSlicingObjectsServerPDerived*)o;
+        p.pb = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerPNode class]])
+    {
+        TestSlicingObjectsServerPNode* curr = o;
+        while(curr && o != curr.next)
+        {
+            TestSlicingObjectsServerPNode* next = curr.next;
+            curr.next = nil;
+            curr = next;
+        }
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerPSUnknown class]])
+    {
+        TestSlicingObjectsServerPSUnknown* p = (TestSlicingObjectsServerPSUnknown*)o;
+        breakCycles(p.graph);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerPSUnknown2 class]])
+    {
+        TestSlicingObjectsServerPSUnknown2* p = (TestSlicingObjectsServerPSUnknown2*)o;
+        breakCycles(p.pb);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerBaseException class]])
+    {
+        TestSlicingObjectsServerBaseException* e = (TestSlicingObjectsServerBaseException*)o;
+        breakCycles(e.pb);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerDerivedException class]])
+    {
+        TestSlicingObjectsServerDerivedException* e = (TestSlicingObjectsServerDerivedException*)o;
+        breakCycles(e.pd1);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerUnknownDerivedException class]])
+    {
+        TestSlicingObjectsServerUnknownDerivedException* e = (TestSlicingObjectsServerUnknownDerivedException*)o;
+        breakCycles(e.pd2);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerPSUnknownException class]])
+    {
+        TestSlicingObjectsServerPSUnknownException* e = (TestSlicingObjectsServerPSUnknownException*)o;
+        breakCycles(e.p);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerSS1 class]])
+    {
+        TestSlicingObjectsServerSS1* s = (TestSlicingObjectsServerSS1*)o;
+        breakCycles(s.s);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerSS2 class]])
+    {
+        TestSlicingObjectsServerSS2* s = (TestSlicingObjectsServerSS2*)o;
+        breakCycles(s.s);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerSS class]])
+    {
+        TestSlicingObjectsServerSS* s = (TestSlicingObjectsServerSS*)o;
+        breakCycles(s.c1);
+        breakCycles(s.c2);
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerForward class]])
+    {
+        TestSlicingObjectsServerForward* f = (TestSlicingObjectsServerForward*)o;
+        f.h = nil;
+    }
+    if([o isKindOfClass:[TestSlicingObjectsServerSUnknown class]])
+    {
+        TestSlicingObjectsServerSUnknown* u = (TestSlicingObjectsServerSUnknown*)o;
+        u.cycle = nil;
+    }
+    if([o isKindOfClass:[NSArray class]])
+    {
+        for(id e in o)
+        {
+            breakCycles(e);
+        }
+    }
+    if([o isKindOfClass:[NSDictionary class]])
+    {
+        for(id e in [o allValues])
+        {
+            breakCycles(e);
+        }
+    }
+}
+
 @implementation TestSlicingObjectsServerI
++(id) serverI
+{
+    TestSlicingObjectsServerI* impl = [[TestSlicingObjectsServerI alloc] init];
+    impl->objects_ = [NSMutableArray array];
+    return ICE_AUTORELEASE(impl);
+}
+-(void) dealloc
+{
+    for(id o in objects_)
+    {
+        breakCycles(o);
+    }
+#if !__has_feature(objc_arc)
+    [super dealloc];
+#endif
+}
 -(ICEObject*) SBaseAsObject:(ICECurrent*)current
 {
     return [TestSlicingObjectsServerSBase sBase:@"SBase.sb"];
@@ -48,10 +192,13 @@
 
 -(ICEObject*) SUnknownAsObject:(ICECurrent*)current
 {
-    return [TestSlicingObjectsServerSUnknown sUnknown:@"SUnknown.su"];
+    TestSlicingObjectsServerSUnknown* s = [TestSlicingObjectsServerSUnknown sUnknown:@"SUnknown.su" cycle:nil];
+    s.cycle = s;
+    [objects_ addObject:s];
+    return s;
 }
 
--(void) checkSUnknown:(ICEObject*) object current:(ICECurrent*)current
+-(void) checkSUnknown:(ICEObject*)object current:(ICECurrent*)current
 {
     if([current encoding] == ICEEncoding_1_0)
     {
@@ -63,6 +210,7 @@
         TestSlicingObjectsServerSUnknown* su = (TestSlicingObjectsServerSUnknown*)object;
         test([[su su] isEqual:@"SUnknown.su"]);
     }
+    [objects_ addObject:object];
 }
 
 -(TestSlicingObjectsServerB*) oneElementCycle:(ICECurrent*)current
@@ -70,6 +218,7 @@
     TestSlicingObjectsServerB* b1 = [TestSlicingObjectsServerB b];
     b1.sb = @"B1.sb";
     b1.pb = b1;
+    [objects_ addObject:b1];
     return b1;
 }
 -(TestSlicingObjectsServerB*) twoElementCycle:(ICECurrent*)current
@@ -80,6 +229,7 @@
     b2.sb = @"B2.sb";
     b2.pb = b1;
     b1.pb = b2;
+    [objects_ addObject:b1];
     return b1;
 }
 -(TestSlicingObjectsServerB*) D1AsB:(ICECurrent*)current
@@ -95,6 +245,8 @@
     d2.pd2 = d1;
     d1.pb = d2;
     d1.pd1 = d2;
+
+    [objects_ addObject:d1];
     return d1;
 }
 -(TestSlicingObjectsServerD1*) D1AsD1:(ICECurrent*)current
@@ -109,6 +261,8 @@
     d2.pd2 = d1;
     d1.pb = d2;
     d1.pd1 = d2;
+
+    [objects_ addObject:d1];
     return d1;
 }
 -(TestSlicingObjectsServerB*) D2AsB:(ICECurrent*)current
@@ -123,6 +277,8 @@
     d1.pd1 = d2;
     d2.pb = d1;
     d2.pd2 = d1;
+
+    [objects_ addObject:d2];
     return d2;
 }
 -(void) paramTest1:(TestSlicingObjectsServerB**)p1 p2:(TestSlicingObjectsServerB**)p2 current:(ICECurrent*)current
@@ -139,6 +295,9 @@
     d1.pd1 = d2;
     *p1 = d1;
     *p2 = d2;
+
+    [objects_ addObject:d1];
+    [objects_ addObject:d2];
 }
 -(void) paramTest2:(TestSlicingObjectsServerB**)p1 p1:(TestSlicingObjectsServerB**)p2 current:(ICECurrent*)current
 {
@@ -172,6 +331,9 @@
     d3.pd1 = 0;
     d4.pd2 = d3;
 
+    [objects_ addObject:d2];
+    [objects_ addObject:d3];
+    [objects_ addObject:d4];
     return d3;
 }
 -(TestSlicingObjectsServerB*) paramTest4:(TestSlicingObjectsServerB**)p1 current:(ICECurrent*)current
@@ -184,6 +346,7 @@
     d4.p2 = [TestSlicingObjectsServerB b];
     d4.p2.sb = @"B.sb (2)";
     *p1 = d4;
+    [objects_ addObject:d4];
     return d4.p2;
 }
 -(TestSlicingObjectsServerB*) returnTest1:(TestSlicingObjectsServerB**)p1 p2:(TestSlicingObjectsServerB**)p2 current:(ICECurrent*)current
@@ -198,6 +361,8 @@
 }
 -(TestSlicingObjectsServerB*) returnTest3:(TestSlicingObjectsServerB*)p1 p2:(TestSlicingObjectsServerB*)p2 current:(ICECurrent*)current
 {
+    [objects_ addObject:p1];
+    [objects_ addObject:p2];
     return p1;
 }
 -(TestSlicingObjectsServerSS*) sequenceTest:(TestSlicingObjectsServerSS1*)p1 p2:(TestSlicingObjectsServerSS2*)p2 current:(ICECurrent*)current
@@ -205,6 +370,9 @@
     TestSlicingObjectsServerSS* ss = [TestSlicingObjectsServerSS ss];
     ss.c1 = p1;
     ss.c2 = p2;
+    [objects_ addObject:p1];
+    [objects_ addObject:p2];
+    [objects_ addObject:ss];
     return ss;
 }
 -(TestSlicingObjectsServerBDict*) dictionaryTest:(TestSlicingObjectsServerMutableBDict*)bin
@@ -232,12 +400,15 @@
         d1.pd1 = d1;
         [r setObject:d1 forKey:[NSNumber numberWithInt:(i * 20)]];
     }
+    [objects_ addObject:*bout];
+    [objects_ addObject:r];
     return r;
 }
 
 -(TestSlicingObjectsServerPBase*) exchangePBase:(TestSlicingObjectsServerPBase*)pb
                                         current:(ICECurrent*)current
 {
+    [objects_ addObject:pb];
     return pb;
 }
 
@@ -295,6 +466,7 @@
     r.graph.next = [TestSlicingObjectsServerPNode alloc];
     r.graph.next.next = [TestSlicingObjectsServerPNode alloc];
     r.graph.next.next.next = r.graph;
+    [objects_ addObject:r];
     return r;
 }
 
@@ -318,6 +490,7 @@
         test(pu.graph.next.next.next == pu.graph);
         pu.graph.next.next.next = nil; // Break the cycle.
     }
+    [objects_ addObject:p];
 }
 
 -(TestSlicingObjectsServerPreserved*) PBSUnknown2AsPreservedWithGraph:(ICECurrent*)current
@@ -326,10 +499,11 @@
     r.pi = 5;
     r.ps = @"preserved";
     r.pb = r;
+    [objects_ addObject:r];
     return r;
 }
 
--(void) checkPBSUnknown2WithGraph:(TestSlicingObjectsServerPreserved*) p current:(ICECurrent*)current
+-(void) checkPBSUnknown2WithGraph:(TestSlicingObjectsServerPreserved*)p current:(ICECurrent*)current
 {
     if([current.encoding isEqual:ICEEncoding_1_0])
     {
@@ -344,12 +518,14 @@
         test(pu.pi == 5);
         test([pu.ps isEqual:@"preserved"]);
         test(pu.pb == pu);
-        pu.pb = 0; // Break the cycle.
+        pu.pb = nil; // Break the cycle.
     }
+    [objects_ addObject:p];
 }
 
 -(TestSlicingObjectsServerPNode*) exchangePNode:(TestSlicingObjectsServerPNode*)pn current:(ICECurrent*)current
 {
+    [objects_ addObject:pn];
     return pn;
 }
 
@@ -360,6 +536,7 @@
     be.pb = [TestSlicingObjectsServerB b];
     be.pb.sb = @"sb";
     be.pb.pb = be.pb;
+    [objects_ addObject:be];
     @throw be;
 }
 -(void) throwDerivedAsBase:(ICECurrent*)current
@@ -375,6 +552,7 @@
     de.pd1.pb = de.pd1;
     de.pd1.sd1 = @"sd2";
     de.pd1.pd1 = de.pd1;
+    [objects_ addObject:de];
     @throw de;
 }
 -(void) throwDerivedAsDerived:(ICECurrent*)current
@@ -390,6 +568,7 @@
     de.pd1.pb = de.pd1;
     de.pd1.sd1 = @"sd2";
     de.pd1.pd1 = de.pd1;
+    [objects_ addObject:de];
     @throw de;
 }
 -(void) throwUnknownDerivedAsBase:(ICECurrent*)current
@@ -405,6 +584,7 @@
     ude.pb = d2;
     ude.sude = @"sude";
     ude.pd2 = d2;
+    [objects_ addObject:ude];
     @throw ude;
 }
 -(void) throwPreservedException:(ICECurrent*)current
@@ -414,12 +594,7 @@
     ue.p.pi = 5;
     ue.p.ps = @"preserved";
     ue.p.pb = ue.p;
-    if(ex_ != nil)
-    {
-        ex_.p.pb = nil;
-        ICE_RELEASE(ex_);
-    }
-    ex_ = ICE_RETAIN(ue);
+    [objects_ addObject:ue];
     @throw ue;
 }
 -(void) useForward:(TestSlicingObjectsServerForward**)f current:(ICECurrent*)current
@@ -427,14 +602,10 @@
     *f = [TestSlicingObjectsServerForward forward];
     (*f).h = [TestSlicingObjectsServerHidden hidden];
     (*f).h.f = *f;
+    [objects_ addObject:*f];
 }
 -(void) shutdown:(ICECurrent*)current
 {
-    if(ex_ != nil)
-    {
-        ex_.p.pb = nil;
-        ICE_RELEASE(ex_);
-    }
     [[current.adapter getCommunicator] shutdown];
 }
 @end