Merge branch 'develop' into 'master'

Develop

See merge request company-projects/Meadow!32

src/Meadow.EVM/Debugging/Tracing/ExecutionTrace.cs

@@ -21,6 +21,10 @@ public class ExecutionTrace
         /// The last memory change count we had recorded.
         /// </summary>
         private ulong _lastMemoryChangeCount;
+        /// <summary>
+        /// Indicates if the last tracepoint had changed storage, so it is known to be included for the current step.
+        /// </summary>
+        private bool _lastStorageChanged;
         #endregion
 
         #region Properties
@@ -42,6 +46,7 @@ public ExecutionTrace()
             Exceptions = new List<ExecutionTraceException>();
             _lastContractAddress = null;
             _lastMemoryChangeCount = 0;
+            _lastStorageChanged = false;
         }
         #endregion
 
@@ -69,12 +74,9 @@ public void RecordExecution(MeadowEVM evm, InstructionBase instruction, BigInteg
             _lastContractAddress = deployedAddress;
             _lastMemoryChangeCount = evm.ExecutionState.Memory.ChangeCount;
 
-            // Determine if our storage changed
-            bool storageChanged = instruction is InstructionStorageStore;
-
             // Determine our storage we will have for this point (null if unchanged, otherwise set)
             Dictionary<Memory<byte>, byte[]> storage = null;
-            if (contextChanged || storageChanged)
+            if (contextChanged || _lastStorageChanged)
             {
                 // Obtain our storage dictionary.
                 var account = evm.State.GetAccount(evm.Message.To);
@@ -98,6 +100,9 @@ public void RecordExecution(MeadowEVM evm, InstructionBase instruction, BigInteg
                 }
             }
 
+            // Determine if our storage changed this step and mark it for our next step.
+            _lastStorageChanged = instruction is InstructionStorageStore;
+
             // If our context changed, we want to include code hash.
             byte[] codeSegment = null;
             if (contextChanged)

src/Meadow.UnitTestTemplate.Test/CustomTestDescription.cs

@@ -0,0 +1,56 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Meadow.UnitTestTemplate.Test
+{
+
+    [MeadowTestClass]
+    public class CustomTestDescriptionWithMeadowTestClassAttribute : ContractTest
+    {
+        [TestMethod]
+        [Description("Custom example description")]
+        public async Task ExampleTestWithDescription()
+        {
+            await Task.CompletedTask;
+        }
+
+        [TestMethod]
+        [System.ComponentModel.Description("Custom example description")]
+        public async Task ExampleTestWithDescription2()
+        {
+            await Task.CompletedTask;
+        }
+
+        [DataTestMethod]
+        [Description("thing {0} and thing {1}")]
+        [DataRow("some val 1", 32465)]
+        [DataRow("next valll", 1111)]
+        public async Task ExampleDataDrivenTest(string val1, int num2)
+        {
+            await Task.CompletedTask;
+        }
+    }
+
+    [TestClass]
+    public class CustomTestDescriptionWithMeadowTestMethodAttributes : ContractTest
+    {
+        [MeadowTestMethod]
+        [Description("Custom example description")]
+        public async Task ExampleTestWithDescription()
+        {
+            await Task.CompletedTask;
+        }
+
+        [MeadowDataTestMethod]
+        [Description("thing {0} and thing {1}")]
+        [DataRow("some val 1", 32465)]
+        [DataRow("next valll", 1111)]
+        public async Task ExampleDataDrivenTest(string val1, int num2)
+        {
+            await Task.CompletedTask;
+        }
+    }
+}

src/Meadow.UnitTestTemplate/ContractTest.cs

@@ -9,7 +9,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Net;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -18,11 +17,11 @@
 namespace Meadow.UnitTestTemplate
 {
 
-    [TestClass]
+    [MeadowTestClass]
     public abstract class ContractTest
     {
         #region Fields
-        private ulong _baseSnapshotID;
+        private ulong? _baseSnapshotID;
         private static Semaphore _sequentialExecutionSemaphore = new Semaphore(1, 1);
         #endregion
 
@@ -66,6 +65,7 @@ public async Task OnTestInitialize()
         {
             try
             {
+
                 // With parallel tests, all code should execute in pairs (main vs. external for every test)
                 // so we need to ensure sequential execution to avoid issues with other tests running and trying
                 // to snapshot, execute, restore on the external node, ending up with a race condition.
@@ -98,7 +98,10 @@ public async Task OnTestInitialize()
                 InternalTestState.StartTime = DateTimeOffset.UtcNow;
 
                 // Create a snapshot to revert to when test is completed.
-                _baseSnapshotID = await TestServices.TestNodeClient.Snapshot();
+                if (!_baseSnapshotID.HasValue)
+                {
+                    _baseSnapshotID = await TestServices.TestNodeClient.Snapshot();
+                }
 
                 // Determine what message to log
                 if (InternalTestState.InExternalNodeContext)
@@ -155,7 +158,7 @@ public async Task OnTestCleanup()
                 }
 
                 // Revert the node chain for the next unit test to start with a clean slate.
-                await TestServices.TestNodeClient.Revert(_baseSnapshotID);
+                await TestServices.TestNodeClient.Revert(_baseSnapshotID.Value);
 
                 // Calculate our time elapsed.
                 var testDuration = (InternalTestState.EndTime - InternalTestState.StartTime);
@@ -170,24 +173,21 @@ public async Task OnTestCleanup()
                     var testOutcome = new UnitTestResult
                     {
                         Namespace = TestContext.FullyQualifiedTestClassName,
-                        TestName = TestContext.TestName,
+                        TestName = InternalTestState.CustomDisplayName ?? TestContext.TestName,
                         Passed = TestContext.CurrentTestOutcome == UnitTestOutcome.Passed,
                         Duration = testDuration
                     };
 
                     // Add the test to our global testing result test output.
                     Global.UnitTestResults.Add(testOutcome);
-
+                    
                     // As this is our built in node, we put the test services back in the pool.
                     await Global.TestServicesPool.PutAsync(TestServices);
                 }
 
                 // Blank out the local test services after the test has completed.
                 TestServices = null;
 
-                // Set our cleanup as a success
-                InternalTestState.CleanupSuccess = true;
-
                 // If we are running an external node, we'll want to make tests run sequentially.
                 if (Global.ExternalNodeTestServices != null)
                 {
@@ -200,7 +200,8 @@ public async Task OnTestCleanup()
             }
             finally
             {
-
+                // Reset test state so its not reused in another test.
+                InternalTestState = null;
             }
         }
 

src/Meadow.UnitTestTemplate/ITestMethodExtensions.cs

@@ -0,0 +1,20 @@
+using ExposedObject;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Meadow.UnitTestTemplate
+{
+    static class ITestMethodExtensions
+    {
+        public static TestContext GetTestContext(this ITestMethod testMethod)
+        {
+            // Obtain our test method options
+            var testMethodOptions = Exposed.From(testMethod).TestMethodOptions;
+
+            // Obtain our test context.
+            var testContext = Exposed.From(testMethodOptions).TestContext as TestContext;
+
+            // Return the test context
+            return testContext;
+        }
+    }
+}

src/Meadow.UnitTestTemplate/InternalTestState.cs

@@ -28,10 +28,8 @@ internal class InternalTestState
         /// Indicates whether test initialization occurred without error.
         /// </summary>
         internal bool InitializationSuccess { get; set; }
-        /// <summary>
-        /// Indicates whether test cleanup occurred without error.
-        /// </summary>
-        internal bool CleanupSuccess { get; set; }
+
+        internal string CustomDisplayName { get; set; }
         #endregion
     }
 }

src/Meadow.UnitTestTemplate/MSTestRunner.cs

@@ -175,6 +175,13 @@ Action<TestResult> GetConsoleLogger()
 
                         stderrWriter.Flush();
                     }
+
+                    foreach (var msg in testResult.Messages)
+                    {
+                        stdoutWriter.WriteLine($"[{msg.Category}] {msg.Text}");
+                        stdoutWriter.Flush();
+                    }
+
                 }
             };
         }

src/Meadow.UnitTestTemplate/Meadow.UnitTestTemplate.csproj

@@ -11,6 +11,7 @@
     <PackageReference Include="Microsoft.UnitTestFramework.Extensions" Version="2.0.0" />
     <PackageReference Include="MSTest.TestFramework" Version="1.3.2" />
     <PackageReference Include="Microsoft.TestPlatform.TestHost" Version="15.8.0" />
+    <PackageReference Include="System.ComponentModel.Primitives" Version="4.3.0" />
     <PackageReference Include="System.Configuration.ConfigurationManager" Version="4.5.0" />
   </ItemGroup>
 

src/Meadow.UnitTestTemplate/MeadowTestClassAttribute.cs

@@ -0,0 +1,17 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Meadow.UnitTestTemplate
+{
+    public class MeadowTestClassAttribute : TestClassAttribute
+    {
+        public override TestMethodAttribute GetTestMethodAttribute(TestMethodAttribute testMethodAttribute)
+        {
+            return new MeadowTestMethodAttribute();
+        }
+
+        public override bool IsDefaultAttribute()
+        {
+            return base.IsDefaultAttribute();
+        }
+    }
+}