[fixes] UInt160 Class

benchmarks/Neo.Benchmarks/Benchmarks.UInt160.cs

@@ -0,0 +1,167 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Benchmarks.UInt160.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 BenchmarkDotNet.Attributes;
+
+namespace Neo.Benchmark;
+
+public class Benchmarks_UInt160
+{
+    [Benchmark]
+    public void TestOldUInt160Gernerator1()
+    {
+        OldUInt160 uInt160 = new OldUInt160();
+    }
+
+    [Benchmark]
+    public void TestOldUInt160Gernerator2()
+    {
+        OldUInt160 uInt160 = new OldUInt160(new byte[20]);
+    }
+
+    [Benchmark]
+    public void TestOldUInt160CompareTo()
+    {
+        byte[] temp = new byte[20];
+        temp[19] = 0x01;
+        OldUInt160 result = new OldUInt160(temp);
+        OldUInt160.Zero.CompareTo(OldUInt160.Zero);
+        OldUInt160.Zero.CompareTo(result);
+        result.CompareTo(OldUInt160.Zero);
+    }
+
+    [Benchmark]
+    public void TestOldUInt160Equals()
+    {
+        byte[] temp = new byte[20];
+        temp[19] = 0x01;
+        OldUInt160 result = new OldUInt160(temp);
+        OldUInt160.Zero.Equals(OldUInt160.Zero);
+        OldUInt160.Zero.Equals(result);
+        result.Equals(null);
+    }
+
+    [Benchmark]
+    public void TestOldUInt160Parse()
+    {
+        OldUInt160 result = OldUInt160.Parse("0x0000000000000000000000000000000000000000");
+        OldUInt160 result1 = OldUInt160.Parse("0000000000000000000000000000000000000000");
+    }
+
+    [Benchmark]
+    public void TestOldUInt160TryParse()
+    {
+        OldUInt160.TryParse(null, out _);
+        OldUInt160.TryParse("0x0000000000000000000000000000000000000000", out var temp);
+        OldUInt160.TryParse("0x1230000000000000000000000000000000000000", out temp);
+        OldUInt160.TryParse("000000000000000000000000000000000000000", out _);
+        OldUInt160.TryParse("0xKK00000000000000000000000000000000000000", out _);
+    }
+
+    [Benchmark]
+    public void TestOldUInt160OperatorLarger()
+    {
+        _ = OldUInt160.Zero > OldUInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestOldUInt160OperatorLargerAndEqual()
+    {
+        _ = OldUInt160.Zero >= OldUInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestOldUInt160OperatorSmaller()
+    {
+        _ = OldUInt160.Zero < OldUInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestOldUInt160OperatorSmallerAndEqual()
+    {
+        _ = OldUInt160.Zero <= OldUInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestGernerator1()
+    {
+        UInt160 uInt160 = new UInt160();
+    }
+
+    [Benchmark]
+    public void TestGernerator2()
+    {
+        UInt160 uInt160 = new UInt160(new byte[20]);
+    }
+
+    [Benchmark]
+    public void TestCompareTo()
+    {
+        byte[] temp = new byte[20];
+        temp[19] = 0x01;
+        UInt160 result = new UInt160(temp);
+        UInt160.Zero.CompareTo(UInt160.Zero);
+        UInt160.Zero.CompareTo(result);
+        result.CompareTo(UInt160.Zero);
+    }
+
+    [Benchmark]
+    public void TestEquals()
+    {
+        byte[] temp = new byte[20];
+        temp[19] = 0x01;
+        UInt160 result = new UInt160(temp);
+        UInt160.Zero.Equals(UInt160.Zero);
+        UInt160.Zero.Equals(result);
+        result.Equals(null);
+    }
+
+    [Benchmark]
+    public void TestParse()
+    {
+        UInt160 result = UInt160.Parse("0x0000000000000000000000000000000000000000");
+        UInt160 result1 = UInt160.Parse("0000000000000000000000000000000000000000");
+    }
+
+    [Benchmark]
+    public void TestTryParse()
+    {
+        UInt160.TryParse(null, out _);
+        UInt160.TryParse("0x0000000000000000000000000000000000000000", out var temp);
+        UInt160.TryParse("0x1230000000000000000000000000000000000000", out temp);
+        UInt160.TryParse("000000000000000000000000000000000000000", out _);
+        UInt160.TryParse("0xKK00000000000000000000000000000000000000", out _);
+    }
+
+    [Benchmark]
+    public void TestOperatorLarger()
+    {
+        _ = UInt160.Zero > UInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestOperatorLargerAndEqual()
+    {
+        _ = UInt160.Zero >= UInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestOperatorSmaller()
+    {
+        _ = UInt160.Zero < UInt160.Zero;
+    }
+
+    [Benchmark]
+    public void TestOperatorSmallerAndEqual()
+    {
+        _ = UInt160.Zero <= UInt160.Zero;
+    }
+}

benchmarks/Neo.Benchmarks/Neo.Benchmarks.csproj

@@ -5,6 +5,7 @@
     <TargetFrameworks>net8.0</TargetFrameworks>
     <RootNamespace>Neo</RootNamespace>
     <ImplicitUsings>enable</ImplicitUsings>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>

benchmarks/Neo.Benchmarks/OldUInt160.cs

@@ -0,0 +1,184 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// OldUInt160.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 Neo.Extensions;
+using Neo.IO;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+namespace Neo
+{
+    /// <summary>
+    /// Represents a 160-bit unsigned integer.
+    /// </summary>
+    [StructLayout(LayoutKind.Explicit, Size = 20)]
+    public class OldUInt160 : IComparable<OldUInt160>, IEquatable<OldUInt160>, ISerializable
+    {
+        /// <summary>
+        /// The length of <see cref="OldUInt160"/> values.
+        /// </summary>
+        public const int Length = 20;
+
+        /// <summary>
+        /// Represents 0.
+        /// </summary>
+        public static readonly OldUInt160 Zero = new();
+
+        [FieldOffset(0)] private ulong value1;
+        [FieldOffset(8)] private ulong value2;
+        [FieldOffset(16)] private uint value3;
+
+        public int Size => Length;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OldUInt160"/> class.
+        /// </summary>
+        public OldUInt160()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OldUInt160"/> class.
+        /// </summary>
+        /// <param name="value">The value of the <see cref="OldUInt160"/>.</param>
+        public unsafe OldUInt160(ReadOnlySpan<byte> value)
+        {
+            if (value.Length != Length) throw new FormatException();
+            fixed (ulong* p = &value1)
+            {
+                Span<byte> dst = new(p, Length);
+                value[..Length].CopyTo(dst);
+            }
+        }
+
+        public int CompareTo(OldUInt160 other)
+        {
+            int result = value3.CompareTo(other.value3);
+            if (result != 0) return result;
+            result = value2.CompareTo(other.value2);
+            if (result != 0) return result;
+            return value1.CompareTo(other.value1);
+        }
+
+        public void Deserialize(ref MemoryReader reader)
+        {
+            value1 = reader.ReadUInt64();
+            value2 = reader.ReadUInt64();
+            value3 = reader.ReadUInt32();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(obj, this)) return true;
+            return Equals(obj as OldUInt160);
+        }
+
+        public bool Equals(OldUInt160 other)
+        {
+            if (other is null) return false;
+            return value1 == other.value1
+                && value2 == other.value2
+                && value3 == other.value3;
+        }
+
+        public override int GetHashCode()
+        {
+            return (int)value1;
+        }
+
+        /// <summary>
+        /// Parses an <see cref="OldUInt160"/> from the specified <see cref="string"/>.
+        /// </summary>
+        /// <param name="value">An <see cref="OldUInt160"/> represented by a <see cref="string"/>.</param>
+        /// <returns>The parsed <see cref="OldUInt160"/>.</returns>
+        /// <exception cref="FormatException"><paramref name="value"/> is not in the correct format.</exception>
+        public static OldUInt160 Parse(string value)
+        {
+            if (!TryParse(value, out var result)) throw new FormatException();
+            return result;
+        }
+
+        public void Serialize(BinaryWriter writer)
+        {
+            writer.Write(value1);
+            writer.Write(value2);
+            writer.Write(value3);
+        }
+
+        public override string ToString()
+        {
+            return "0x" + this.ToArray().ToHexString(reverse: true);
+        }
+
+        /// <summary>
+        /// Parses an <see cref="OldUInt160"/> from the specified <see cref="string"/>.
+        /// </summary>
+        /// <param name="s">An <see cref="OldUInt160"/> represented by a <see cref="string"/>.</param>
+        /// <param name="result">The parsed <see cref="OldUInt160"/>.</param>
+        /// <returns><see langword="true"/> if an <see cref="OldUInt160"/> is successfully parsed; otherwise, <see langword="false"/>.</returns>
+        public static bool TryParse(string s, out OldUInt160 result)
+        {
+            if (s == null)
+            {
+                result = null;
+                return false;
+            }
+            if (s.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase))
+                s = s[2..];
+            if (s.Length != Length * 2)
+            {
+                result = null;
+                return false;
+            }
+            byte[] data = new byte[Length];
+            for (int i = 0; i < Length; i++)
+                if (!byte.TryParse(s.Substring(i * 2, 2), NumberStyles.AllowHexSpecifier, null, out data[Length - i - 1]))
+                {
+                    result = null;
+                    return false;
+                }
+            result = new OldUInt160(data);
+            return true;
+        }
+
+        public static bool operator ==(OldUInt160 left, OldUInt160 right)
+        {
+            if (ReferenceEquals(left, right)) return true;
+            if (left is null || right is null) return false;
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(OldUInt160 left, OldUInt160 right)
+        {
+            return !(left == right);
+        }
+
+        public static bool operator >(OldUInt160 left, OldUInt160 right)
+        {
+            return left.CompareTo(right) > 0;
+        }
+
+        public static bool operator >=(OldUInt160 left, OldUInt160 right)
+        {
+            return left.CompareTo(right) >= 0;
+        }
+
+        public static bool operator <(OldUInt160 left, OldUInt160 right)
+        {
+            return left.CompareTo(right) < 0;
+        }
+
+        public static bool operator <=(OldUInt160 left, OldUInt160 right)
+        {
+            return left.CompareTo(right) <= 0;
+        }
+    }
+}

benchmarks/Neo.Benchmarks/Program.cs

@@ -12,4 +12,5 @@
 using BenchmarkDotNet.Running;
 using Neo.Benchmark;
 
-BenchmarkRunner.Run<Benchmarks_PoCs>();
+// BenchmarkRunner.Run<Benchmarks_PoCs>();
+BenchmarkRunner.Run<Benchmarks_UInt160>();