11848706958

Committed 15 Nov 2024 01:42AM UTC coverage: 55.56% (+0.005%) from 55.555%

Build # 11848706958

Build Type

Pull #3580

github

Committed by

web-flow

Commit Message

Merge e9b3c525b into 83289289c

Pull Request Pull Request #3580: fix: Same maps should have the same hash-code

Run Details

5870 of 9128 branches covered (64.31%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

21906 of 40865 relevant lines covered (53.61%)

84823.49 hits per line

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

64.75

/src/Neo.VM/Types/Map.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// Map.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.VM.Collections;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace Neo.VM.Types
{
    /// <summary>
    /// Represents an ordered collection of key-value pairs in the VM.
    /// </summary>
    public class Map : CompoundType, IReadOnlyDictionary<PrimitiveType, StackItem>
    {
        /// <summary>
        /// Indicates the maximum size of keys in bytes.
        /// </summary>
        public const int MaxKeySize = 64;

        private readonly OrderedDictionary<PrimitiveType, StackItem> dictionary = new();

        /// <summary>
        /// Gets or sets the element that has the specified key in the map.
        /// </summary>
        /// <param name="key">The key to locate.</param>
        /// <returns>The element that has the specified key in the map.</returns>
        public StackItem this[PrimitiveType key]
        {
            get
            {
                if (key.Size > MaxKeySize)
                    throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
                return dictionary[key];
            }
            set
            {
                if (key.Size > MaxKeySize)
                    throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
                if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
                if (ReferenceCounter != null)
                {
                    if (dictionary.TryGetValue(key, out StackItem? old_value))
                        ReferenceCounter.RemoveReference(old_value, this);
                    else
                        ReferenceCounter.AddReference(key, this);
                    if (value is CompoundType { ReferenceCounter: null })
                    {
                        throw new InvalidOperationException("Can not set a Map without a ReferenceCounter.");
                    }
                    ReferenceCounter.AddReference(value, this);
                }
                dictionary[key] = value;
            }
        }

        public override int Count => dictionary.Count;

        /// <summary>
        /// Gets an enumerable collection that contains the keys in the map.
        /// </summary>
        public IEnumerable<PrimitiveType> Keys => dictionary.Keys;

        public override IEnumerable<StackItem> SubItems => Keys.Concat(Values);

        public override int SubItemsCount => dictionary.Count * 2;

        public override StackItemType Type => StackItemType.Map;

        /// <summary>
        /// Gets an enumerable collection that contains the values in the map.
        /// </summary>
        public IEnumerable<StackItem> Values => dictionary.Values;

        /// <summary>
        /// Create a new map with the specified reference counter.
        /// </summary>
        /// <param name="referenceCounter">The reference counter to be used.</param>
        public Map(IReferenceCounter? referenceCounter = null)
            : base(referenceCounter)
        {
        }

        public override void Clear()
        {
            if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
            if (ReferenceCounter != null)
                foreach (var pair in dictionary)
                {
                    ReferenceCounter.RemoveReference(pair.Key, this);
                    ReferenceCounter.RemoveReference(pair.Value, this);
                }
            dictionary.Clear();
        }

        /// <summary>
        /// Determines whether the map contains an element that has the specified key.
        /// </summary>
        /// <param name="key">The key to locate.</param>
        /// <returns>
        /// <see langword="true" /> if the map contains an element that has the specified key;
        /// otherwise, <see langword="false" />.
        /// </returns>
        public bool ContainsKey(PrimitiveType key)
        {
            if (key.Size > MaxKeySize)
                throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
            return dictionary.ContainsKey(key);
        }

        internal override StackItem DeepCopy(Dictionary<StackItem, StackItem> refMap, bool asImmutable)
        {
            if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem;
            Map result = new(ReferenceCounter);
            refMap.Add(this, result);
            foreach (var (k, v) in dictionary)
                result[k] = v.DeepCopy(refMap, asImmutable);
            result.IsReadOnly = true;
            return result;
        }

        IEnumerator<KeyValuePair<PrimitiveType, StackItem>> IEnumerable<KeyValuePair<PrimitiveType, StackItem>>.GetEnumerator()
        {
            return ((IDictionary<PrimitiveType, StackItem>)dictionary).GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IDictionary<PrimitiveType, StackItem>)dictionary).GetEnumerator();
        }

        /// <summary>
        /// Removes the element with the specified key from the map.
        /// </summary>
        /// <param name="key">The key of the element to remove.</param>
        /// <returns>
        /// <see langword="true" /> if the element is successfully removed;
        /// otherwise, <see langword="false"/>.
        /// This method also returns <see langword="false"/> if <paramref name="key"/> was not found in the original map.
        /// </returns>
        public bool Remove(PrimitiveType key)
        {
            if (key.Size > MaxKeySize)
                throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
            if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
            if (!dictionary.Remove(key, out StackItem? old_value))
                return false;
            ReferenceCounter?.RemoveReference(key, this);
            ReferenceCounter?.RemoveReference(old_value, this);
            return true;
        }

        /// <summary>
        /// Gets the value that is associated with the specified key.
        /// </summary>
        /// <param name="key">The key to locate.</param>
        /// <param name="value">
        /// When this method returns, the value associated with the specified key, if the key is found;
        /// otherwise, <see langword="null"/>.
        /// </param>
        /// <returns>
        /// <see langword="true" /> if the map contains an element that has the specified key;
        /// otherwise, <see langword="false"/>.
        /// </returns>
// supress warning of value parameter nullability mismatch
#pragma warning disable CS8767
        public bool TryGetValue(PrimitiveType key, [MaybeNullWhen(false)] out StackItem value)
#pragma warning restore CS8767
        {
            if (key.Size > MaxKeySize)
                throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
            return dictionary.TryGetValue(key, out value);
        }

        /// <summary>
        /// Gets the hash code of the map.
        /// </summary>
        /// <returns>The hash code of the map.</returns>
        public override int GetHashCode()
        {
            var keysHashCode = 0;
            // only keys are used.
            foreach (var item in Keys)
                keysHashCode ^= item.GetHashCode();
            return HashCode.Combine(Count, (int)Type, keysHashCode);
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// Map.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 Neo.VM.Collections;
13	using System;
14	using System.Collections;
15	using System.Collections.Generic;
16	using System.Diagnostics.CodeAnalysis;
17	using System.Linq;
18
19	namespace Neo.VM.Types
20	{
21	/// <summary>
22	/// Represents an ordered collection of key-value pairs in the VM.
23	/// </summary>
24	public class Map : CompoundType, IReadOnlyDictionary<PrimitiveType, StackItem>
25	{
26	/// <summary>
27	/// Indicates the maximum size of keys in bytes.
28	/// </summary>
29	public const int MaxKeySize = 64;
30
31	private readonly OrderedDictionary<PrimitiveType, StackItem> dictionary = new();	3,518✔
32
33	/// <summary>
34	/// Gets or sets the element that has the specified key in the map.
35	/// </summary>
36	/// <param name="key">The key to locate.</param>
37	/// <returns>The element that has the specified key in the map.</returns>
38	public StackItem this[PrimitiveType key]
39	{
40	get
41	{	×
42	if (key.Size > MaxKeySize)	×
43	throw new ArgumentException($"MaxKeySize exceed: {key.Size}");	×
44	return dictionary[key];	×
45	}	×
46	set
47	{	53✔
48	if (key.Size > MaxKeySize)	53!
49	throw new ArgumentException($"MaxKeySize exceed: {key.Size}");	×
50	if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");	53!
51	if (ReferenceCounter != null)	53✔
52	{	15✔
53	if (dictionary.TryGetValue(key, out StackItem? old_value))	15✔
54	ReferenceCounter.RemoveReference(old_value, this);	1✔
55	else
56	ReferenceCounter.AddReference(key, this);	14✔
57	if (value is CompoundType { ReferenceCounter: null })	15!
58	{	×
59	throw new InvalidOperationException("Can not set a Map without a ReferenceCounter.");	×
60	}
61	ReferenceCounter.AddReference(value, this);	15✔
62	}	15✔
63	dictionary[key] = value;	53✔
64	}	53✔
65	}
66
67	public override int Count => dictionary.Count;	3,460✔
68
69	/// <summary>
70	/// Gets an enumerable collection that contains the keys in the map.
71	/// </summary>
72	public IEnumerable<PrimitiveType> Keys => dictionary.Keys;	10✔
73
UNCOV 74	public override IEnumerable<StackItem> SubItems => Keys.Concat(Values);	×
75
76	public override int SubItemsCount => dictionary.Count * 2;	×
77
78	public override StackItemType Type => StackItemType.Map;	2,980✔
79
80	/// <summary>
81	/// Gets an enumerable collection that contains the values in the map.
82	/// </summary>
83	public IEnumerable<StackItem> Values => dictionary.Values;	4✔
84
85	/// <summary>
86	/// Create a new map with the specified reference counter.
87	/// </summary>
88	/// <param name="referenceCounter">The reference counter to be used.</param>
89	public Map(IReferenceCounter? referenceCounter = null)
90	: base(referenceCounter)	3,518✔
91	{	3,518✔
92	}	3,518✔
93
94	public override void Clear()
95	{	1✔
96	if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");	1!
97	if (ReferenceCounter != null)	1✔
98	foreach (var pair in dictionary)	5✔
99	{	1✔
100	ReferenceCounter.RemoveReference(pair.Key, this);	1✔
101	ReferenceCounter.RemoveReference(pair.Value, this);	1✔
102	}	1✔
103	dictionary.Clear();	1✔
104	}	1✔
105
106	/// <summary>
107	/// Determines whether the map contains an element that has the specified key.
108	/// </summary>
109	/// <param name="key">The key to locate.</param>
110	/// <returns>
111	/// <see langword="true" /> if the map contains an element that has the specified key;
112	/// otherwise, <see langword="false" />.
113	/// </returns>
114	public bool ContainsKey(PrimitiveType key)
115	{	3✔
116	if (key.Size > MaxKeySize)	3✔
117	throw new ArgumentException($"MaxKeySize exceed: {key.Size}");	1✔
118	return dictionary.ContainsKey(key);	2✔
119	}	2✔
120
121	internal override StackItem DeepCopy(Dictionary<StackItem, StackItem> refMap, bool asImmutable)
122	{	1✔
123	if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem;	1!
124	Map result = new(ReferenceCounter);	1✔
125	refMap.Add(this, result);	1✔
126	foreach (var (k, v) in dictionary)	7✔
127	result[k] = v.DeepCopy(refMap, asImmutable);	2✔
128	result.IsReadOnly = true;	1✔
129	return result;	1✔
130	}	1✔
131
132	IEnumerator<KeyValuePair<PrimitiveType, StackItem>> IEnumerable<KeyValuePair<PrimitiveType, StackItem>>.GetEnumerator()
133	{	3,029✔
134	return ((IDictionary<PrimitiveType, StackItem>)dictionary).GetEnumerator();	3,029✔
135	}	3,029✔
136
137	IEnumerator IEnumerable.GetEnumerator()
138	{	×
139	return ((IDictionary<PrimitiveType, StackItem>)dictionary).GetEnumerator();	×
140	}	×
141
142	/// <summary>
143	/// Removes the element with the specified key from the map.
144	/// </summary>
145	/// <param name="key">The key of the element to remove.</param>
146	/// <returns>
147	/// <see langword="true" /> if the element is successfully removed;
148	/// otherwise, <see langword="false"/>.
149	/// This method also returns <see langword="false"/> if <paramref name="key"/> was not found in the original map.
150	/// </returns>
151	public bool Remove(PrimitiveType key)
152	{	×
153	if (key.Size > MaxKeySize)	×
154	throw new ArgumentException($"MaxKeySize exceed: {key.Size}");	×
155	if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");	×
156	if (!dictionary.Remove(key, out StackItem? old_value))	×
157	return false;	×
158	ReferenceCounter?.RemoveReference(key, this);	×
159	ReferenceCounter?.RemoveReference(old_value, this);	×
160	return true;	×
161	}	×
162
163	/// <summary>
164	/// Gets the value that is associated with the specified key.
165	/// </summary>
166	/// <param name="key">The key to locate.</param>
167	/// <param name="value">
168	/// When this method returns, the value associated with the specified key, if the key is found;
169	/// otherwise, <see langword="null"/>.
170	/// </param>
171	/// <returns>
172	/// <see langword="true" /> if the map contains an element that has the specified key;
173	/// otherwise, <see langword="false"/>.
174	/// </returns>
175	// supress warning of value parameter nullability mismatch
176	#pragma warning disable CS8767
177	public bool TryGetValue(PrimitiveType key, [MaybeNullWhen(false)] out StackItem value)
178	#pragma warning restore CS8767
179	{	2✔
180	if (key.Size > MaxKeySize)	2!
181	throw new ArgumentException($"MaxKeySize exceed: {key.Size}");	×
182	return dictionary.TryGetValue(key, out value);	2✔
183	}	2✔
184
185	/// <summary>
186	/// Gets the hash code of the map.
187	/// </summary>
188	/// <returns>The hash code of the map.</returns>
189	public override int GetHashCode()
190	{	6✔
191	var keysHashCode = 0;	6✔
192	// only keys are used.
193	foreach (var item in Keys)	42✔
194	keysHashCode ^= item.GetHashCode();	12✔
195	return HashCode.Combine(Count, (int)Type, keysHashCode);	6✔
196	}	6✔
197	}
198	}

neo-project / neo / 11848706958

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