Add and update some Unit tests in IO module

neo.UnitTests/IO/Caching/UT_FifoSet.cs → neo.UnitTests/IO/Caching/UT_FIFOSet.cs

@@ -2,6 +2,7 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.IO.Caching;
 using System;
+using System.Collections;
 using System.Linq;
 
 namespace Neo.UnitTests.IO.Caching
@@ -81,12 +82,38 @@ public void TestAdd()
                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
                 0x01, 0x02
             });
-            var set = new FIFOSet<UInt256>(1, 1);
-            set.Add(a);
-            set.Add(b);
+            var set = new FIFOSet<UInt256>(1, 1)
+            {
+                a,
+                b
+            };
             CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { b });
         }
 
+        [TestMethod]
+        public void TestGetEnumerator()
+        {
+            var a = new UInt256(new byte[32] {
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01
+            });
+            var b = new UInt256(new byte[32] {
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                0x01, 0x02
+            });
+            var set = new FIFOSet<UInt256>(1, 1)
+            {
+                a,
+                b
+            };
+            IEnumerable ie = set;
+            ie.GetEnumerator().Should().NotBeNull();
+        }
+
         [TestMethod]
         public void TestExceptWith()
         {
@@ -109,10 +136,12 @@ public void TestExceptWith()
                 0x01, 0x03
             });
 
-            var set = new FIFOSet<UInt256>(10);
-            set.Add(a);
-            set.Add(b);
-            set.Add(c);
+            var set = new FIFOSet<UInt256>(10)
+            {
+                a,
+                b,
+                c
+            };
             set.ExceptWith(new UInt256[] { b, c });
             CollectionAssert.AreEqual(set.ToArray(), new UInt256[] { a });
         }

neo.UnitTests/IO/Caching/UT_OrderedDictionary.cs

@@ -1,6 +1,8 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.IO.Caching;
+using System.Collections;
+using System.Collections.Generic;
 
 namespace Neo.UnitTests.IO.Caching
 {
@@ -83,5 +85,45 @@ public void TestTryGetValue()
             od.TryGetValue("d", out uint j).Should().BeFalse();
             j.Should().Be(0);
         }
+
+        [TestMethod]
+        public void TestCollectionAddAndContains()
+        {
+            var pair = new KeyValuePair<string, uint>("d", 4);
+            ICollection<KeyValuePair<string, uint>> collection = od;
+            collection.Add(pair);
+            collection.Contains(pair).Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void TestCollectionCopyTo()
+        {
+            var arr = new KeyValuePair<string, uint>[3];
+            ICollection<KeyValuePair<string, uint>> collection = od;
+            collection.CopyTo(arr, 0);
+            arr[0].Key.Should().Be("a");
+            arr[0].Value.Should().Be(1);
+            arr[1].Key.Should().Be("b");
+            arr[1].Value.Should().Be(2);
+            arr[2].Key.Should().Be("c");
+            arr[2].Value.Should().Be(3);
+        }
+
+        [TestMethod]
+        public void TestCollectionRemove()
+        {
+            ICollection<KeyValuePair<string, uint>> collection = od;
+            var pair = new KeyValuePair<string, uint>("a", 1);
+            collection.Remove(pair);
+            collection.Contains(pair).Should().BeFalse();
+            collection.Count.Should().Be(2);
+        }
+
+        [TestMethod]
+        public void TestGetEnumerator()
+        {
+            IEnumerable collection = od;
+            collection.GetEnumerator().MoveNext().Should().BeTrue();
+        }
     }
 }

neo.UnitTests/IO/Caching/UT_ReflectionCache.cs

@@ -0,0 +1,80 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.IO.Caching;
+using System;
+
+namespace Neo.UnitTests.IO.Caching
+{
+    public class TestItem { }
+
+    public class TestItem1 : TestItem { }
+
+    public class TestItem2 : TestItem { }
+
+    public enum MyTestEnum : byte
+    {
+        [ReflectionCache(typeof(TestItem1))]
+        Item1 = 0x00,
+
+        [ReflectionCache(typeof(TestItem2))]
+        Item2 = 0x01,
+    }
+
+    public enum MyEmptyEnum : byte { }
+
+    [TestClass]
+    public class UT_ReflectionCache
+    {
+        ReflectionCache<byte> reflectionCache;
+
+        [TestInitialize]
+        public void SetUp()
+        {
+            reflectionCache = ReflectionCache<byte>.CreateFromEnum<MyTestEnum>();
+        }
+
+        [TestMethod]
+        public void TestCreateFromEnum()
+        {
+            reflectionCache.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void TestCreateFromObjectNotEnum()
+        {
+            Action action = () => ReflectionCache<byte>.CreateFromEnum<int>();
+            action.ShouldThrow<ArgumentException>();
+        }
+
+        [TestMethod]
+        public void TestCreateFromEmptyEnum()
+        {
+            reflectionCache = ReflectionCache<byte>.CreateFromEnum<MyEmptyEnum>();
+            reflectionCache.Count.Should().Be(0);
+        }
+
+        [TestMethod]
+        public void TestCreateInstance()
+        {
+            object item1 = reflectionCache.CreateInstance((byte)MyTestEnum.Item1, null);
+            (item1 is TestItem1).Should().BeTrue();
+
+            object item2 = reflectionCache.CreateInstance((byte)MyTestEnum.Item2, null);
+            (item2 is TestItem2).Should().BeTrue();
+
+            object item3 = reflectionCache.CreateInstance(0x02, null);
+            item3.Should().BeNull();
+        }
+
+        [TestMethod]
+        public void TestCreateInstance2()
+        {
+            TestItem defaultItem = new TestItem1();
+            object item2 = reflectionCache.CreateInstance((byte)MyTestEnum.Item2, defaultItem);
+            (item2 is TestItem2).Should().BeTrue();
+
+            object item1 = reflectionCache.CreateInstance(0x02, new TestItem1());
+            (item1 is TestItem1).Should().BeTrue();
+        }
+    }
+}

neo.UnitTests/IO/Caching/UT_RelayCache.cs

@@ -0,0 +1,41 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.IO.Caching;
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.UnitTests.IO.Caching
+{
+    [TestClass]
+    public class UT_RelayCache
+    {
+        RelayCache relayCache;
+
+        [TestInitialize]
+        public void SetUp()
+        {
+            relayCache = new RelayCache(10);
+        }
+
+        [TestMethod]
+        public void TestGetKeyForItem()
+        {
+            Transaction tx = new Transaction()
+            {
+                Version = 0,
+                Nonce = 1,
+                Sender = UInt160.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff01"),
+                SystemFee = 0,
+                NetworkFee = 0,
+                ValidUntilBlock = 100,
+                Attributes = new TransactionAttribute[0],
+                Script = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04 },
+                Witnesses = new Witness[0]
+            };
+            relayCache.Add(tx);
+
+            relayCache.Contains(tx).Should().BeTrue();
+            relayCache.TryGet(tx.Hash, out IInventory tmp).Should().BeTrue();
+            (tmp is Transaction).Should().BeTrue();
+        }
+    }
+}