Index: Core/Common/test/Core.Common.Data.TestUtil.Test/CloneAssertTest.cs
===================================================================
diff -u -r0c4d52e7ae76886aaca7096aee8871ef9cd86b33 -rd4a0cbf0e0833ca2bbf3812d8b6025ae5bd86be3
--- Core/Common/test/Core.Common.Data.TestUtil.Test/CloneAssertTest.cs	(.../CloneAssertTest.cs)	(revision 0c4d52e7ae76886aaca7096aee8871ef9cd86b33)
+++ Core/Common/test/Core.Common.Data.TestUtil.Test/CloneAssertTest.cs	(.../CloneAssertTest.cs)	(revision d4a0cbf0e0833ca2bbf3812d8b6025ae5bd86be3)
@@ -20,6 +20,8 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 
 namespace Core.Common.Data.TestUtil.Test
@@ -28,7 +30,7 @@
     public class CloneAssertTest
     {
         [Test]
-        public void AreClones_TypeSpecificAssertsNull_ThrowsArgumentNullException()
+        public void AreClones_ObjectsWithTypeSpecificAssertsNull_ThrowsArgumentNullException()
         {
             // Call
             TestDelegate test = () => CloneAssert.AreClones(new object(), new object(), null);
@@ -38,7 +40,7 @@
         }
 
         [Test]
-        public void AreClones_OriginalAndCloneBothNull_DoesNotThrow()
+        public void AreClones_OriginalObjectAndClonedObjectBothNull_DoesNotThrow()
         {
             // Call
             TestDelegate test = () => CloneAssert.AreClones<object>(null, null, (original, clone) => {});
@@ -48,7 +50,7 @@
         }
 
         [Test]
-        public void AreClones_OriginalNull_ThrowsAssertionException()
+        public void AreClones_OriginalObjectNull_ThrowsAssertionException()
         {
             // Call
             TestDelegate test = () => CloneAssert.AreClones<object>(null, new object(), (original, clone) => {});
@@ -58,7 +60,7 @@
         }
 
         [Test]
-        public void AreClones_CloneNull_ThrowsAssertionException()
+        public void AreClones_ClonedObjectNull_ThrowsAssertionException()
         {
             // Call
             TestDelegate test = () => CloneAssert.AreClones(new object(), null, (original, clone) => {});
@@ -68,7 +70,7 @@
         }
 
         [Test]
-        public void AreClones_CloneOfOtherDataType_ThrowsAssertionException()
+        public void AreClones_ClonedObjectOfOtherDataType_ThrowsAssertionException()
         {
             // Call
             TestDelegate test = () => CloneAssert.AreClones(1.0, 1, (original, clone) => {});
@@ -78,7 +80,7 @@
         }
 
         [Test]
-        public void AreClones_OriginalAndCloneAreSame_ThrowsAssertionException()
+        public void AreClones_OriginalObjectAndClonedObjectAreSame_ThrowsAssertionException()
         {
             // Setup
             var o = new object();
@@ -91,7 +93,7 @@
         }
 
         [Test]
-        public void AreClones_TypeSpecificAsserts_TypeSpecificAssertsCalled()
+        public void AreClones_ObjectsWithTypeSpecificAsserts_TypeSpecificAssertsCalled()
         {
             // Setup
             var counter = 0;
@@ -102,5 +104,89 @@
             // Assert
             Assert.AreEqual(1, counter);
         }
+
+        [Test]
+        public void AreClones_EnumerationsWithTypeSpecificAssertsNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => CloneAssert.AreClones(Enumerable.Empty<object>(), Enumerable.Empty<object>(), null);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(test);
+        }
+
+        [Test]
+        public void AreClones_OriginalEnumerationAndClonedEnumerationBothNull_DoesNotThrow()
+        {
+            // Call
+            TestDelegate test = () => CloneAssert.AreClones<IEnumerable<object>>(null, null, (original, clone) => {});
+
+            // Assert
+            Assert.DoesNotThrow(test);
+        }
+
+        [Test]
+        public void AreClones_OriginalEnumerationNull_ThrowsAssertionException()
+        {
+            // Call
+            TestDelegate test = () => CloneAssert.AreClones<IEnumerable<object>>(null, Enumerable.Empty<object>(), (original, clone) => {});
+
+            // Assert
+            Assert.Throws<AssertionException>(test);
+        }
+
+        [Test]
+        public void AreClones_ClonedEnumerationNull_ThrowsAssertionException()
+        {
+            // Call
+            TestDelegate test = () => CloneAssert.AreClones(Enumerable.Empty<object>(), null, (original, clone) => {});
+
+            // Assert
+            Assert.Throws<AssertionException>(test);
+        }
+
+        [Test]
+        public void AreClones_ClonedEnumerationOfOtherDataType_ThrowsAssertionException()
+        {
+            // Call
+            TestDelegate test = () => CloneAssert.AreClones<int>(Enumerable.Empty<int>(), Enumerable.Empty<double>(), (original, clone) => {});
+
+            // Assert
+            Assert.Throws<AssertionException>(test);
+        }
+
+        [Test]
+        public void AreClones_OriginalEnumerationAndClonedEnumerationAreSame_ThrowsAssertionException()
+        {
+            // Setup
+            IEnumerable<object> o = Enumerable.Empty<object>();
+
+            // Call
+            TestDelegate test = () => CloneAssert.AreClones(o, o, (original, clone) => {});
+
+            // Assert
+            Assert.Throws<AssertionException>(test);
+        }
+
+        [Test]
+        public void AreClones_ObjectsWithTypeSpecificAsserts_TypeSpecificAssertsCalledForEachElement()
+        {
+            // Setup
+            var counter = 0;
+
+            // Call
+            CloneAssert.AreClones<object>(new[]
+            {
+                new object(),
+                new object()
+            }, new[]
+            {
+                new object(),
+                new object()
+            }, (original, clone) => counter++);
+
+            // Assert
+            Assert.AreEqual(2, counter);
+        }
     }
 }
\ No newline at end of file