Update PoC projects (#199)

josesimoes · web-flow · commit e5b5e313f53a · 2023-03-31T13:52:02.000+01:00
***NO_CI***
diff --git a/poc/TestOfTestFramework/NFUnitTest.nfproj b/poc/TestOfTestFramework/NFUnitTest.nfproj
@@ -32,13 +32,13 @@
   </ItemGroup>
   <ItemGroup>
     <Reference Include="mscorlib">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.12.0\lib\mscorlib.dll</HintPath>
+      <HintPath>..\packages\nanoFramework.CoreLibrary.1.14.2\lib\mscorlib.dll</HintPath>
     </Reference>
     <Reference Include="nanoFramework.TestFramework">
-      <HintPath>..\packages\nanoFramework.TestFramework.2.0.60\lib\nanoFramework.TestFramework.dll</HintPath>
+      <HintPath>..\packages\nanoFramework.TestFramework.2.1.60\lib\nanoFramework.TestFramework.dll</HintPath>
     </Reference>
     <Reference Include="nanoFramework.UnitTestLauncher">
-      <HintPath>..\packages\nanoFramework.TestFramework.2.0.60\lib\nanoFramework.UnitTestLauncher.exe</HintPath>
+      <HintPath>..\packages\nanoFramework.TestFramework.2.1.60\lib\nanoFramework.UnitTestLauncher.exe</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -52,11 +52,11 @@
       <ProjectConfigurationsDeclaredAsItems />
     </ProjectCapabilities>
   </ProjectExtensions>
-  <Import Project="..\packages\nanoFramework.TestFramework.2.0.60\build\nanoFramework.TestFramework.targets" Condition="Exists('..\packages\nanoFramework.TestFramework.2.0.60\build\nanoFramework.TestFramework.targets')" />
+  <Import Project="..\packages\nanoFramework.TestFramework.2.1.60\build\nanoFramework.TestFramework.targets" Condition="Exists('..\packages\nanoFramework.TestFramework.2.1.60\build\nanoFramework.TestFramework.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105.The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\packages\nanoFramework.TestFramework.2.0.60\build\nanoFramework.TestFramework.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\nanoFramework.TestFramework.2.0.60\build\nanoFramework.TestFramework.targets'))" />
+    <Error Condition="!Exists('..\packages\nanoFramework.TestFramework.2.1.60\build\nanoFramework.TestFramework.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\nanoFramework.TestFramework.2.1.60\build\nanoFramework.TestFramework.targets'))" />
   </Target>
 </Project>
diff --git a/poc/TestOfTestFramework/Test.cs b/poc/TestOfTestFramework/Test.cs
@@ -17,13 +17,15 @@ public class TestOfTest
         public void TestRaisesException()
         {
             Debug.WriteLine("Test will raise exception");
+
             Assert.Throws(typeof(Exception), ThrowMe);
             Assert.Throws(typeof(ArgumentOutOfRangeException), () =>
             {
                 Debug.WriteLine("To see another way of doing this");
                 // This should throw an ArgumentException
                 Thread.Sleep(-2);
             });
+
             try
             {
                 Assert.Throws(typeof(Exception), () => { Debug.WriteLine("Nothing will be thrown"); });
@@ -43,6 +45,7 @@ private void ThrowMe()
         public void TestCheckAllEqual()
         {
             Debug.WriteLine("Test will check that all the Equal are actually equal");
+
             // Arrange
             byte bytea = 42; byte byteb = 42;
             char chara = (char)42; char charb = (char)42;
@@ -60,29 +63,31 @@ public void TestCheckAllEqual()
             object obja = new object(); object objb = obja;
             string stra = "42"; string strb = "42";
             byte[] arrayempty = new byte[0];
+
             // Assert
-            Assert.True(boola);
-            Assert.Equal(bytea, byteb);
-            Assert.Equal(chara, charb);
-            Assert.Equal(sbytea, sbyteb);
-            Assert.Equal(inta, intb);
-            Assert.Equal(uinta, uintb);
-            Assert.Equal(longa, longb);
-            Assert.Equal(ulonga, ulongb);
-            Assert.Equal(boola, boolb);
-            Assert.Equal(shorta, shortb);
-            Assert.Equal(ushorta, ushortb);
-            Assert.Equal(floata, floatb);
-            Assert.Equal(intArraya, intArrayb);
-            Assert.Equal(stra, strb);
-            Assert.Same(obja, objb);
-            Assert.Empty(arrayempty);
+            Assert.IsTrue(boola);
+            Assert.AreEqual(bytea, byteb);
+            Assert.AreEqual(chara, charb);
+            Assert.AreEqual(sbytea, sbyteb);
+            Assert.AreEqual(inta, intb);
+            Assert.AreEqual(uinta, uintb);
+            Assert.AreEqual(longa, longb);
+            Assert.AreEqual(ulonga, ulongb);
+            Assert.AreEqual(boola, boolb);
+            Assert.AreEqual(shorta, shortb);
+            Assert.AreEqual(ushorta, ushortb);
+            Assert.AreEqual(floata, floatb);
+            CollectionAssert.AreEqual(intArraya, intArrayb);
+            Assert.AreEqual(stra, strb);
+            Assert.AreSame(obja, objb);
+            CollectionAssert.Empty(arrayempty);
         }
 
         [TestMethod]
         public void TestCheckAllNotEqual()
         {
             Debug.WriteLine("Test will check that all the NotEqual are actually equal");
+
             // Arrange
             byte bytea = 42; byte byteb = 43;
             char chara = (char)42; char charb = (char)43;
@@ -101,60 +106,63 @@ public void TestCheckAllNotEqual()
             int[] intArrayter = null;
             object obja = new object(); object objb = new object();
             string stra = "42"; string strb = "43";
+
             // Assert
-            Assert.False(boolb);
-            Assert.NotEqual(bytea, byteb);
-            Assert.NotEqual(chara, charb);
-            Assert.NotEqual(sbytea, sbyteb);
-            Assert.NotEqual(inta, intb);
-            Assert.NotEqual(uinta, uintb);
-            Assert.NotEqual(longa, longb);
-            Assert.NotEqual(ulonga, ulongb);
-            Assert.NotEqual(boola, boolb);
-            Assert.NotEqual(shorta, shortb);
-            Assert.NotEqual(ushorta, ushortb);
-            Assert.NotEqual(floata, floatb);
-            Assert.NotEqual(intArraya, intArrayb);
-            Assert.NotEqual(intArraya, intArraybis);
-            Assert.NotEqual(intArraya, intArrayter);
-            Assert.NotEqual(stra, strb);
-            Assert.NotSame(obja, objb);
-            Assert.NotEmpty(intArraya);
+            Assert.IsFalse(boolb);
+            Assert.AreNotEqual(bytea, byteb);
+            Assert.AreNotEqual(chara, charb);
+            Assert.AreNotEqual(sbytea, sbyteb);
+            Assert.AreNotEqual(inta, intb);
+            Assert.AreNotEqual(uinta, uintb);
+            Assert.AreNotEqual(longa, longb);
+            Assert.AreNotEqual(ulonga, ulongb);
+            Assert.AreNotEqual(boola, boolb);
+            Assert.AreNotEqual(shorta, shortb);
+            Assert.AreNotEqual(ushorta, ushortb);
+            Assert.AreNotEqual(floata, floatb);
+            Assert.AreNotEqual(intArraya, intArrayb);
+            Assert.AreNotEqual(intArraya, intArraybis);
+            Assert.AreNotEqual(intArraya, intArrayter);
+            Assert.AreNotEqual(stra, strb);
+            Assert.AreNotSame(obja, objb);
+            CollectionAssert.NotEmpty(intArraya);
         }
 
         [TestMethod]
         public void TestNullEmpty()
         {
             Debug.WriteLine("Test null, not null, types");
+
             // Arrange
             object objnull = null;
             object objnotnull = new object();
             Type typea = typeof(int);
             Type typeb = typeof(int);
             Type typec = typeof(long);
+
             // Assert
-            Assert.Null(objnull);
-            Assert.NotNull(objnotnull);
-            Assert.IsType(typea, typeb);
-            Assert.IsNotType(typea, typec);
+            Assert.IsNull(objnull);
+            Assert.IsNotNull(objnotnull);
+            Assert.AreEqual(typea, typeb);
+            Assert.AreNotEqual(typea, typec);
         }
 
         [TestMethod]
         public void TestStringComparison()
         {
             Debug.WriteLine("Test string, Contains, EndsWith, StartWith");
+
             // Arrange
             string tocontains = "this text contains and end with contains";
             string startcontains = "contains start this text";
             string contains = "contains";
             string doesnotcontains = "this is totally something else";
             string empty = string.Empty;
-            string stringnull = null;
+
             // Assert
             Assert.Contains(contains, tocontains);
             Assert.DoesNotContains(contains, doesnotcontains);
             Assert.DoesNotContains(contains, empty);
-            Assert.DoesNotContains(contains, stringnull);
             Assert.StartsWith(contains, startcontains);
             Assert.EndsWith(contains, tocontains);
         }
diff --git a/poc/TestOfTestFramework/packages.config b/poc/TestOfTestFramework/packages.config
@@ -1,5 +1,5 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="nanoFramework.CoreLibrary" version="1.12.0" targetFramework="netnano1.0" />
-  <package id="nanoFramework.TestFramework" version="2.0.60" targetFramework="netnano1.0" developmentDependency="true" />
+  <package id="nanoFramework.CoreLibrary" version="1.14.2" targetFramework="netnano1.0" />
+  <package id="nanoFramework.TestFramework" version="2.1.60" targetFramework="netnano1.0" developmentDependency="true" />
 </packages>
diff --git a/poc/TestOfTestFrameworkByReference/DataRowTests.cs b/poc/TestOfTestFrameworkByReference/DataRowTests.cs
@@ -4,10 +4,6 @@
 // See LICENSE file in the project root for full license information.
 //
 
-using System;
-using System.Diagnostics;
-using System.Threading;
-
 namespace nanoFramework.TestFramework.Test
 {
     [TestClass]
@@ -20,29 +16,29 @@ public void TestAddition(int number1, int number2, int result)
         {
             var additionResult = number1 + number2;
 
-            Assert.Equal(additionResult, result);
+            Assert.AreEqual(additionResult, result);
         }
 
         [TestMethod]
         [DataRow("TestString")]
         public void TestString(string testData)
         {
-            Assert.Equal(testData, "TestString");
+            Assert.AreEqual(testData, "TestString");
         }
 
         [TestMethod]
         [DataRow("adsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassa")]
         public void TestLongString(string testData)
         {
-            Assert.Equal(testData, "adsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassa");
+            Assert.AreEqual(testData, "adsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassa");
         }
 
         [TestMethod]
         [DataRow("Right align in 10 chars: {0,10:N2}: and then more", 1234.5641, "Right align in 10 chars:   1,234.56: and then more")]
         public void TestStringWithComma(string formatString, double value, string outcomeMessage)
         {
             // Test alignment operator which is the "," and a number. Negative is right aligned, positive left aligned
-            Assert.Equal(string.Format(formatString, value), outcomeMessage);
+            Assert.AreEqual(string.Format(formatString, value), outcomeMessage);
         }
     }
 }
diff --git a/poc/TestOfTestFrameworkByReference/NFUnitTestByReference.nfproj b/poc/TestOfTestFrameworkByReference/NFUnitTestByReference.nfproj
@@ -43,24 +43,22 @@
   </ItemGroup>
   <ItemGroup>
     <Reference Include="mscorlib">
-      <HintPath>..\..\packages\nanoFramework.CoreLibrary.1.12.0\lib\mscorlib.dll</HintPath>
+      <HintPath>..\packages\nanoFramework.CoreLibrary.1.14.2\lib\mscorlib.dll</HintPath>
     </Reference>
     <Reference Include="nanoFramework.Runtime.Native">
-      <HintPath>..\packages\nanoFramework.Runtime.Native.1.5.4\lib\nanoFramework.Runtime.Native.dll</HintPath>
+      <HintPath>..\packages\nanoFramework.Runtime.Native.1.6.6\lib\nanoFramework.Runtime.Native.dll</HintPath>
     </Reference>
   </ItemGroup>
   <Target Name="CopyTestAdapter" AfterTargets="Build">
     <Message Text="Copying TestAdapter" Importance="High" />
     <ItemGroup>
-        <!-- Because this ItemGroup is inside the target, this will enumerate
+      <!-- Because this ItemGroup is inside the target, this will enumerate
               all files just before calling Copy. If the ItemGroup were outside
               the target , it would enumerate the files during evaluation, before
               the build starts, which may miss files created during the build. -->
-        <TestAdapterFiles Include="$(SolutionDir)..\source\TestAdapter\bin\Debug\net4.8\*"/>
-    </ItemGroup>    
-    <Copy
-      SourceFiles="@(TestAdapterFiles)"
-      DestinationFolder="$(TargetDir)" />
+      <TestAdapterFiles Include="$(SolutionDir)..\source\TestAdapter\bin\Debug\net4.8\*" />
+    </ItemGroup>
+    <Copy SourceFiles="@(TestAdapterFiles)" DestinationFolder="$(TargetDir)" />
   </Target>
   <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
   <ProjectExtensions>
diff --git a/poc/TestOfTestFrameworkByReference/SkipFewMethods.cs b/poc/TestOfTestFrameworkByReference/SkipFewMethods.cs
@@ -6,7 +6,6 @@
 
 using nanoFramework.Runtime.Native;
 using nanoFramework.TestFramework;
-using System;
 using System.Diagnostics;
 using static nanoFramework.Runtime.Native.SystemInfo;
 
@@ -17,15 +16,21 @@ class SkipFewTest
     {
         [Setup]
         public void SetupMethodWillPass()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void MethodWillPass1()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void MethodWillPass2()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void MethodWillSkip()
@@ -42,7 +47,9 @@ public void MethodWillSkip2()
 
         [TestMethod]
         public void MethodWillPass3()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
 
         [TestMethod]
@@ -56,8 +63,8 @@ public void MethodWillSkippIfFloatingPointSupportNotOK()
 
             double on42 = 42.1;
             double maxDouble = double.MaxValue;
-            Assert.Equal(42.1, on42);
-            Assert.Equal(double.MaxValue, maxDouble);
+            Assert.AreEqual(42.1, on42);
+            Assert.AreEqual(double.MaxValue, maxDouble);
         }
 
         [TestMethod]
diff --git a/poc/TestOfTestFrameworkByReference/SkipTestClass.cs b/poc/TestOfTestFrameworkByReference/SkipTestClass.cs
@@ -5,7 +5,6 @@
 //
 
 using nanoFramework.TestFramework;
-using System;
 using System.Diagnostics;
 
 namespace NFUnitTest
@@ -16,36 +15,50 @@ class SkipTestClass
         [Setup]
         public void SetupMethodToSkip()
         {
-            Debug.WriteLine("Skippîng all the other methods");
+            Debug.WriteLine("Skipping all the other methods");
             Assert.SkipTest("None of the other methods should be tested, they should all be skipped.");
         }
 
         [TestMethod]
         public void TestMothdWhichShouldSkip()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void TestMothdWhichShouldSkip2()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void TestMothdWhichShouldSkip3()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void TestMothdWhichShouldSkip4()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void TestMothdWhichShouldSkip5()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [TestMethod]
         public void TestMothdWhichShouldSkip6()
-        { }
+        {
+            // Method intentionally left empty.
+        }
 
         [Cleanup]
         public void CleanUpMethodSkip()
-        { }
+        {
+            // Method intentionally left empty.
+        }
     }
 }
diff --git a/poc/TestOfTestFrameworkByReference/Test.cs b/poc/TestOfTestFrameworkByReference/Test.cs
diff --git a/poc/TestOfTestFrameworkByReference/packages.config b/poc/TestOfTestFrameworkByReference/packages.config

Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,6 @@`
`4`	`4`	`// See LICENSE file in the project root for full license information.`
`5`	`5`	`//`
`6`	`6`
`7`		`-using System;`
`8`		`-using System.Diagnostics;`
`9`		`-using System.Threading;`
`10`		`-`
`11`	`7`	`namespace nanoFramework.TestFramework.Test`
`12`	`8`	`{`
`13`	`9`	`[TestClass]`
`@@ -20,29 +16,29 @@ public void TestAddition(int number1, int number2, int result)`
`20`	`16`	`{`
`21`	`17`	`var additionResult = number1 + number2;`
`22`	`18`
`23`		`- Assert.Equal(additionResult, result);`
	`19`	`+ Assert.AreEqual(additionResult, result);`
`24`	`20`	`}`
`25`	`21`
`26`	`22`	`[TestMethod]`
`27`	`23`	`[DataRow("TestString")]`
`28`	`24`	`public void TestString(string testData)`
`29`	`25`	`{`
`30`		`- Assert.Equal(testData, "TestString");`
	`26`	`+ Assert.AreEqual(testData, "TestString");`
`31`	`27`	`}`
`32`	`28`
`33`	`29`	`[TestMethod]`
`34`	`30`	`[DataRow("adsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassa")]`
`35`	`31`	`public void TestLongString(string testData)`
`36`	`32`	`{`
`37`		`- Assert.Equal(testData, "adsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassa");`
	`33`	`+ Assert.AreEqual(testData, "adsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassaadsdasdasasddassa");`
`38`	`34`	`}`
`39`	`35`
`40`	`36`	`[TestMethod]`
`41`	`37`	`[DataRow("Right align in 10 chars: {0,10:N2}: and then more", 1234.5641, "Right align in 10 chars: 1,234.56: and then more")]`
`42`	`38`	`public void TestStringWithComma(string formatString, double value, string outcomeMessage)`
`43`	`39`	`{`
`44`	`40`	`// Test alignment operator which is the "," and a number. Negative is right aligned, positive left aligned`
`45`		`- Assert.Equal(string.Format(formatString, value), outcomeMessage);`
	`41`	`+ Assert.AreEqual(string.Format(formatString, value), outcomeMessage);`
`46`	`42`	`}`
`47`	`43`	`}`
`48`	`44`	`}`