Add missing null check tests in Data*Specs

Tests/FluentAssertions.Equivalency.Specs/DataRowSpecs.cs

@@ -364,7 +364,7 @@ public void Any_type_is_not_equivalent_to_data_row_colletion()
         {
             // Arrange 
             var o = new object();
-            
+
             // Act
             Action act = () => o.Should().BeEquivalentTo((DataRowCollection)null);
 
@@ -403,6 +403,20 @@ public void When_data_row_does_not_have_column_then_asserting_that_it_has_that_c
             action.Should().Throw<XunitException>().WithMessage("Expected dataRow to contain a column named *Unicorn*");
         }
 
+        [Fact]
+        public void Null_data_row_does_not_have_column()
+        {
+            // Arrange
+            var dataRow = (DataRow)null;
+
+            // Act
+            Action action =
+                () => dataRow.Should().HaveColumn("Does not matter");
+
+            // Assert
+            action.Should().Throw<XunitException>().WithMessage("Expected dataRow to contain a column named *Does not matter*, but found <null>*");
+        }
+
         [Fact]
         public void When_data_row_data_has_all_columns_being_asserted_then_it_should_succeed()
         {
@@ -419,6 +433,46 @@ public void When_data_row_data_has_all_columns_being_asserted_then_it_should_suc
             dataRow.Should().HaveColumns(subsetOfColumnNames);
         }
 
+        [Fact]
+        public void Data_row_with_all_colums_asserted_and_using_the_array_overload_passes()
+        {
+            // Arrange
+            var dataSet = CreateDummyDataSet<TypedDataSetSubclass>();
+
+            var dataRow = dataSet.TypedDataTable1[0];
+
+            string[] subsetOfColumnNames = dataRow.Table.Columns.Cast<DataColumn>()
+                .Take(dataRow.Table.Columns.Count - 2)
+                .Select(column => column.ColumnName)
+                .ToArray();
+
+            // Act & Assert
+            dataRow.Should().HaveColumns(subsetOfColumnNames);
+        }
+
+        [Fact]
+        public void Null_data_row_and_using_the_array_overload_fails()
+        {
+            // Arrange
+            var dataSet = CreateDummyDataSet<TypedDataSetSubclass>();
+
+            var dataRow = dataSet.TypedDataTable1[0];
+
+            var actual = (DataRow)null;
+
+            string[] subsetOfColumnNames = dataRow.Table.Columns.Cast<DataColumn>()
+                .Take(dataRow.Table.Columns.Count - 2)
+                .Select(column => column.ColumnName)
+                .ToArray();
+
+            // Act
+            Action act = () => actual.Should().HaveColumns(subsetOfColumnNames);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected actual to be in a table containing *column*, but found <null>*");
+        }
+
         [Fact]
         public void When_data_row_data_has_only_some_of_the_columns_being_asserted_then_it_should_fail()
         {

Tests/FluentAssertions.Equivalency.Specs/DataSetSpecs.cs

@@ -648,6 +648,22 @@ public void When_data_set_table_count_has_expected_value_equivalence_test_should
             // Act & Assert
             dataSet.Should().HaveTableCount(correctTableCount);
         }
+
+        [Fact]
+        public void Null_data_set_fails()
+        {
+            // Arrange
+            var dataSet = (DataSet)null;
+
+            var correctTableCount = -1;
+
+            // Act
+            Action act = () => dataSet.Should().HaveTableCount(correctTableCount);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected dataSet to contain exactly*, but found <null>*");
+        }
 
         [Fact]
         public void When_data_set_table_count_has_unexpected_value_equivalence_test_should_fail()
@@ -679,6 +695,22 @@ public void When_data_set_contains_expected_table_and_asserting_that_it_has_that
             dataSet.Should().HaveTable(existingTableName);
         }
 
+        [Fact]
+        public void Null_data_set_does_not_contain_expected_table()
+        {
+            // Arrange
+            var dataSet = (DataSet)null;
+
+            var existingTableName = "Does not matter";
+
+            // Act
+            Action act = () => dataSet.Should().HaveTable(existingTableName);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected dataSet to contain a table named*, but found <nulL>*");
+        }
+
         [Fact]
         public void When_data_set_does_not_contain_expected_table_asserting_that_it_has_that_table_should_fail()
         {
@@ -708,6 +740,24 @@ public void When_data_set_has_all_expected_tables_asserting_that_it_has_them_sho
             dataSet.Should().HaveTables(existingTableNames);
         }
 
+        [Fact]
+        public void Null_data_set_has_no_tables_and_fails()
+        {
+            // Arrange
+            var dataSet = CreateDummyDataSet<TypedDataSetSubclass>();
+            var actual = (DataSet)null;
+
+            var existingTableNames = dataSet.Tables.Cast<DataTable>()
+                .Select(table => table.TableName);
+
+            // Act
+            Action act = () => actual.Should().HaveTables(existingTableNames);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected actual to contain*table*with specific name*, but found <null>*");
+        }
+
         [Fact]
         public void When_data_set_has_some_of_the_expected_tables_but_not_all_then_asserting_that_it_has_them_should_fail()
         {

Tests/FluentAssertions.Equivalency.Specs/DataTableSpecs.cs

@@ -757,6 +757,22 @@ public void When_data_table_has_expected_row_count_it_should_succeed()
             dataTable.Should().HaveRowCount(correctRowCount);
         }
 
+        [Fact]
+        public void Null_data_table_no_rows_and_fails_test()
+        {
+            // Arrange
+            var dataTable = (DataTable)null;
+
+            int correctRowCount = -1;
+
+            // Act
+            Action act = () => dataTable.Should().HaveRowCount(correctRowCount);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected dataTable to contain exactly*row*, but found <nulL>*");
+        }
+
         [Fact]
         public void When_empty_data_table_has_expected_row_count_of_zero_it_should_succeed()
         {
@@ -805,6 +821,22 @@ public void When_data_table_has_expected_column_it_should_succeed()
             // Act & Assert
             dataTable.Should().HaveColumn(expectedColumnName);
         }
+
+        [Fact]
+        public void Null_data_table_has_no_columns_and_fail_the_test()
+        {
+            // Arrange
+            var dataTable = (DataTable)null;
+
+            var expectedColumnName = "Does not matter";
+
+            // Act
+            Action act = () => dataTable.Should().HaveColumn(expectedColumnName);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected dataTable to contain a column named*, but found <null>*");
+        }
 
         [Fact]
         public void When_data_table_does_not_have_expected_column_it_should_fail()
@@ -837,6 +869,22 @@ public void When_data_table_has_all_expected_columns_it_should_succeed()
             dataTable.Should().HaveColumns(existingColumnNames);
         }
 
+        [Fact]
+        public void Null_data_table_has_no_columns_and_fails_the_test()
+        {
+            // Arrange
+            var actual = (DataTable)null;
+
+            var existingColumnName = "Does not matter";
+
+            // Act
+            Action act = () => actual.Should().HaveColumns(existingColumnName);
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected actual to contain*column*with specific name*, but found <null>*");
+        }
+
         [Fact]
         public void When_data_table_has_only_some_expected_columns_then_asserting_that_it_has_all_of_them_should_fail()
         {