diff --git a/Src/IdiomsUnitTest/EqualityComparerAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerAssertionTest.cs
new file mode 100644
index 000000000..f54a125b8
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerAssertionTest.cs
@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IIdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedNullEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedNullEqualityComparer)));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedSelfEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedSelfEqualityComparer)));
+        }
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return true;
+
+                if (ReferenceEquals(x, null))
+                    return false;
+
+                if (ReferenceEquals(y, null))
+                    return false;
+
+                if (x.GetType() != y.GetType())
+                    return false;
+
+                return x.Property == y.Property;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedNullEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (x == null && y == null)
+                    return false;
+
+                if (x == null ^ y == null)
+                    return true;
+
+                return false;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+
+        private class IllBehavedSelfEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return false;
+
+                return true;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/IdiomsUnitTest/EqualityComparerEqualsNullAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerEqualsNullAssertionTest.cs
new file mode 100644
index 000000000..9c395dd98
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerEqualsNullAssertionTest.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using AutoFixture.Kernel;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerEqualsNullAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerEqualsNullAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ComposerIsCorrect()
+        {
+            // Arrange
+            var expectedComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullAssertion(expectedComposer);
+            // Act
+            ISpecimenBuilder result = sut.Builder;
+            // Assert
+            Assert.Equal(expectedComposer, result);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerEqualsNullAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedEqualityComparer)));
+        }
+
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return true;
+
+                if (ReferenceEquals(x, null))
+                    return false;
+
+                if (ReferenceEquals(y, null))
+                    return false;
+
+                if (x.GetType() != y.GetType())
+                    return false;
+
+                return x.Property == y.Property;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (x == null ^ y == null)
+                    return true;
+
+                return false;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/IdiomsUnitTest/EqualityComparerEqualsNullNullAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerEqualsNullNullAssertionTest.cs
new file mode 100644
index 000000000..e35267bc6
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerEqualsNullNullAssertionTest.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using AutoFixture.Kernel;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerEqualsNullNullAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerEqualsNullNullAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ComposerIsCorrect()
+        {
+            // Arrange
+            var expectedComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullNullAssertion(expectedComposer);
+            // Act
+            ISpecimenBuilder result = sut.Builder;
+            // Assert
+            Assert.Equal(expectedComposer, result);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerEqualsNullNullAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsNullNullAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedEqualityComparer)));
+        }
+
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return true;
+
+                if (ReferenceEquals(x, null))
+                    return false;
+
+                if (ReferenceEquals(y, null))
+                    return false;
+
+                if (x.GetType() != y.GetType())
+                    return false;
+
+                return x.Property == y.Property;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (x == null && y == null)
+                    return false;
+
+                return true;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/IdiomsUnitTest/EqualityComparerEqualsSelfAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerEqualsSelfAssertionTest.cs
new file mode 100644
index 000000000..8730c8ab9
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerEqualsSelfAssertionTest.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using AutoFixture.Kernel;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerEqualsSelfAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerEqualsSelfAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ComposerIsCorrect()
+        {
+            // Arrange
+            var expectedComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSelfAssertion(expectedComposer);
+            // Act
+            ISpecimenBuilder result = sut.Builder;
+            // Assert
+            Assert.Equal(expectedComposer, result);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerEqualsSelfAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSelfAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSelfAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSelfAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSelfAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedEqualityComparer)));
+        }
+
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return true;
+
+                if (ReferenceEquals(x, null))
+                    return false;
+
+                if (ReferenceEquals(y, null))
+                    return false;
+
+                if (x.GetType() != y.GetType())
+                    return false;
+
+                return x.Property == y.Property;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return false;
+
+                return true;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/IdiomsUnitTest/EqualityComparerEqualsSymmetricAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerEqualsSymmetricAssertionTest.cs
new file mode 100644
index 000000000..51a9575fb
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerEqualsSymmetricAssertionTest.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using AutoFixture.Kernel;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerEqualsSymmetricAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerEqualsSymmetricAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ComposerIsCorrect()
+        {
+            // Arrange
+            var expectedComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSymmetricAssertion(expectedComposer);
+            // Act
+            ISpecimenBuilder result = sut.Builder;
+            // Assert
+            Assert.Equal(expectedComposer, result);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerEqualsSymmetricAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSymmetricAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSymmetricAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSymmetricAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsSymmetricAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedEqualityComparer)));
+        }
+
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return true;
+
+                if (ReferenceEquals(x, null))
+                    return false;
+
+                if (ReferenceEquals(y, null))
+                    return false;
+
+                if (x.GetType() != y.GetType())
+                    return false;
+
+                return x.Property == y.Property;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            private static bool flag = false;
+
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                flag = !flag;
+
+                return flag;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/IdiomsUnitTest/EqualityComparerEqualsTransitiveAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerEqualsTransitiveAssertionTest.cs
new file mode 100644
index 000000000..fdc478ef2
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerEqualsTransitiveAssertionTest.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using AutoFixture.Kernel;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerEqualsTransitiveAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerEqualsTransitiveAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ComposerIsCorrect()
+        {
+            // Arrange
+            var expectedComposer = new Fixture();
+            var sut = new EqualityComparerEqualsTransitiveAssertion(expectedComposer);
+            // Act
+            ISpecimenBuilder result = sut.Builder;
+            // Assert
+            Assert.Equal(expectedComposer, result);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerEqualsTransitiveAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsTransitiveAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsTransitiveAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsTransitiveAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerEqualsTransitiveAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedEqualityComparer)));
+        }
+
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                if (ReferenceEquals(x, y))
+                    return true;
+
+                if (ReferenceEquals(x, null))
+                    return false;
+
+                if (ReferenceEquals(y, null))
+                    return false;
+
+                if (x.GetType() != y.GetType())
+                    return false;
+
+                return x.Property == y.Property;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            private static bool flag = false;
+
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                flag = !flag;
+
+                return flag;
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                throw new Exception();
+            }
+        }
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/IdiomsUnitTest/EqualityComparerGetHashCodeAssertionTest.cs b/Src/IdiomsUnitTest/EqualityComparerGetHashCodeAssertionTest.cs
new file mode 100644
index 000000000..192d5bdeb
--- /dev/null
+++ b/Src/IdiomsUnitTest/EqualityComparerGetHashCodeAssertionTest.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using AutoFixture.Idioms;
+using AutoFixture.Kernel;
+using TestTypeFoundation;
+using Xunit;
+
+namespace AutoFixture.IdiomsUnitTest
+{
+    public class EqualityComparerGetHashCodeAssertionTest
+    {
+        [Fact]
+        public void SutIsIdiomaticAssertion()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            // Act
+            var sut = new EqualityComparerGetHashCodeAssertion(dummyComposer);
+            // Assert
+            Assert.IsAssignableFrom<IdiomaticAssertion>(sut);
+        }
+
+        [Fact]
+        public void ComposerIsCorrect()
+        {
+            // Arrange
+            var expectedComposer = new Fixture();
+            var sut = new EqualityComparerGetHashCodeAssertion(expectedComposer);
+            // Act
+            ISpecimenBuilder result = sut.Builder;
+            // Assert
+            Assert.Equal(expectedComposer, result);
+        }
+
+        [Fact]
+        public void ConstructWithNullComposerThrows()
+        {
+            // Arrange
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                new EqualityComparerGetHashCodeAssertion(null));
+        }
+
+        [Fact]
+        public void VerifyNullMethodThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerGetHashCodeAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() =>
+                sut.Verify((MethodInfo)null));
+        }
+
+        [Fact]
+        public void VerifyNonEqualityComparerDoesNothing()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerGetHashCodeAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(NonEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyWellBehavedEqualityComparerDoesNotThrow()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerGetHashCodeAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Null(Record.Exception(() =>
+                sut.Verify(typeof(WellBehavedEqualityComparer))));
+        }
+
+        [Fact]
+        public void VerifyIllBehavedEqualityComparerThrows()
+        {
+            // Arrange
+            var dummyComposer = new Fixture();
+            var sut = new EqualityComparerGetHashCodeAssertion(dummyComposer);
+            // Act & Assert
+            Assert.Throws<EqualityComparerImplementationException>(() =>
+                sut.Verify(typeof(IllBehavedEqualityComparer)));
+        }
+
+#pragma warning disable 659
+        private class WellBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                throw new Exception();
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return obj.Property;
+            }
+        }
+
+        private class IllBehavedEqualityComparer : IEqualityComparer<PropertyHolder<int>>
+        {
+            private static readonly Random HashCodeGenerator = new Random();
+
+            public bool Equals(PropertyHolder<int> x, PropertyHolder<int> y)
+            {
+                throw new Exception();
+            }
+
+            public int GetHashCode(PropertyHolder<int> obj)
+            {
+                return HashCodeGenerator.Next();
+            }
+        }
+#pragma warning restore 659
+
+        private class NonEqualityComparer
+        {
+        }
+    }
+}
\ No newline at end of file