Fix UT for PR#2215

src/neo/SmartContract/Native/HashIndexState.cs

@@ -4,7 +4,7 @@
 
 namespace Neo.SmartContract.Native
 {
-    class HashIndexState : IInteroperable
+    internal class HashIndexState : IInteroperable
     {
         public UInt256 Hash;
         public uint Index;

src/neo/SmartContract/Native/LedgerContract.cs

@@ -181,7 +181,7 @@ private Transaction GetTransactionFromBlock(DataCache snapshot, byte[] blockInde
             return GetTransaction(snapshot, block.Hashes[txIndex + 1]);
         }
 
-        private static TrimmedBlock Trim(Block block)
+        internal static TrimmedBlock Trim(Block block)
         {
             return new TrimmedBlock
             {

src/neo/SmartContract/StorageItem.cs

@@ -3,11 +3,12 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Numerics;
 
 namespace Neo.SmartContract
 {
-    public class StorageItem : ISerializable
+    public class StorageItem : ISerializable, IEquatable<StorageItem>
     {
         private byte[] value;
         private object cache;
@@ -112,6 +113,19 @@ public void Set(BigInteger integer)
             value = null;
         }
 
+        public bool Equals(StorageItem other)
+        {
+            if (other == null) return false;
+
+            return IsConstant == other.IsConstant &&
+                Value.SequenceEqual(other.Value);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(IsConstant, Value.Length);
+        }
+
         public static implicit operator BigInteger(StorageItem item)
         {
             item.cache ??= new BigInteger(item.value);

tests/neo.UnitTests/IO/Caching/UT_CloneCache.cs

@@ -5,19 +5,20 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 
 namespace Neo.UnitTests.IO.Caching
 {
     [TestClass]
     public class UT_CloneCache
     {
         ClonedCache clonedCache;
-        MyDataCache<MyKey, MyValue> myDataCache;
+        MyDataCache myDataCache;
 
         [TestInitialize]
         public void Init()
         {
-            myDataCache = new MyDataCache<MyKey, MyValue>();
+            myDataCache = new MyDataCache();
             clonedCache = new ClonedCache(myDataCache);
         }
 
@@ -112,9 +113,9 @@ public void TestUpdateInternal()
             myDataCache.Add(new MyKey("key2"), new MyValue("value2"));
             myDataCache.InnerDict.Add(new MyKey("key3"), new MyValue("value3"));
 
-            clonedCache.GetAndChange(new MyKey("key1")).Value = "value_new_1";
-            clonedCache.GetAndChange(new MyKey("key2")).Value = "value_new_2";
-            clonedCache.GetAndChange(new MyKey("key3")).Value = "value_new_3";
+            clonedCache.GetAndChange(new MyKey("key1")).Value = Encoding.Default.GetBytes("value_new_1");
+            clonedCache.GetAndChange(new MyKey("key2")).Value = Encoding.Default.GetBytes("value_new_2");
+            clonedCache.GetAndChange(new MyKey("key3")).Value = Encoding.Default.GetBytes("value_new_3");
 
             clonedCache.Commit();
 

tests/neo.UnitTests/IO/Caching/UT_DataCache.cs

@@ -2,84 +2,70 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.IO;
 using Neo.Persistence;
+using Neo.SmartContract;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 
 namespace Neo.UnitTests.IO.Caching
 {
-    class MyKey : ISerializable, IEquatable<MyKey>, IComparable<MyKey>
+    class MyKey : StorageKey, IEquatable<MyKey>
     {
-        public string Key;
-
         public int Size => Key.Length;
 
-        public MyKey() { }
+        public MyKey(UInt256 hash)
+        {
+            Key = hash.ToArray();
+        }
 
         public MyKey(string val)
         {
-            Key = val;
+            Key = Encoding.Default.GetBytes(val);
         }
 
         public void Deserialize(BinaryReader reader)
         {
-            Key = reader.ReadString();
+            Key = Encoding.Default.GetBytes(reader.ReadString());
         }
 
         public void Serialize(BinaryWriter writer)
         {
             writer.Write(Key);
         }
-
         public bool Equals(MyKey other)
         {
-            return Key.Equals(other.Key);
+            return Key.SequenceEqual(other.Key);
         }
 
         public override bool Equals(object obj)
         {
-            if (!(obj is MyKey key)) return false;
-            return Equals(key);
+            if (obj is not MyKey other) return false;
+            return Key.SequenceEqual(other.Key);
         }
 
         public override int GetHashCode()
         {
-            return Key.GetHashCode();
-        }
-
-        public int CompareTo(MyKey obj)
-        {
-            return Key.CompareTo(obj.Key);
+            return Key.Length;
         }
     }
 
-    public class MyValue : ISerializable
+    public class MyValue : StorageItem, ISerializable, IEquatable<MyValue>
     {
-        public string Value;
-
-        public int Size => Value.Length;
-
-        public MyValue() { }
-
-        public MyValue(string val)
-        {
-            Value = val;
-        }
-
-        public void Deserialize(BinaryReader reader)
+        public MyValue(UInt256 hash)
         {
-            Value = reader.ReadString();
+            Value = hash.ToArray();
         }
 
-        public void Serialize(BinaryWriter writer)
+        public MyValue(string val)
         {
-            writer.Write(Value);
+            Value = Encoding.Default.GetBytes(val);
         }
 
-        public MyValue Clone()
+        public MyValue(byte[] val)
         {
-            return new MyValue(Value);
+            Value = val;
         }
 
         public void FromReplica(MyValue replica)
@@ -89,83 +75,81 @@ public void FromReplica(MyValue replica)
 
         public bool Equals(MyValue other)
         {
-            return (Value == null && other.Value == null) || Value.Equals(other.Value);
+            return (Value == null && other.Value == null) || Value.SequenceEqual(other.Value);
         }
 
         public override bool Equals(object obj)
         {
-            if (!(obj is MyValue key)) return false;
-            return Equals(key);
+            if (obj is not StorageItem other) return false;
+            return (Value == null && other.Value == null) || Value.SequenceEqual(other.Value);
         }
 
         public override int GetHashCode()
         {
-            return Value.GetHashCode();
+            return Value.Length;
         }
     }
 
-    class MyDataCache<TKey, TValue> : DataCache
-           where TKey : IEquatable<TKey>, ISerializable, new()
-           where TValue : class, ISerializable, new()
+    class MyDataCache : DataCache
     {
-        public Dictionary<TKey, TValue> InnerDict = new Dictionary<TKey, TValue>();
+        public Dictionary<StorageKey, StorageItem> InnerDict = new Dictionary<StorageKey, StorageItem>();
 
-        protected override void DeleteInternal(TKey key)
+        protected override void DeleteInternal(StorageKey key)
         {
             InnerDict.Remove(key);
         }
 
-        protected override void AddInternal(TKey key, TValue value)
+        protected override void AddInternal(StorageKey key, StorageItem value)
         {
             InnerDict.Add(key, value);
         }
 
-        protected override IEnumerable<(TKey, TValue)> SeekInternal(byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
+        protected override IEnumerable<(StorageKey, StorageItem)> SeekInternal(byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
         {
             if (direction == SeekDirection.Forward)
                 return InnerDict.OrderBy(kvp => kvp.Key).Where(kvp => ByteArrayComparer.Default.Compare(kvp.Key.ToArray(), keyOrPrefix) >= 0).Select(p => (p.Key, p.Value));
             else
                 return InnerDict.OrderByDescending(kvp => kvp.Key).Where(kvp => ByteArrayComparer.Reverse.Compare(kvp.Key.ToArray(), keyOrPrefix) >= 0).Select(p => (p.Key, p.Value));
         }
 
-        protected override TValue GetInternal(TKey key)
+        protected override StorageItem GetInternal(StorageKey key)
         {
-            if (InnerDict.TryGetValue(key, out TValue value))
+            if (InnerDict.TryGetValue(key, out var value))
             {
-                return value.Clone();
+                return new MyValue(value.Value);
             }
             throw new KeyNotFoundException();
         }
 
-        protected override TValue TryGetInternal(TKey key)
+        protected override StorageItem TryGetInternal(StorageKey key)
         {
-            if (InnerDict.TryGetValue(key, out TValue value))
+            if (InnerDict.TryGetValue(key, out var value))
             {
-                return value.Clone();
+                return new MyValue(value.Value);
             }
             return null;
         }
 
-        protected override bool ContainsInternal(TKey key)
+        protected override bool ContainsInternal(StorageKey key)
         {
             return InnerDict.ContainsKey(key);
         }
 
-        protected override void UpdateInternal(TKey key, TValue value)
+        protected override void UpdateInternal(StorageKey key, StorageItem value)
         {
-            InnerDict[key] = value;
+            InnerDict[key] = new MyValue(value.Value);
         }
     }
 
     [TestClass]
     public class UT_DataCache
     {
-        MyDataCache<MyKey, MyValue> myDataCache;
+        MyDataCache myDataCache;
 
         [TestInitialize]
         public void Initialize()
         {
-            myDataCache = new MyDataCache<MyKey, MyValue>();
+            myDataCache = new MyDataCache();
         }
 
         [TestMethod]
@@ -291,10 +275,10 @@ public void TestSeek()
             items[0].Value.Should().Be(new MyValue("value3"));
             items[1].Key.Should().Be(new MyKey("key2"));
             items[1].Value.Should().Be(new MyValue("value2"));
-            items.Count().Should().Be(3);
+            items.Length.Should().Be(3);
 
             items = myDataCache.Seek(new MyKey("key5").ToArray(), SeekDirection.Forward).ToArray();
-            items.Count().Should().Be(0);
+            items.Length.Should().Be(0);
         }
 
         [TestMethod]
@@ -311,11 +295,11 @@ public void TestFindRange()
             items[0].Value.Should().Be(new MyValue("value3"));
             items[1].Key.Should().Be(new MyKey("key4"));
             items[1].Value.Should().Be(new MyValue("value4"));
-            items.Count().Should().Be(2);
+            items.Length.Should().Be(2);
 
             // case 2 Need to sort the cache of myDataCache
 
-            myDataCache = new MyDataCache<MyKey, MyValue>();
+            myDataCache = new MyDataCache();
             myDataCache.Add(new MyKey("key1"), new MyValue("value1"));
             myDataCache.Add(new MyKey("key2"), new MyValue("value2"));
 
@@ -327,11 +311,11 @@ public void TestFindRange()
             items[0].Value.Should().Be(new MyValue("value3"));
             items[1].Key.Should().Be(new MyKey("key4"));
             items[1].Value.Should().Be(new MyValue("value4"));
-            items.Count().Should().Be(2);
+            items.Length.Should().Be(2);
 
             // case 3 FindRange by Backward
 
-            myDataCache = new MyDataCache<MyKey, MyValue>();
+            myDataCache = new MyDataCache();
             myDataCache.Add(new MyKey("key1"), new MyValue("value1"));
             myDataCache.Add(new MyKey("key2"), new MyValue("value2"));
 
@@ -344,7 +328,7 @@ public void TestFindRange()
             items[0].Value.Should().Be(new MyValue("value5"));
             items[1].Key.Should().Be(new MyKey("key4"));
             items[1].Value.Should().Be(new MyValue("value4"));
-            items.Count().Should().Be(2);
+            items.Length.Should().Be(2);
         }
 
         [TestMethod]
@@ -413,7 +397,7 @@ public void TestTryGet()
         [TestMethod]
         public void TestFindInvalid()
         {
-            var myDataCache = new MyDataCache<MyKey, MyValue>();
+            var myDataCache = new MyDataCache();
             myDataCache.Add(new MyKey("key1"), new MyValue("value1"));
 
             myDataCache.InnerDict.Add(new MyKey("key2"), new MyValue("value2"));