Update the NUnit assertion model to the contraint model from the classic model which no longer receives updates.

- This also makes migrating to NUnit 4 easier.
- This enables Verify.NUnit to be updated to 22.1.4 since it depebnds on NUnit 4.

Author: milkshakeuk

tests/NHapi.Base.NUnit/CommonDtTest.cs

@@ -11,182 +11,232 @@ public class CommonDtTest
         public void Constructor_Sets_Value()
         {
             var commonDt = new CommonDT("20010203");
-            Assert.AreEqual("20010203", commonDt.Value);
+
+            Assert.That(commonDt.Value, Is.EqualTo("20010203"));
         }
 
         [Test]
         public void Value__Set_to_Null()
         {
-            var commonDt = new CommonDT();
-            commonDt.Value = null;
-            Assert.AreEqual(null, commonDt.Value);
+            var commonDt = new CommonDT
+            {
+                Value = null,
+            };
+
+            Assert.That(commonDt.Value, Is.EqualTo(null));
         }
 
         [Test]
         public void Value__Set_to_Empty_String()
         {
-            var commonDt = new CommonDT();
-            commonDt.Value = string.Empty;
-            Assert.AreEqual(string.Empty, commonDt.Value);
+            var commonDt = new CommonDT
+            {
+                Value = string.Empty,
+            };
+
+            Assert.That(commonDt.Value, Is.EqualTo(string.Empty));
         }
 
         [Test]
         public void Value__Set_to_Empty_Quoted_String()
         {
-            var commonDt = new CommonDT();
-            commonDt.Value = "\"\"";
-            Assert.AreEqual("\"\"", commonDt.Value);
+            var commonDt = new CommonDT
+            {
+                Value = "\"\"",
+            };
+
+            Assert.That(commonDt.Value, Is.EqualTo("\"\""));
         }
 
         [Test]
         public void Value__Set_to_Invalid_Length()
         {
             var commonDt = new CommonDT();
-            Assert.Throws<DataTypeException>(
-                () => commonDt.Value = "20010");
+            Assert.That(() => commonDt.Value = "20010", Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void Value__Set_to_Valid_Year()
         {
-            var commonDt = new CommonDT();
-            commonDt.Value = "2001";
-            Assert.AreEqual("2001", commonDt.Value);
-            Assert.AreEqual(2001, commonDt.Year);
+            var commonDt = new CommonDT
+            {
+                Value = "2001",
+            };
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(commonDt.Value, Is.EqualTo("2001"));
+                Assert.That(commonDt.Year, Is.EqualTo(2001));
+            });
         }
 
         [Test]
         public void Value__Set_to_Valid_Year_and_Month()
         {
-            var commonDt = new CommonDT();
-            commonDt.Value = "200102";
-            Assert.AreEqual("200102", commonDt.Value);
-            Assert.AreEqual(2001, commonDt.Year);
-            Assert.AreEqual(2, commonDt.Month);
+            var commonDt = new CommonDT
+            {
+                Value = "200102",
+            };
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(commonDt.Value, Is.EqualTo("200102"));
+                Assert.That(commonDt.Year, Is.EqualTo(2001));
+                Assert.That(commonDt.Month, Is.EqualTo(2));
+            });
         }
 
         [Test]
         public void Value__Set_to_Valid_Year_and_Month_and_Day()
         {
-            var commonDt = new CommonDT();
-            commonDt.Value = "20010203";
-            Assert.AreEqual("20010203", commonDt.Value);
-            Assert.AreEqual(2001, commonDt.Year);
-            Assert.AreEqual(2, commonDt.Month);
-            Assert.AreEqual(3, commonDt.Day);
+            var commonDt = new CommonDT
+            {
+                Value = "20010203",
+            };
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(commonDt.Value, Is.EqualTo("20010203"));
+                Assert.That(commonDt.Year, Is.EqualTo(2001));
+                Assert.That(commonDt.Month, Is.EqualTo(2));
+                Assert.That(commonDt.Day, Is.EqualTo(3));
+            });
         }
 
         [Test]
         public void Value__Set_to_Invalid_Year()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.Value = "200a");
+            Assert.That(
+                () => commonDt.Value = "200a",
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void Value__Set_to_Invalid_Month()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.Value = "20010a");
+            Assert.That(
+                () => commonDt.Value = "20010a",
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void Value__Set_to_Invalid_Day()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.Value = "2001020a");
+            Assert.That(
+                () => commonDt.Value = "2001020a",
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void YearPrecision__Set_to_Valid_Year()
         {
-            var commonDt = new CommonDT();
-            commonDt.YearPrecision = 2001;
-            Assert.AreEqual("2001", commonDt.Value);
-            Assert.AreEqual(2001, commonDt.Year);
-            Assert.AreEqual(0, commonDt.Month);
-            Assert.AreEqual(0, commonDt.Day);
+            var commonDt = new CommonDT
+            {
+                YearPrecision = 2001,
+            };
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(commonDt.Value, Is.EqualTo("2001"));
+                Assert.That(commonDt.Year, Is.EqualTo(2001));
+                Assert.That(commonDt.Month, Is.EqualTo(0));
+                Assert.That(commonDt.Day, Is.EqualTo(0));
+            });
         }
 
         [Test]
         public void YearPrecision__Set_to_Invalid_Year()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.YearPrecision = 20010);
+            Assert.That(
+                () => commonDt.YearPrecision = 20010,
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void SetYearMonthPrecision_With_Valid_Year_and_Month()
         {
             var commonDt = new CommonDT();
             commonDt.SetYearMonthPrecision(2001, 02);
-            Assert.AreEqual("200102", commonDt.Value);
-            Assert.AreEqual(2001, commonDt.Year);
-            Assert.AreEqual(2, commonDt.Month);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(commonDt.Value, Is.EqualTo("200102"));
+                Assert.That(commonDt.Year, Is.EqualTo(2001));
+                Assert.That(commonDt.Month, Is.EqualTo(2));
+            });
         }
 
         [Test]
         public void SetYearMonthPrecision_With_Invalid_Year()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.SetYearMonthPrecision(20010, 02));
+            Assert.That(
+                () => commonDt.SetYearMonthPrecision(20010, 02),
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void SetYearMonthPrecision_With_Invalid_Month()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.SetYearMonthPrecision(2001, 13));
+            Assert.That(
+                () => commonDt.SetYearMonthPrecision(2001, 13),
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void SetYearMonthDayPrecision_With_Valid_Year_and_Month_and_Day()
         {
             var commonDt = new CommonDT();
             commonDt.SetYearMonthDayPrecision(2001, 2, 3);
-            Assert.AreEqual("20010203", commonDt.Value);
-            Assert.AreEqual(2001, commonDt.Year);
-            Assert.AreEqual(2, commonDt.Month);
-            Assert.AreEqual(3, commonDt.Day);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(commonDt.Value, Is.EqualTo("20010203"));
+                Assert.That(commonDt.Year, Is.EqualTo(2001));
+                Assert.That(commonDt.Month, Is.EqualTo(2));
+                Assert.That(commonDt.Day, Is.EqualTo(3));
+            });
         }
 
         [Test]
         public void SetYearMonthDayPrecision_With_Invalid_Year()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.SetYearMonthDayPrecision(20010, 2, 3));
+            Assert.That(
+                () => commonDt.SetYearMonthDayPrecision(20010, 2, 3),
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void SetYearMonthDayPrecision_With_Invalid_Month()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.SetYearMonthDayPrecision(2001, 13, 3));
+            Assert.That(
+                () => commonDt.SetYearMonthDayPrecision(2001, 13, 3),
+                Throws.TypeOf<DataTypeException>());
         }
 
         [Test]
         public void SetYearMonthDayPrecision_With_Invalid_Day()
         {
             var commonDt = new CommonDT();
 
-            Assert.Throws<DataTypeException>(
-                () => commonDt.SetYearMonthDayPrecision(2001, 2, 29));
+            Assert.That(
+                () => commonDt.SetYearMonthDayPrecision(2001, 2, 29),
+                Throws.TypeOf<DataTypeException>());
         }
     }
 }

tests/NHapi.Base.NUnit/DataTypeUtilTests.cs

@@ -33,7 +33,7 @@ public void GetGMTOffset_PST()
                 TimeZoneInfo.FindSystemTimeZoneById(timeZone),
                 new DateTime(2014, 12, 1));
 
-            Assert.AreEqual(-800, offset);
+            Assert.That(offset, Is.EqualTo(-800));
         }
 
         [Test]
@@ -45,7 +45,7 @@ public void GetGMTOffset_PDT()
                 TimeZoneInfo.FindSystemTimeZoneById(timeZone),
                 new DateTime(2014, 10, 1));
 
-            Assert.AreEqual(-700, offset);
+            Assert.That(offset, Is.EqualTo(-700));
         }
 
         [Test]
@@ -57,7 +57,7 @@ public void GetGMTOffset_For_TimeZone_With_Non_Zero_Minutes()
                 TimeZoneInfo.FindSystemTimeZoneById(timeZone),
                 new DateTime(2014, 11, 1));
 
-            Assert.AreEqual(630, offset);
+            Assert.That(offset, Is.EqualTo(630));
         }
 
         [Test]
@@ -69,7 +69,7 @@ public void GetGMTOffset_For_TimeZone_With_Offset_Greater_Than_12()
                 TimeZoneInfo.FindSystemTimeZoneById(timeZone),
                 new DateTime(2014, 11, 1));
 
-            Assert.AreEqual(1400, offset);
+            Assert.That(offset, Is.EqualTo(1400));
         }
 
         private string GetAppropriateTimeZoneId(string timeZoneId)