diff --git a/TryAtSoftware.Equalizer.Core.Tests/CollectionEqualizationProfileTests.cs b/TryAtSoftware.Equalizer.Core.Tests/CollectionEqualizationProfileTests.cs
index 67304fe..9e10e31 100644
--- a/TryAtSoftware.Equalizer.Core.Tests/CollectionEqualizationProfileTests.cs
+++ b/TryAtSoftware.Equalizer.Core.Tests/CollectionEqualizationProfileTests.cs
@@ -41,6 +41,36 @@ public void CollectionsWithDifferentLengthShouldBeEqualizedUnsuccessfully(int fi
         Assert.False(equalizationResult.IsSuccessful);
     }
 
+    [Fact]
+    public void CollectionsWithFewerExpectedElementsShouldShowCorrectMessage()
+    {
+        var profile = InstantiateProfile();
+        var equalizationOptions = TestsCompanion.MockEqualizationOptions();
+
+        var expected = new[] { 1, 2 };
+        var actual = new[] { 1, 2, 3 };
+        var equalizationResult = profile.Equalize(expected, actual, equalizationOptions);
+
+        Assert.False(equalizationResult.IsSuccessful);
+        Assert.Contains("Expected count: 2", equalizationResult.Message);
+        Assert.Contains("Actual count: > 2", equalizationResult.Message);
+    }
+
+    [Fact]
+    public void CollectionsWithMoreExpectedElementsShouldShowCorrectMessage()
+    {
+        var profile = InstantiateProfile();
+        var equalizationOptions = TestsCompanion.MockEqualizationOptions();
+
+        var expected = new[] { 1, 2, 3 };
+        var actual = new[] { 1, 2 };
+        var equalizationResult = profile.Equalize(expected, actual, equalizationOptions);
+
+        Assert.False(equalizationResult.IsSuccessful);
+        Assert.Contains("Expected count: > 2", equalizationResult.Message);
+        Assert.Contains("Actual count: 2", equalizationResult.Message);
+    }
+
     [Fact]
     public void CollectionsShouldBeEqualizedSuccessfully()
     {
diff --git a/TryAtSoftware.Equalizer.Core.Tests/DictionaryEqualizationProfileTests.cs b/TryAtSoftware.Equalizer.Core.Tests/DictionaryEqualizationProfileTests.cs
index 1895481..ecfacda 100644
--- a/TryAtSoftware.Equalizer.Core.Tests/DictionaryEqualizationProfileTests.cs
+++ b/TryAtSoftware.Equalizer.Core.Tests/DictionaryEqualizationProfileTests.cs
@@ -94,6 +94,48 @@ public void DictionariesWithDifferentKeysShouldBeEqualizedUnsuccessfully()
         equalizer.AssertInequality(firstDictionary, secondDictionary);
     }
 
+    [Fact]
+    public void DictionariesWithFewerExpectedElementsShouldShowCorrectMessage()
+    {
+        var profile = InstantiateProfile();
+        var equalizationOptions = TestsCompanion.MockEqualizationOptions((a, b) =>
+        {
+            // Make count comparisons fail when counts are different
+            if (a is int && b is int && (int)a != (int)b)
+                return new UnsuccessfulEqualizationResult("Counts differ");
+            return new SuccessfulEqualizationResult();
+        });
+
+        var expected = new Dictionary<int, int> { { 1, 1 }, { 2, 2 } };
+        var actual = new Dictionary<int, int> { { 1, 1 }, { 2, 2 }, { 3, 3 } };
+        var equalizationResult = profile.Equalize(expected, actual, equalizationOptions);
+
+        Assert.False(equalizationResult.IsSuccessful);
+        Assert.Contains("Expected count: 2", equalizationResult.Message);
+        Assert.Contains("Actual count: > 2", equalizationResult.Message);
+    }
+
+    [Fact]
+    public void DictionariesWithMoreExpectedElementsShouldShowCorrectMessage()
+    {
+        var profile = InstantiateProfile();
+        var equalizationOptions = TestsCompanion.MockEqualizationOptions((a, b) =>
+        {
+            // Make count comparisons fail when counts are different
+            if (a is int && b is int && (int)a != (int)b)
+                return new UnsuccessfulEqualizationResult("Counts differ");
+            return new SuccessfulEqualizationResult();
+        });
+
+        var expected = new Dictionary<int, int> { { 1, 1 }, { 2, 2 }, { 3, 3 } };
+        var actual = new Dictionary<int, int> { { 1, 1 }, { 2, 2 } };
+        var equalizationResult = profile.Equalize(expected, actual, equalizationOptions);
+
+        Assert.False(equalizationResult.IsSuccessful);
+        Assert.Contains("Expected count: > 2", equalizationResult.Message);
+        Assert.Contains("Actual count: 2", equalizationResult.Message);
+    }
+
     private static IEqualizer InstantiateEqualizer() => new Equalizer();
     
     private static DictionaryEqualizationProfile InstantiateProfile() => new ();
diff --git a/TryAtSoftware.Equalizer.Core/Profiles/CollectionEqualizationProfile.cs b/TryAtSoftware.Equalizer.Core/Profiles/CollectionEqualizationProfile.cs
index fa6aa65..b9d9714 100644
--- a/TryAtSoftware.Equalizer.Core/Profiles/CollectionEqualizationProfile.cs
+++ b/TryAtSoftware.Equalizer.Core/Profiles/CollectionEqualizationProfile.cs
@@ -25,7 +25,14 @@ protected override IEqualizationResult Equalize(IEnumerable expected, IEnumerabl
             var hasMoreActual = actualEnumerator.MoveNext();
 
             if (!hasMoreExpected && !hasMoreActual) canContinue = false;
-            else if (hasMoreExpected != hasMoreActual) return new UnsuccessfulEqualizationResult(this.UnsuccessfulEqualization(expected, actual, "Counts do not match"));
+            else if (hasMoreExpected != hasMoreActual)
+            {
+                var currentCount = iteratedValues.Count;
+                var countMessage = hasMoreExpected
+                    ? $"Expected count: > {currentCount}; Actual count: {currentCount}"
+                    : $"Expected count: {currentCount}; Actual count: > {currentCount}";
+                return new UnsuccessfulEqualizationResult(this.UnsuccessfulEqualization(expected, actual, countMessage));
+            }
             else
                 iteratedValues.Add((expectedEnumerator.Current, actualEnumerator.Current));
         }
diff --git a/TryAtSoftware.Equalizer.Core/Profiles/DictionaryEqualizationProfile.cs b/TryAtSoftware.Equalizer.Core/Profiles/DictionaryEqualizationProfile.cs
index f670ae6..e2e907e 100644
--- a/TryAtSoftware.Equalizer.Core/Profiles/DictionaryEqualizationProfile.cs
+++ b/TryAtSoftware.Equalizer.Core/Profiles/DictionaryEqualizationProfile.cs
@@ -15,7 +15,10 @@ protected override IEqualizationResult Equalize(IDictionary expected, IDictionar
         var countEqualizationResult = options.Equalize(expected.Count, actual.Count);
         if (!countEqualizationResult.IsSuccessful)
         {
-            var errorMessage = this.UnsuccessfulEqualization(expected, actual, "Counts do not match.");
+            var countMessage = expected.Count < actual.Count
+                ? $"Expected count: {expected.Count}; Actual count: > {expected.Count}"
+                : $"Expected count: > {actual.Count}; Actual count: {actual.Count}";
+            var errorMessage = this.UnsuccessfulEqualization(expected, actual, countMessage);
             return new UnsuccessfulEqualizationResult(errorMessage.WithInner(countEqualizationResult));
         }