Migrate to mscorlib v2

- Update pipelines config.
- Update references.
- Update versions.
- Add overloads with `Span<byte>` and `ReadOnlySpan<byte>`.
- Update unit tests.
- Update license headers.
- Bump versions.

Author: josesimoes

.runsettings

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
+    <RunConfiguration>
+        <MaxCpuCount>1</MaxCpuCount>
+        <ResultsDirectory>.\TestResults</ResultsDirectory>
+        <TestSessionTimeout>120000</TestSessionTimeout>
+        <TargetFrameworkVersion>net48</TargetFrameworkVersion>
+        <TargetPlatform>x64</TargetPlatform>
+    </RunConfiguration>
+    <nanoFrameworkAdapter>
+        <Logging>Verbose</Logging>
+        <IsRealHardware>False</IsRealHardware>
+        <UsePreviewClr>True</UsePreviewClr>
+    </nanoFrameworkAdapter>
+</RunSettings>

Tests/IPAddressTests/IPAddressTests.cs

@@ -27,11 +27,11 @@ public void NetTest1_DNS()
         {
             IPHostEntry ipHostEntry = Dns.GetHostEntry("192.168.1.1");
 
-            Assert.Equal(ipHostEntry.AddressList.Length, 1, "GetHostEntry returned wrong number of addresses");
+            Assert.AreEqual(1, ipHostEntry.AddressList.Length, "GetHostEntry returned wrong number of addresses");
             IPAddress address = ipHostEntry.AddressList[0];
 
-            Assert.NotNull(address, "Address is null");
-            Assert.Equal(address.ToString(), "192.168.1.1", "Address is incorrect");
+            Assert.IsNotNull(address, "Address is null");
+            Assert.AreEqual("192.168.1.1", address.ToString(), "Address is incorrect");
         }
 
         [TestMethod]
@@ -54,25 +54,25 @@ public void NetTest2_IPAddressBasic()
                     + IPInts[1] * 256
                     + IPInts[2] * 256 * 256
                     + IPInts[3] * 256 * 256 * 256);
-                Assert.NotNull(address, "Address is null");
+                Assert.IsNotNull(address, "Address is null");
 
                 Type typeOfAddress = address.GetType();
-                Assert.IsType(typeOfAddress, Type.GetType("System.Net.IPAddress"), "Type is incorrect");
+                Assert.IsInstanceOfType(typeOfAddress, Type.GetType("System.Net.IPAddress"), "Type is incorrect");
 
                 byte[] targetBytes = { (byte)IPInts[0], (byte)IPInts[1], (byte)IPInts[2], (byte)IPInts[3] };
                 byte[] addressBytes = address.GetAddressBytes();
-                Assert.Equal(addressBytes.Length, 4, "GetAddressBytes returns wrong size");
+                Assert.AreEqual(4, addressBytes.Length, "GetAddressBytes returns wrong size");
 
                 for (int j = 0; j < 4; j++)
                 {
-                    Assert.Equal(addressBytes[j], targetBytes[j], "GetAddressBytes returns wrong bytes");
+                    Assert.AreEqual(targetBytes[j], addressBytes[j], "GetAddressBytes returns wrong bytes");
                 }
 
                 IPAddress addressFromByteArray = new(targetBytes);
                 addressBytes = addressFromByteArray.GetAddressBytes();
                 for (int j = 0; j < 4; j++)
                 {
-                    Assert.Equal(addressBytes[j], targetBytes[j], "Address from byte array returns wrong bytes");
+                    Assert.AreEqual(targetBytes[j], addressBytes[j], "Address from byte array returns wrong bytes");
                 }
 
                 IPAddress address2 = new(
@@ -81,17 +81,17 @@ public void NetTest2_IPAddressBasic()
                     + IPInts[2] * 256 * 256
                     + IPInts[3] * 256 * 256 * 256);
 
-                Assert.Equal(address.ToString(), address2.ToString(), "ToString returns differently for same data");
+                Assert.AreEqual(address2.ToString(), address.ToString(), "ToString returns differently for same data");
 
-                Assert.Equal(address.GetHashCode(), address2.GetHashCode(), "GetHasCode returns differently for same data");
+                Assert.AreEqual(address2.GetHashCode(), address.GetHashCode(), "GetHasCode returns differently for same data");
 
                 address2 = new IPAddress(
                     (IPInts[0] % 2 + 1)
                     + (IPInts[1] % 2 + 1) * 256
                     + (IPInts[2] % 2 + 1) * 256 * 256
                     + (IPInts[3] % 2 + 1) * 256 * 256 * 256);
 
-                Assert.NotEqual(address.GetHashCode(), address2.GetHashCode(), "GetHasCode returns same for " + address.ToString()
+                Assert.AreNotEqual(address2.GetHashCode(), address.GetHashCode(), "GetHasCode returns same for " + address.ToString()
                         + " as " + address2.ToString());
             }
         }
@@ -100,20 +100,20 @@ public void NetTest2_IPAddressBasic()
         public void NetTest3_IPAddressLoopback()
         {
             IPAddress address = IPAddress.Loopback;
-            Assert.NotNull(address, "Address is null");
+            Assert.IsNotNull(address, "Address is null");
 
-            Assert.Equal(address.ToString(), "127.0.0.1", "Address is incorrect");
+            Assert.AreEqual("127.0.0.1", address.ToString(), "Address is incorrect");
 
             Type typeOfAddress = address.GetType();
-            Assert.IsType(typeOfAddress, Type.GetType("System.Net.IPAddress"), "Type is incorrect");
+            Assert.IsInstanceOfType(typeOfAddress, Type.GetType("System.Net.IPAddress"), "Type is incorrect");
 
             byte[] localhostBytes = { 127, 0, 0, 1 };
             byte[] addressBytes = address.GetAddressBytes();
-            Assert.Equal(addressBytes.Length, 4, "GetAddressBytes returns wrong size");
+            Assert.AreEqual(4, addressBytes.Length, "GetAddressBytes returns wrong size");
 
             for (int i = 0; i < 4; i++)
             {
-                Assert.Equal(addressBytes[i], localhostBytes[i], "GetAddressBytes returns wrong bytes");
+                Assert.AreEqual(localhostBytes[i], addressBytes[i], "GetAddressBytes returns wrong bytes");
             }
         }
 
@@ -123,20 +123,20 @@ public void NetTest4_IPAddressAny()
         {
             IPAddress address = IPAddress.Any;
 
-            Assert.NotNull(address, "Address is null");
+            Assert.IsNotNull(address, "Address is null");
 
-            Assert.Equal(address.ToString(), "0.0.0.0", "Address is incorrect");
+            Assert.AreEqual("0.0.0.0", address.ToString(), "Address is incorrect");
 
             Type typeOfAddress = address.GetType();
-            Assert.IsType(typeOfAddress, Type.GetType("System.Net.IPAddress"), "Type is incorrect");
+            Assert.IsInstanceOfType(typeOfAddress, Type.GetType("System.Net.IPAddress"), "Type is incorrect");
 
             byte[] localhostBytes = { 0, 0, 0, 0 };
             byte[] addressBytes = address.GetAddressBytes();
-            Assert.Equal(addressBytes.Length, 4, "GetAddressBytes returns wrong size");
+            Assert.AreEqual(4, addressBytes.Length, "GetAddressBytes returns wrong size");
 
             for (int i = 0; i < 4; i++)
             {
-                Assert.Equal(addressBytes[i], localhostBytes[i], "GetAddressBytes returns wrong bytes");
+                Assert.AreEqual(localhostBytes[i], addressBytes[i], "GetAddressBytes returns wrong bytes");
             }
         }
 
@@ -171,47 +171,47 @@ public void NetTest5_IPEndPointBasic()
                 Debug.WriteLine("EndPoint2 created with long and int");
                 IPEndPoint endPoint2 = new(addressLong, portInt);
 
-                Assert.NotNull(endPoint1, "EndPoint1 is null");
-                Assert.NotNull(endPoint2, "EndPoint2 is null");
+                Assert.IsNotNull(endPoint1, "EndPoint1 is null");
+                Assert.IsNotNull(endPoint2, "EndPoint2 is null");
 
                 Type typeOfEndPoint = endPoint1.GetType();
-                Assert.IsType(typeOfEndPoint, Type.GetType("System.Net.IPEndPoint"), "EndPoint1 Type is incorrect");
+                Assert.IsInstanceOfType(typeOfEndPoint, Type.GetType("System.Net.IPEndPoint"), "EndPoint1 Type is incorrect");
 
                 typeOfEndPoint = endPoint2.GetType();
-                Assert.IsType(typeOfEndPoint, Type.GetType("System.Net.IPEndPoint"), "EndPoint2 Type is incorrect");
+                Assert.IsInstanceOfType(typeOfEndPoint, Type.GetType("System.Net.IPEndPoint"), "EndPoint2 Type is incorrect");
 
-                Assert.Equal(endPoint1.ToString(), endPoint2.ToString(), "ToString returns differently for same data");
+                Assert.AreEqual(endPoint2.ToString(), endPoint1.ToString(), "ToString returns differently for same data");
 
-                Assert.True(endPoint1.Equals(endPoint2), "Equals returns false for same data");
+                Assert.IsTrue(endPoint1.Equals(endPoint2), "Equals returns false for same data");
 
                 int hashCode1 = endPoint1.GetHashCode();
                 int hashCode2 = endPoint2.GetHashCode();
 
-                Assert.Equal(hashCode1, hashCode2, "GetHasCode returns differently for same data");
+                Assert.AreEqual(hashCode2, hashCode1, "GetHasCode returns differently for same data");
 
-                Assert.False(endPoint1.Address.ToString() != endPoint2.Address.ToString()
+                Assert.IsFalse(endPoint1.Address.ToString() != endPoint2.Address.ToString()
                     || endPoint1.Address.ToString() != address.ToString()
                     || endPoint2.Address.ToString() != address.ToString(), "Address returns wrong data");
 
-                Assert.False(endPoint1.Port != endPoint2.Port
+                Assert.IsFalse(endPoint1.Port != endPoint2.Port
                     || endPoint1.Port != portInt
                     || endPoint2.Port != portInt, "Port returns wrong data");
 
                 Debug.WriteLine("Cloning Enpoint1 into EndPoint2");
                 endPoint2 = (IPEndPoint)endPoint2.Create(endPoint1.Serialize());
 
                 typeOfEndPoint = endPoint2.GetType();
-                Assert.IsType(typeOfEndPoint, Type.GetType("System.Net.IPEndPoint"), "EndPoint2 Type is incorrect after clone");
+                Assert.IsInstanceOfType(typeOfEndPoint, Type.GetType("System.Net.IPEndPoint"), "EndPoint2 Type is incorrect after clone");
 
-                Assert.Equal(endPoint1.ToString(), endPoint2.ToString(), "ToString returns differently for cloned data");
+                Assert.AreEqual(endPoint2.ToString(), endPoint1.ToString(), "ToString returns differently for cloned data");
 
-                Assert.Equal(endPoint1.GetHashCode(), endPoint2.GetHashCode(), "GetHashCode returns differently for cloned data");
+                Assert.AreEqual(endPoint2.GetHashCode(), endPoint1.GetHashCode(), "GetHashCode returns differently for cloned data");
 
-                Assert.False(endPoint1.Address.ToString() != endPoint2.Address.ToString()
+                Assert.IsFalse(endPoint1.Address.ToString() != endPoint2.Address.ToString()
                     || endPoint1.Address.ToString() != address.ToString()
                     || endPoint2.Address.ToString() != address.ToString(), "Address returns wrong data after clone");
 
-                Assert.False(endPoint1.Port != endPoint2.Port
+                Assert.IsFalse(endPoint1.Port != endPoint2.Port
                     || endPoint1.Port != portInt
                     || endPoint2.Port != portInt, "Port returns wrong data after clone");
 
@@ -225,14 +225,14 @@ public void NetTest5_IPEndPointBasic()
                     + (IPInts[3] % 2 + 1) * 256 * 256 * 256;
                 endPoint2 = new IPEndPoint(addressLong2, portInt2);
 
-                Assert.NotEqual(endPoint1.GetHashCode(), endPoint2.GetHashCode(), "GetHashCode returns same for "
+                Assert.AreNotEqual(endPoint2.GetHashCode(), endPoint1.GetHashCode(), "GetHashCode returns same for "
                         + endPoint1.ToString()
                         + " as " + endPoint2.ToString());
 
-                Assert.False(endPoint1.Address == endPoint2.Address
+                Assert.IsFalse(endPoint1.Address == endPoint2.Address
                     || endPoint2.Address == address, "Address returns wrong data after change");
 
-                Assert.False(endPoint1.Port == endPoint2.Port
+                Assert.IsFalse(endPoint1.Port == endPoint2.Port
                     || endPoint2.Port == portInt, "Port returns wrong data after change");
             }
         }
@@ -241,13 +241,13 @@ public void NetTest5_IPEndPointBasic()
         public void NetTest5_IPHostEntryBasic()
         {
             IPHostEntry ipHostEntry = Dns.GetHostEntry("192.168.1.1");
-            Assert.NotNull(ipHostEntry, "IPHostEntry is null");
+            Assert.IsNotNull(ipHostEntry, "IPHostEntry is null");
 
             Type typeOfIPHostEntry = ipHostEntry.GetType();
-            Assert.IsType(typeOfIPHostEntry, Type.GetType("System.Net.IPHostEntry"), "IPHostEntry Type is incorrect");
+            Assert.IsInstanceOfType(typeOfIPHostEntry, Type.GetType("System.Net.IPHostEntry"), "IPHostEntry Type is incorrect");
 
-            Assert.Equal(ipHostEntry.AddressList[0].ToString(), "192.168.1.1", "AddressList[0] is incorrect");
-            Assert.Throws(typeof(IndexOutOfRangeException), () => { ipHostEntry.AddressList[1].ToString(); });
+            Assert.AreEqual("192.168.1.1", ipHostEntry.AddressList[0].ToString(), "AddressList[0] is incorrect");
+            Assert.ThrowsException(typeof(IndexOutOfRangeException), () => { ipHostEntry.AddressList[1].ToString(); });
         }
 
         [TestMethod]
@@ -278,25 +278,25 @@ public void NetTest6_SocketAddressBasic()
                 SocketAddress socketAddress1 = ipEndpoint1.Serialize();
                 SocketAddress socketAddress2 = ipEndpoint1.Serialize();
 
-                Assert.NotNull(socketAddress1, "socketAddress1 is null");
-                Assert.NotNull(socketAddress2, "socketAddress2 is null");
+                Assert.IsNotNull(socketAddress1, "socketAddress1 is null");
+                Assert.IsNotNull(socketAddress2, "socketAddress2 is null");
 
                 Type typeOfSocketAddress = socketAddress1.GetType();
-                Assert.IsType(typeOfSocketAddress, Type.GetType("System.Net.SocketAddress"), "socketAddress1 Type is incorrect");
+                Assert.IsInstanceOfType(typeOfSocketAddress, Type.GetType("System.Net.SocketAddress"), "socketAddress1 Type is incorrect");
 
                 typeOfSocketAddress = socketAddress2.GetType();
-                Assert.IsType(typeOfSocketAddress, Type.GetType("System.Net.SocketAddress"), "socketAddress2 Type is incorrect");
+                Assert.IsInstanceOfType(typeOfSocketAddress, Type.GetType("System.Net.SocketAddress"), "socketAddress2 Type is incorrect");
 
-                Assert.Equal(socketAddress1.ToString(), socketAddress2.ToString(), "ToString returns differently for same data");
+                Assert.AreEqual(socketAddress2.ToString(), socketAddress1.ToString(), "ToString returns differently for same data");
 
-                Assert.Equal(socketAddress1.GetHashCode(), socketAddress2.GetHashCode(), $"GetHashCode returns differently for same data");
-                Assert.True(socketAddress1.Family == AddressFamily.InterNetwork, "socketAddress1 Family is incorrect");
-                Assert.True(socketAddress2.Family == AddressFamily.InterNetwork, "socketAddress2 Family is incorrect");
+                Assert.AreEqual(socketAddress2.GetHashCode(), socketAddress1.GetHashCode(), $"GetHashCode returns differently for same data");
+                Assert.IsTrue(socketAddress1.Family == AddressFamily.InterNetwork, "socketAddress1 Family is incorrect");
+                Assert.IsTrue(socketAddress2.Family == AddressFamily.InterNetwork, "socketAddress2 Family is incorrect");
 
                 // Recreate a different Socket
                 socketAddress2 = new SocketAddress(AddressFamily.Chaos, 8);
 
-                Assert.NotEqual(socketAddress1.GetHashCode(), socketAddress2.GetHashCode(), "GetHashCode returns same for "
+                Assert.AreNotEqual(socketAddress2.GetHashCode(), socketAddress1.GetHashCode(), "GetHashCode returns same for "
                         + socketAddress1.ToString() + " " + socketAddress1.GetHashCode()
                         + " as " + socketAddress2.ToString() + " " + socketAddress2.GetHashCode());
             }

Tests/IPAddressTests/IPAddressTests.nfproj

@@ -25,40 +25,36 @@
     <RestoreLockedMode Condition="'$(TF_BUILD)' == 'True' or '$(ContinuousIntegrationBuild)' == 'True'">true</RestoreLockedMode>
   </PropertyGroup>
   <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <PropertyGroup>
-    <RunSettingsFilePath>$(MSBuildProjectDirectory)\nano.runsettings</RunSettingsFilePath>
-  </PropertyGroup>
   <ItemGroup>
     <Compile Include="IPAddressTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Reference Include="mscorlib, Version=1.17.11.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\..\packages\nanoFramework.CoreLibrary.1.17.11\lib\mscorlib.dll</HintPath>
+    <ProjectReference Include="..\..\nanoFramework.System.Net\System.Net.nfproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="packages.lock.json" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="mscorlib">
+      <HintPath>..\..\packages\nanoFramework.CoreLibrary.2.0.0-preview.32\lib\netnano1.0\mscorlib.dll</HintPath>
     </Reference>
-    <Reference Include="nanoFramework.System.Text, Version=1.3.42.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\..\packages\nanoFramework.System.Text.1.3.42\lib\nanoFramework.System.Text.dll</HintPath>
+    <Reference Include="nanoFramework.System.Text">
+      <HintPath>..\..\packages\nanoFramework.System.Text.2.0.0-preview.5\lib\nanoFramework.System.Text.dll</HintPath>
     </Reference>
-    <Reference Include="nanoFramework.TestFramework, Version=3.0.77.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\..\packages\nanoFramework.TestFramework.3.0.77\lib\nanoFramework.TestFramework.dll</HintPath>
+    <Reference Include="nanoFramework.TestFramework">
+      <HintPath>..\..\packages\nanoFramework.TestFramework.4.0.0-preview.47\lib\nanoFramework.TestFramework.dll</HintPath>
     </Reference>
-    <Reference Include="nanoFramework.UnitTestLauncher, Version=0.0.0.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\..\packages\nanoFramework.TestFramework.3.0.77\lib\nanoFramework.UnitTestLauncher.exe</HintPath>
+    <Reference Include="nanoFramework.UnitTestLauncher">
+      <HintPath>..\..\packages\nanoFramework.TestFramework.4.0.0-preview.47\lib\nanoFramework.UnitTestLauncher.exe</HintPath>
     </Reference>
-    <Reference Include="System.IO.Streams, Version=1.1.96.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\..\packages\nanoFramework.System.IO.Streams.1.1.96\lib\System.IO.Streams.dll</HintPath>
+    <Reference Include="System.IO.Streams">
+      <HintPath>..\..\packages\nanoFramework.System.IO.Streams.2.0.0-preview.7\lib\System.IO.Streams.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <None Include="nano.runsettings" />
     <None Include="packages.config" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\nanoFramework.System.Net\System.Net.nfproj" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="packages.lock.json" />
-  </ItemGroup>
   <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
   <!-- MANUAL UPDATE HERE -->
   <ProjectExtensions>