[Neo Core Storage] Implicit methods and tests

src/Neo/SmartContract/StorageItem.cs

@@ -193,5 +193,15 @@ public static implicit operator BigInteger(StorageItem item)
  item.cache ??= new BigInteger(item.value.Span);
  return (BigInteger)item.cache;
  }
+
+ public static implicit operator StorageItem(BigInteger value)
+ {
+ return new StorageItem(value);
+ }
+
+ public static implicit operator StorageItem(byte[] value)
+ {
+ return new StorageItem(value);
+ }
  }
 }

src/Neo/SmartContract/StorageKey.cs

@@ -12,6 +12,7 @@
 using Neo.Cryptography;
 using System;
 using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
 
 namespace Neo.SmartContract
 {
@@ -79,5 +80,14 @@ public byte[] ToArray()
  }
  return cache;
  }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static implicit operator StorageKey(byte[] value) => new StorageKey(value);
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static implicit operator StorageKey(ReadOnlyMemory<byte> value) => new StorageKey(value.Span.ToArray());
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static implicit operator StorageKey(ReadOnlySpan<byte> value) => new StorageKey(value.ToArray());
  }
 }

tests/Neo.UnitTests/SmartContract/UT_Storage.cs

@@ -0,0 +1,74 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// UT_Storage.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.SmartContract;
+using Neo.VM;
+using Neo.VM.Types;
+using System;
+using System.Linq;
+using System.Numerics;
+
+namespace Neo.UnitTests.SmartContract
+{
+ [TestClass]
+ public class UT_Storage
+ {
+ [TestMethod]
+ public void TestStorageKey()
+ {
+ // Test data
+ byte[] keyData = [0x00, 0x00, 0x00, 0x00, 0x12];
+ var keyMemory = new ReadOnlyMemory<byte>(keyData);
+
+ // Test implicit conversion from byte[] to StorageKey
+ StorageKey storageKeyFromArray = keyData;
+ Assert.AreEqual(0, storageKeyFromArray.Id);
+ Assert.IsTrue(keyMemory.Span.ToArray().Skip(sizeof(int)).SequenceEqual(storageKeyFromArray.Key.Span.ToArray()));
+
+ // Test implicit conversion from ReadOnlyMemory<byte> to StorageKey
+ StorageKey storageKeyFromMemory = keyMemory;
+ Assert.AreEqual(0, storageKeyFromMemory.Id);
+ Assert.IsTrue(keyMemory.Span.ToArray().Skip(sizeof(int)).SequenceEqual(storageKeyFromMemory.Key.Span.ToArray()));
+
+ // Test CreateSearchPrefix method
+ byte[] prefix = { 0xAA };
+ var searchPrefix = StorageKey.CreateSearchPrefix(0, prefix);
+ var expectedPrefix = BitConverter.GetBytes(0).Concat(prefix).ToArray();
+ Assert.IsTrue(expectedPrefix.SequenceEqual(searchPrefix));
+
+ // Test Equals method
+ var storageKey1 = new StorageKey { Id = 0, Key = keyMemory };
+ var storageKey2 = new StorageKey { Id = 0, Key = keyMemory };
+ var storageKeyDifferentId = new StorageKey { Id = 0 + 1, Key = keyMemory };
+ var storageKeyDifferentKey = new StorageKey { Id = 0, Key = new ReadOnlyMemory<byte>([0x04]) };
+ Assert.AreEqual(storageKey1, storageKey2);
+ Assert.AreNotEqual(storageKey1, storageKeyDifferentId);
+ Assert.AreNotEqual(storageKey1, storageKeyDifferentKey);
+ }
+
+ [TestMethod]
+ public void TestStorageItem()
+ {
+ // Test data
+ byte[] keyData = [0x00, 0x00, 0x00, 0x00, 0x12];
+ BigInteger bigInteger = new BigInteger(1234567890);
+
+ // Test implicit conversion from byte[] to StorageItem
+ StorageItem storageItemFromArray = keyData;
+ Assert.IsTrue(keyData.SequenceEqual(storageItemFromArray.Value.Span.ToArray()));
+
+ // Test implicit conversion from BigInteger to StorageItem
+ StorageItem storageItemFromBigInteger = bigInteger;
+ Assert.AreEqual(bigInteger, (BigInteger)storageItemFromBigInteger);
+ }
+ }
+}