Order sensitive comparison should display missing rows if there are m…

…ore expected rows in the table than were returned (#1098)

* Add test showing failure case in sensitive comparison.

* Note missing items in order-sensitive compare when less items in set than table.

* Refactor to only generate absent items once.

"Results are present but there should be no results" is a subcondition
of "extra results exist".

TechTalk.SpecFlow/Assist/SetComparer.cs

@@ -25,24 +25,29 @@ private SafetyTableDiffExceptionBuilder<T> BuildTheTableDiffExceptionBuilder()
             return makeSureTheFormattingWorkAboveDoesNotResultInABadException;
         }
 
+        private IEnumerable<int> GetExpectedItemsNotFoundInTheData(IEnumerable<T> set, bool sequentialEquality)
+        {
+            var getListOfExpectedItemsThatCouldNotBeFound =
+                sequentialEquality
+                    ? new Func<IEnumerable<T>, IEnumerable<int>>(GetListOfExpectedItemsThatCouldNotBeFoundOrderSensitive)
+                    : new Func<IEnumerable<T>, IEnumerable<int>>(GetListOfExpectedItemsThatCouldNotBeFoundOrderInsensitive);
+
+            var expectedItemsNotFoundInTheData = getListOfExpectedItemsThatCouldNotBeFound(set);
+            return expectedItemsNotFoundInTheData;
+        }
+
         public void CompareToSet(IEnumerable<T> set, bool sequentialEquality)
         {
             AssertThatAllColumnsInTheTableMatchToPropertiesOnTheType();
 
             if (ThereAreNoResultsAndNoExpectedResults(set))
                 return;
 
-            var getListOfExpectedItemsThatCouldNotBeFound = 
-                sequentialEquality ? 
-                new Func<IEnumerable<T>, IEnumerable<int>>(GetListOfExpectedItemsThatCouldNotBeFoundOrderSensitive) :
-                new Func<IEnumerable<T>, IEnumerable<int>>(GetListOfExpectedItemsThatCouldNotBeFoundOrderInsensitive);
-
-            if (ThereAreResultsWhenThereShouldBeNone(set))
-                ThrowAnExpectedNoResultsError(set, getListOfExpectedItemsThatCouldNotBeFound(set));
+            var expectedItemsNotFoundInTheData = GetExpectedItemsNotFoundInTheData(set, sequentialEquality);
 
-            AssertThatTheItemsMatchTheExpectedResults(set, getListOfExpectedItemsThatCouldNotBeFound);
+            AssertThatTheItemsMatchTheExpectedResults(set, expectedItemsNotFoundInTheData);
 
-            AssertThatNoExtraRowsExist(set, getListOfExpectedItemsThatCouldNotBeFound(set));
+            AssertThatNoExtraRowsExist(set, expectedItemsNotFoundInTheData);
         }
 
         private void AssertThatNoExtraRowsExist(IEnumerable<T> set, IEnumerable<int> listOfMissingItems)
@@ -52,25 +57,13 @@ private void AssertThatNoExtraRowsExist(IEnumerable<T> set, IEnumerable<int> lis
             ThrowAnErrorDetailingWhichItemsAreMissing(listOfMissingItems);
         }
 
-        private void ThrowAnExpectedNoResultsError(IEnumerable<T> set, IEnumerable<int> listOfMissingItems)
-        {
-            ThrowAnErrorDetailingWhichItemsAreMissing(listOfMissingItems);
-        }
-
-        private bool ThereAreResultsWhenThereShouldBeNone(IEnumerable<T> set)
-        {
-            return set.Any() && !table.Rows.Any();
-        }
-
         private bool ThereAreNoResultsAndNoExpectedResults(IEnumerable<T> set)
         {
             return !set.Any() && !table.Rows.Any();
         }
 
-        private void AssertThatTheItemsMatchTheExpectedResults(IEnumerable<T> set, Func<IEnumerable<T>, IEnumerable<int>> getListOfExpectedItemsThatCouldNotBeFound)
+        private void AssertThatTheItemsMatchTheExpectedResults(IEnumerable<T> set, IEnumerable<int> listOfMissingItems)
         {
-            var listOfMissingItems = getListOfExpectedItemsThatCouldNotBeFound(set);
-
             if (ExpectedItemsCouldNotBeFound(listOfMissingItems))
                 ThrowAnErrorDetailingWhichItemsAreMissing(listOfMissingItems);
         }
@@ -119,6 +112,15 @@ private IEnumerable<int> GetListOfExpectedItemsThatCouldNotBeFoundOrderSensitive
                 actualItems.Skip(table.RowCount).Select(i => new TableDifferenceItem<T>(i)))
                 .ToList();
 
+            var extraTableItems = table.Rows.Count() - actualItems.Count;
+            if (extraTableItems > 0)
+            {
+                for (var index = actualItems.Count; index < table.Rows.Count(); index++)
+                {
+                    listOfMissingItems.Add(index + 1);
+                }
+            }
+
             return listOfMissingItems;
         }
 

Tests/TechTalk.SpecFlow.RuntimeTests/AssistTests/SetComparisonExtensionMethods_MessageTests.cs

@@ -144,6 +144,22 @@ public void Returns_a_descriptive_error_when_three_results_exist_when_one_expect
 ".AgnosticLineBreak());
         }
 
+        [Test]
+        public void Returns_a_descriptive_error_when_no_results_exist_when_one_expected()
+        {
+            var table = new Table("StringProperty");
+            table.AddRow("orange");
+
+            var items = new SetComparisonTestObject[] { };
+
+            var exception = GetTheExceptionThrowByComparingThese(table, items);
+
+            exception.Message.AgnosticLineBreak().Should().Be(@"
+  | StringProperty |
+- | orange         |
+".AgnosticLineBreak());
+        }
+
         protected ComparisonException GetTheExceptionThrowByComparingThese(Table table, SetComparisonTestObject[] items)
         {
             try