11664859480

Committed 04 Nov 2024 01:08PM UTC coverage: 55.895% (+0.004%) from 55.891%

Build # 11664859480

Build Type

Pull #3559

github

Committed by

web-flow

Commit Message

Merge 8d066c5b0 into a856982dd

Pull Request Pull Request #3559: use `Xxhash3` for StorageKey.GetHashCode

Run Details

5794 of 8934 branches covered (64.85%)

Branch coverage included in aggregate %.

10 of 21 new or added lines in 4 files covered. (47.62%)

1 existing line in 1 file now uncovered.

21745 of 40335 relevant lines covered (53.91%)

86114.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/tests/Neo.UnitTests/Ledger/UT_StorageKey.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// UT_StorageKey.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 FluentAssertions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Neo.Cryptography;
using Neo.SmartContract;
using System;

namespace Neo.UnitTests.Ledger
{
    [TestClass]
    public class UT_StorageKey
    {
        [TestMethod]
        public void Id_Get()
        {
            var uut = new StorageKey { Id = 1, Key = new byte[] { 0x01 } };
            uut.Id.Should().Be(1);
        }

        [TestMethod]
        public void Id_Set()
        {
            int val = 1;
            StorageKey uut = new() { Id = val };
            uut.Id.Should().Be(val);
        }

        [TestMethod]
        public void Key_Set()
        {
            byte[] val = new byte[] { 0x42, 0x32 };
            StorageKey uut = new() { Key = val };
            uut.Key.Length.Should().Be(2);
            uut.Key.Span[0].Should().Be(val[0]);
            uut.Key.Span[1].Should().Be(val[1]);
        }

        [TestMethod]
        public void Equals_SameObj()
        {
            StorageKey uut = new();
            uut.Equals(uut).Should().BeTrue();
        }

        [TestMethod]
        public void Equals_Null()
        {
            StorageKey uut = new();
            uut.Equals(null).Should().BeFalse();
        }

        [TestMethod]
        public void Equals_SameHash_SameKey()
        {
            int val = 0x42000000;
            byte[] keyVal = TestUtils.GetByteArray(10, 0x42);
            StorageKey newSk = new StorageKey
            {
                Id = val,
                Key = keyVal
            };
            StorageKey uut = new() { Id = val, Key = keyVal };
            uut.Equals(newSk).Should().BeTrue();
        }

        [TestMethod]
        public void Equals_DiffHash_SameKey()
        {
            int val = 0x42000000;
            byte[] keyVal = TestUtils.GetByteArray(10, 0x42);
            StorageKey newSk = new StorageKey
            {
                Id = val,
                Key = keyVal
            };
            StorageKey uut = new() { Id = 0x78000000, Key = keyVal };
            uut.Equals(newSk).Should().BeFalse();
        }

        [TestMethod]
        public void Equals_SameHash_DiffKey()
        {
            int val = 0x42000000;
            byte[] keyVal = TestUtils.GetByteArray(10, 0x42);
            StorageKey newSk = new StorageKey
            {
                Id = val,
                Key = keyVal
            };
            StorageKey uut = new() { Id = val, Key = TestUtils.GetByteArray(10, 0x88) };
            uut.Equals(newSk).Should().BeFalse();
        }

        [TestMethod]
        public void GetHashCode_Get()
        {
            var data = TestUtils.GetByteArray(10, 0x42);
            StorageKey uut = new() { Id = 0x42000000, Key = data };
            uut.GetHashCode().Should().Be(HashCode.Combine(0x42000000, data.XxHash3_32()));
        }

        [TestMethod]
        public void Equals_Obj()
        {
            StorageKey uut = new();
            uut.Equals(1u).Should().BeFalse();
            uut.Equals((object)uut).Should().BeTrue();
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// UT_StorageKey.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using FluentAssertions;
13	using Microsoft.VisualStudio.TestTools.UnitTesting;
14	using Neo.Cryptography;
15	using Neo.SmartContract;
16	using System;
17
18	namespace Neo.UnitTests.Ledger
19	{
20	[TestClass]
21	public class UT_StorageKey
22	{
23	[TestMethod]
24	public void Id_Get()
25	{	×
26	var uut = new StorageKey { Id = 1, Key = new byte[] { 0x01 } };	×
27	uut.Id.Should().Be(1);	×
28	}	×
29
30	[TestMethod]
31	public void Id_Set()
32	{	×
33	int val = 1;	×
34	StorageKey uut = new() { Id = val };	×
35	uut.Id.Should().Be(val);	×
36	}	×
37
38	[TestMethod]
39	public void Key_Set()
40	{	×
41	byte[] val = new byte[] { 0x42, 0x32 };	×
42	StorageKey uut = new() { Key = val };	×
43	uut.Key.Length.Should().Be(2);	×
44	uut.Key.Span[0].Should().Be(val[0]);	×
45	uut.Key.Span[1].Should().Be(val[1]);	×
46	}	×
47
48	[TestMethod]
49	public void Equals_SameObj()
50	{	×
51	StorageKey uut = new();	×
52	uut.Equals(uut).Should().BeTrue();	×
53	}	×
54
55	[TestMethod]
56	public void Equals_Null()
57	{	×
58	StorageKey uut = new();	×
59	uut.Equals(null).Should().BeFalse();	×
60	}	×
61
62	[TestMethod]
63	public void Equals_SameHash_SameKey()
64	{	×
65	int val = 0x42000000;	×
66	byte[] keyVal = TestUtils.GetByteArray(10, 0x42);	×
67	StorageKey newSk = new StorageKey	×
68	{	×
69	Id = val,	×
70	Key = keyVal	×
71	};	×
72	StorageKey uut = new() { Id = val, Key = keyVal };	×
73	uut.Equals(newSk).Should().BeTrue();	×
74	}	×
75
76	[TestMethod]
77	public void Equals_DiffHash_SameKey()
78	{	×
79	int val = 0x42000000;	×
80	byte[] keyVal = TestUtils.GetByteArray(10, 0x42);	×
81	StorageKey newSk = new StorageKey	×
82	{	×
83	Id = val,	×
84	Key = keyVal	×
85	};	×
86	StorageKey uut = new() { Id = 0x78000000, Key = keyVal };	×
87	uut.Equals(newSk).Should().BeFalse();	×
88	}	×
89
90	[TestMethod]
91	public void Equals_SameHash_DiffKey()
92	{	×
93	int val = 0x42000000;	×
94	byte[] keyVal = TestUtils.GetByteArray(10, 0x42);	×
95	StorageKey newSk = new StorageKey	×
96	{	×
97	Id = val,	×
98	Key = keyVal	×
99	};	×
100	StorageKey uut = new() { Id = val, Key = TestUtils.GetByteArray(10, 0x88) };	×
101	uut.Equals(newSk).Should().BeFalse();	×
102	}	×
103
104	[TestMethod]
105	public void GetHashCode_Get()
106	{	×
NEW 107	var data = TestUtils.GetByteArray(10, 0x42);	×
NEW 108	StorageKey uut = new() { Id = 0x42000000, Key = data };	×
NEW 109	uut.GetHashCode().Should().Be(HashCode.Combine(0x42000000, data.XxHash3_32()));	×
UNCOV 110	}	×
111
112	[TestMethod]
113	public void Equals_Obj()
114	{	×
115	StorageKey uut = new();	×
116	uut.Equals(1u).Should().BeFalse();	×
117	uut.Equals((object)uut).Should().BeTrue();	×
118	}	×
119	}
120	}

neo-project / neo / 11664859480

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous