TestEngine: add Checkpoints, RpcStorage and Dump to html

src/Neo.Compiler.CSharp/Options.cs

@@ -21,7 +21,7 @@ public enum GenerateArtifactsKind
             None,
             Source,
             Library,
-            SourceAndLibrary
+            All
         }
 
         public string? Output { get; set; }

src/Neo.Compiler.CSharp/Program.cs

@@ -193,14 +193,14 @@ private static int ProcessOutputs(Options options, string folder, CompilationCon
                 {
                     var artifact = manifest.GetArtifactsSource(baseName);
 
-                    if (options.GenerateArtifacts == Options.GenerateArtifactsKind.SourceAndLibrary || options.GenerateArtifacts == Options.GenerateArtifactsKind.Source)
+                    if (options.GenerateArtifacts == Options.GenerateArtifactsKind.All || options.GenerateArtifacts == Options.GenerateArtifactsKind.Source)
                     {
                         path = Path.Combine(outputFolder, $"{baseName}.artifacts.cs");
                         File.WriteAllText(path, artifact);
                         Console.WriteLine($"Created {path}");
                     }
 
-                    if (options.GenerateArtifacts == Options.GenerateArtifactsKind.SourceAndLibrary || options.GenerateArtifacts == Options.GenerateArtifactsKind.Library)
+                    if (options.GenerateArtifacts == Options.GenerateArtifactsKind.All || options.GenerateArtifacts == Options.GenerateArtifactsKind.Library)
                     {
                         try
                         {

src/Neo.SmartContract.Testing/Coverage/AbiMethod.cs

@@ -1,6 +1,7 @@
 using System;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -9,6 +10,8 @@
     [DebuggerDisplay("{Name},{PCount}")]
     public class AbiMethod : IEquatable<AbiMethod>
     {
+        private readonly string _toString;
+
         /// <summary>
         /// Method name
         /// </summary>
@@ -23,11 +26,12 @@
         /// Constructor
         /// </summary>
         /// <param name="name">Method name</param>
-        /// <param name="pCount">Parameters count</param>
-        public AbiMethod(string name, int pCount)
+        /// <param name="argsName">Arguments names</param>
+        public AbiMethod(string name, string[] argsName)
         {
             Name = name;
-            PCount = pCount;
+            PCount = argsName.Length;
+            _toString = name + $"({string.Join(",", argsName)})";
         }
 
         /// <summary>
@@ -55,14 +59,14 @@
 
                             return new AbiMethod[]
                             {
-                                new AbiMethod(nameRead, 0),
-                                new AbiMethod(nameWrite, 1)
+                                new AbiMethod(nameRead, Array.Empty<string>()),
+                                new AbiMethod(nameWrite, new string[]{ "value" })
                             };
                         }
 
                         // Only read property
 
-                        return new AbiMethod[] { new AbiMethod(nameRead, 0) };
+                        return new AbiMethod[] { new AbiMethod(nameRead, Array.Empty<string>()) };
                     }
                 }
             }
@@ -73,22 +77,22 @@
                     var display = mInfo.GetCustomAttribute<DisplayNameAttribute>();
                     var name = display is not null ? display.DisplayName : mInfo.Name;
 
-                    return new AbiMethod[] { new AbiMethod(name, mInfo.GetParameters().Length) };
+                    return new AbiMethod[] { new AbiMethod(name, mInfo.GetParameters().Select(u => u.Name ?? "arg").ToArray()) };
                 }
             }
 
             return Array.Empty<AbiMethod>();
         }
 
         public override bool Equals(object obj)
         {
             if (obj is not AbiMethod other) return false;
 
             return PCount == other.PCount && Name == other.Name;
         }
 
         bool IEquatable<AbiMethod>.Equals(AbiMethod other) => PCount == other.PCount && Name == other.Name;
         public override int GetHashCode() => HashCode.Combine(PCount, Name);
-        public override string ToString() => $"{Name},{PCount}";
+        public override string ToString() => _toString;
     }
 }

src/Neo.SmartContract.Testing/Coverage/CoverageHit.cs

@@ -1,16 +1,23 @@
+using Neo.VM;
 using System;
 using System.Diagnostics;
+using System.Text.RegularExpressions;
 
 namespace Neo.SmartContract.Testing.Coverage
 {
-    [DebuggerDisplay("Offset:{Offset}, OutOfScript:{OutOfScript}, Hits:{Hits}, GasTotal:{GasTotal}, GasMin:{GasMin}, GasMax:{GasMax}, GasAvg:{GasAvg}")]
+    [DebuggerDisplay("Offset:{Offset}, Description:{Description}, OutOfScript:{OutOfScript}, Hits:{Hits}, GasTotal:{GasTotal}, GasMin:{GasMin}, GasMax:{GasMax}, GasAvg:{GasAvg}")]
     public class CoverageHit
     {
         /// <summary>
         /// The instruction offset
         /// </summary>
         public int Offset { get; }
 
+        /// <summary>
+        /// The instruction description
+        /// </summary>
+        public string Description { get; }
+
         /// <summary>
         /// The instruction is out of the script
         /// </summary>
@@ -45,10 +52,12 @@
         /// Constructor
         /// </summary>
         /// <param name="offset">Offset</param>
+        /// <param name="description">Decription</param>
         /// <param name="outOfScript">Out of script</param>
-        public CoverageHit(int offset, bool outOfScript = false)
+        public CoverageHit(int offset, string description, bool outOfScript = false)
         {
             Offset = offset;
+            Description = description;
             OutOfScript = outOfScript;
         }
 
@@ -104,7 +113,7 @@
         /// <returns>CoverageData</returns>
         public CoverageHit Clone()
         {
-            return new CoverageHit(Offset, OutOfScript)
+            return new CoverageHit(Offset, Description, OutOfScript)
             {
                 GasMax = GasMax,
                 GasMin = GasMin,
@@ -113,13 +122,66 @@
             };
         }
 
+        /// <summary>
+        /// Return description from instruction
+        /// </summary>
+        /// <param name="instruction">Instruction</param>
+        /// <returns>Description</returns>
+        public static string DescriptionFromInstruction(Instruction instruction)
+        {
+            if (instruction.Operand.Length > 0)
+            {
+                var ret = instruction.OpCode.ToString() + " 0x" + instruction.Operand.ToArray().ToHexString();
+
+                switch (instruction.OpCode)
+                {
+                    case OpCode.JMP:
+                    case OpCode.JMPIF:
+                    case OpCode.JMPIFNOT:
+                    case OpCode.JMPEQ:
+                    case OpCode.JMPNE:
+                    case OpCode.JMPGT:
+                    case OpCode.JMPGE:
+                    case OpCode.JMPLT:
+                    case OpCode.JMPLE: return ret + $" ({instruction.TokenI8})";
+                    case OpCode.JMP_L:
+                    case OpCode.JMPIF_L:
+                    case OpCode.JMPIFNOT_L:
+                    case OpCode.JMPEQ_L:
+                    case OpCode.JMPNE_L:
+                    case OpCode.JMPGT_L:
+                    case OpCode.JMPGE_L:
+                    case OpCode.JMPLT_L:
+                    case OpCode.JMPLE_L: return ret + $" ({instruction.TokenI32})";
+                    case OpCode.SYSCALL:
+                        {
+                            if (ApplicationEngine.Services.TryGetValue(instruction.TokenU32, out var syscall))
+                            {
+                                return ret + $" ('{syscall.Name}')";
+                            }
+
+                            return ret;
+                        }
+                }
+
+                if (instruction.Operand.Span.TryGetString(out var str) && Regex.IsMatch(str, @"^[a-zA-Z0-9_]+$"))
+                {
+                    return ret + $" '{str}'";
+                }
+
+                return ret;
+            }
+
+            return instruction.OpCode.ToString();
+        }
+
         /// <summary>
         /// String representation
         /// </summary>
         /// <returns></returns>
         public override string ToString()
         {
-            return $"Offset:{Offset}, OutOfScript:{OutOfScript}, Hits:{Hits}, GasTotal:{GasTotal}, GasMin:{GasMin}, GasMax:{GasMax}, GasAvg:{GasAvg}";
+            return $"Offset:{Offset}, Description:{Description}, OutOfScript:{OutOfScript}, Hits:{Hits}, GasTotal:{GasTotal}, GasMin:{GasMin}, GasMax:{GasMax}, GasAvg:{GasAvg}";
         }
     }
 }