11362976181

Committed 16 Oct 2024 09:35AM UTC coverage: 55.835% (-0.09%) from 55.924%

Build # 11362976181

Build Type

Pull #3531

github

Committed by

web-flow

Commit Message

Merge 2162dfa0f into bb71676fd

Pull Request Pull Request #3531: Fixed hashcode for StackItem

Run Details

5770 of 8910 branches covered (64.76%)

Branch coverage included in aggregate %.

17 of 17 new or added lines in 6 files covered. (100.0%)

53 existing lines in 2 files now uncovered.

21711 of 40308 relevant lines covered (53.86%)

86413.07 hits per line

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

0.0

/src/Neo.VM/Cryptography/Murmur32.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// Murmur32.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 System;
using System.Buffers.Binary;
using System.Numerics;
using System.Security.Cryptography;

namespace Neo.VM.Cryptography
{
    /// <summary>
    /// Computes the murmur hash for the input data.
    /// </summary>
    sealed class Murmur32 : HashAlgorithm
    {
        private const uint c1 = 0xcc9e2d51;
        private const uint c2 = 0x1b873593;
        private const int r1 = 15;
        private const int r2 = 13;
        private const uint m = 5;
        private const uint n = 0xe6546b64;

        private readonly uint seed;
        private uint hash;
        private int length;

        public override int HashSize => 32;

        /// <summary>
        /// Initializes a new instance of the <see cref="Murmur32"/> class with the specified seed.
        /// </summary>
        /// <param name="seed">The seed to be used.</param>
        public Murmur32(uint seed)
        {
            this.seed = seed;
            Initialize();
        }

        protected override void HashCore(byte[] array, int ibStart, int cbSize)
        {
            length += cbSize;
            int remainder = cbSize & 3;
            int alignedLength = ibStart + (cbSize - remainder);
            for (int i = ibStart; i < alignedLength; i += 4)
            {
                uint k = BinaryPrimitives.ReadUInt32LittleEndian(array.AsSpan(i));
                k *= c1;
                k = BitOperations.RotateLeft(k, r1);
                k *= c2;
                hash ^= k;
                hash = BitOperations.RotateLeft(hash, r2);
                hash = hash * m + n;
            }
            if (remainder > 0)
            {
                uint remainingBytes = 0;
                switch (remainder)
                {
                    case 3: remainingBytes ^= (uint)array[alignedLength + 2] << 16; goto case 2;
                    case 2: remainingBytes ^= (uint)array[alignedLength + 1] << 8; goto case 1;
                    case 1: remainingBytes ^= array[alignedLength]; break;
                }
                remainingBytes *= c1;
                remainingBytes = BitOperations.RotateLeft(remainingBytes, r1);
                remainingBytes *= c2;
                hash ^= remainingBytes;
            }
        }

        protected override byte[] HashFinal()
        {
            hash ^= (uint)length;
            hash ^= hash >> 16;
            hash *= 0x85ebca6b;
            hash ^= hash >> 13;
            hash *= 0xc2b2ae35;
            hash ^= hash >> 16;

            byte[] buffer = new byte[sizeof(uint)];
            BinaryPrimitives.WriteUInt32LittleEndian(buffer, hash);
            return buffer;
        }

        public override void Initialize()
        {
            hash = seed;
            length = 0;
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// Murmur32.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 System;
13	using System.Buffers.Binary;
14	using System.Numerics;
15	using System.Security.Cryptography;
16
17	namespace Neo.VM.Cryptography
18	{
19	/// <summary>
20	/// Computes the murmur hash for the input data.
21	/// </summary>
22	sealed class Murmur32 : HashAlgorithm
23	{
24	private const uint c1 = 0xcc9e2d51;
25	private const uint c2 = 0x1b873593;
26	private const int r1 = 15;
27	private const int r2 = 13;
28	private const uint m = 5;
29	private const uint n = 0xe6546b64;
30
31	private readonly uint seed;
32	private uint hash;
33	private int length;
34
35	public override int HashSize => 32;	×
36
37	/// <summary>
38	/// Initializes a new instance of the <see cref="Murmur32"/> class with the specified seed.
39	/// </summary>
40	/// <param name="seed">The seed to be used.</param>
UNCOV 41	public Murmur32(uint seed)	×
UNCOV 42	{	×
UNCOV 43	this.seed = seed;	×
UNCOV 44	Initialize();	×
UNCOV 45	}	×
46
47	protected override void HashCore(byte[] array, int ibStart, int cbSize)
UNCOV 48	{	×
UNCOV 49	length += cbSize;	×
UNCOV 50	int remainder = cbSize & 3;	×
UNCOV 51	int alignedLength = ibStart + (cbSize - remainder);	×
UNCOV 52	for (int i = ibStart; i < alignedLength; i += 4)	×
UNCOV 53	{	×
UNCOV 54	uint k = BinaryPrimitives.ReadUInt32LittleEndian(array.AsSpan(i));	×
UNCOV 55	k *= c1;	×
UNCOV 56	k = BitOperations.RotateLeft(k, r1);	×
UNCOV 57	k *= c2;	×
UNCOV 58	hash ^= k;	×
UNCOV 59	hash = BitOperations.RotateLeft(hash, r2);	×
UNCOV 60	hash = hash * m + n;	×
UNCOV 61	}	×
UNCOV 62	if (remainder > 0)	×
UNCOV 63	{	×
UNCOV 64	uint remainingBytes = 0;	×
UNCOV 65	switch (remainder)	×
66	{
UNCOV 67	case 3: remainingBytes ^= (uint)array[alignedLength + 2] << 16; goto case 2;	×
UNCOV 68	case 2: remainingBytes ^= (uint)array[alignedLength + 1] << 8; goto case 1;	×
UNCOV 69	case 1: remainingBytes ^= array[alignedLength]; break;	×
70	}
UNCOV 71	remainingBytes *= c1;	×
UNCOV 72	remainingBytes = BitOperations.RotateLeft(remainingBytes, r1);	×
UNCOV 73	remainingBytes *= c2;	×
UNCOV 74	hash ^= remainingBytes;	×
UNCOV 75	}	×
UNCOV 76	}	×
77
78	protected override byte[] HashFinal()
UNCOV 79	{	×
UNCOV 80	hash ^= (uint)length;	×
UNCOV 81	hash ^= hash >> 16;	×
UNCOV 82	hash *= 0x85ebca6b;	×
UNCOV 83	hash ^= hash >> 13;	×
UNCOV 84	hash *= 0xc2b2ae35;	×
UNCOV 85	hash ^= hash >> 16;	×
86
UNCOV 87	byte[] buffer = new byte[sizeof(uint)];	×
UNCOV 88	BinaryPrimitives.WriteUInt32LittleEndian(buffer, hash);	×
UNCOV 89	return buffer;	×
UNCOV 90	}	×
91
92	public override void Initialize()
UNCOV 93	{	×
UNCOV 94	hash = seed;	×
UNCOV 95	length = 0;	×
UNCOV 96	}	×
97	}
98	}

neo-project / neo / 11362976181

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