11871814215

Committed 16 Nov 2024 05:06PM UTC coverage: 55.127% (-0.4%) from 55.55%

Build # 11871814215

Build Type

Pull #3581

github

Committed by

web-flow

Commit Message

Merge a8fd58733 into 8d946b419

Pull Request Pull Request #3581: [Neo VM] adopt light gc from neogo

Run Details

5772 of 9090 branches covered (63.5%)

Branch coverage included in aggregate %.

116 of 145 new or added lines in 39 files covered. (80.0%)

139 existing lines in 5 files now uncovered.

21771 of 40873 relevant lines covered (53.26%)

84730.91 hits per line

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

59.09

/src/Neo/Network/P2P/Payloads/Conditions/WitnessCondition.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// WitnessCondition.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.IO;
using Neo.IO.Caching;
using Neo.Json;
using Neo.SmartContract;
using Neo.VM;
using Neo.VM.Types;
using System;
using System.IO;
using System.Runtime.CompilerServices;

namespace Neo.Network.P2P.Payloads.Conditions
{
    public abstract class WitnessCondition : IInteroperable, ISerializable
    {
        internal const int MaxSubitems = 16;
        internal const int MaxNestingDepth = 2;

        /// <summary>
        /// The type of the <see cref="WitnessCondition"/>.
        /// </summary>
        public abstract WitnessConditionType Type { get; }

        public virtual int Size => sizeof(WitnessConditionType);

        public abstract override bool Equals(object obj);

        public abstract override int GetHashCode();

        void ISerializable.Deserialize(ref MemoryReader reader)
        {
            if (reader.ReadByte() != (byte)Type) throw new FormatException();
            DeserializeWithoutType(ref reader, MaxNestingDepth);
        }

        /// <summary>
        /// Deserializes an <see cref="WitnessCondition"/> array from a <see cref="MemoryReader"/>.
        /// </summary>
        /// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
        /// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
        /// <returns>The deserialized <see cref="WitnessCondition"/> array.</returns>
        protected static WitnessCondition[] DeserializeConditions(ref MemoryReader reader, int maxNestDepth)
        {
            WitnessCondition[] conditions = new WitnessCondition[reader.ReadVarInt(MaxSubitems)];
            for (int i = 0; i < conditions.Length; i++)
                conditions[i] = DeserializeFrom(ref reader, maxNestDepth);
            return conditions;
        }

        /// <summary>
        /// Deserializes an <see cref="WitnessCondition"/> object from a <see cref="MemoryReader"/>.
        /// </summary>
        /// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
        /// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
        /// <returns>The deserialized <see cref="WitnessCondition"/>.</returns>
        public static WitnessCondition DeserializeFrom(ref MemoryReader reader, int maxNestDepth)
        {
            WitnessConditionType type = (WitnessConditionType)reader.ReadByte();
            if (ReflectionCache<WitnessConditionType>.CreateInstance(type) is not WitnessCondition condition)
                throw new FormatException();
            condition.DeserializeWithoutType(ref reader, maxNestDepth);
            return condition;
        }

        /// <summary>
        /// Deserializes the <see cref="WitnessCondition"/> object from a <see cref="MemoryReader"/>.
        /// </summary>
        /// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
        /// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
        protected abstract void DeserializeWithoutType(ref MemoryReader reader, int maxNestDepth);

        /// <summary>
        /// Checks whether the current context matches the condition.
        /// </summary>
        /// <param name="engine">The <see cref="ApplicationEngine"/> that is executing CheckWitness.</param>
        /// <returns><see langword="true"/> if the condition matches; otherwise, <see langword="false"/>.</returns>
        public abstract bool Match(ApplicationEngine engine);

        void ISerializable.Serialize(BinaryWriter writer)
        {
            writer.Write((byte)Type);
            SerializeWithoutType(writer);
        }

        /// <summary>
        /// Serializes the <see cref="WitnessCondition"/> object to a <see cref="BinaryWriter"/>.
        /// </summary>
        /// <param name="writer">The <see cref="BinaryWriter"/> for writing data.</param>
        protected abstract void SerializeWithoutType(BinaryWriter writer);

        private protected abstract void ParseJson(JObject json, int maxNestDepth);

        /// <summary>
        /// Converts the <see cref="WitnessCondition"/> from a JSON object.
        /// </summary>
        /// <param name="json">The <see cref="WitnessCondition"/> represented by a JSON object.</param>
        /// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
        /// <returns>The converted <see cref="WitnessCondition"/>.</returns>
        public static WitnessCondition FromJson(JObject json, int maxNestDepth)
        {
            WitnessConditionType type = Enum.Parse<WitnessConditionType>(json["type"].GetString());
            if (ReflectionCache<WitnessConditionType>.CreateInstance(type) is not WitnessCondition condition)
                throw new FormatException("Invalid WitnessConditionType.");
            condition.ParseJson(json, maxNestDepth);
            return condition;
        }

        /// <summary>
        /// Converts the condition to a JSON object.
        /// </summary>
        /// <returns>The condition represented by a JSON object.</returns>
        public virtual JObject ToJson()
        {
            return new JObject
            {
                ["type"] = Type
            };
        }

        void IInteroperable.FromStackItem(StackItem stackItem)
        {
            throw new NotSupportedException();
        }

        public virtual StackItem ToStackItem(IReferenceCounter referenceCounter)
        {
            return new VM.Types.Array(new StackItem[] { (byte)Type });
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool operator ==(WitnessCondition left, WitnessCondition right)
        {
            if (left is null || right is null)
                return Equals(left, right);

            return left.Equals(right);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool operator !=(WitnessCondition left, WitnessCondition right)
        {
            if (left is null || right is null)
                return !Equals(left, right);

            return !left.Equals(right);
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// WitnessCondition.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.IO;
13	using Neo.IO.Caching;
14	using Neo.Json;
15	using Neo.SmartContract;
16	using Neo.VM;
17	using Neo.VM.Types;
18	using System;
19	using System.IO;
20	using System.Runtime.CompilerServices;
21
22	namespace Neo.Network.P2P.Payloads.Conditions
23	{
24	public abstract class WitnessCondition : IInteroperable, ISerializable
25	{
26	internal const int MaxSubitems = 16;
27	internal const int MaxNestingDepth = 2;
28
29	/// <summary>
30	/// The type of the <see cref="WitnessCondition"/>.
31	/// </summary>
32	public abstract WitnessConditionType Type { get; }
33
34	public virtual int Size => sizeof(WitnessConditionType);	×
35
36	public abstract override bool Equals(object obj);
37
38	public abstract override int GetHashCode();
39
40	void ISerializable.Deserialize(ref MemoryReader reader)
41	{	×
42	if (reader.ReadByte() != (byte)Type) throw new FormatException();	×
43	DeserializeWithoutType(ref reader, MaxNestingDepth);	×
44	}	×
45
46	/// <summary>
47	/// Deserializes an <see cref="WitnessCondition"/> array from a <see cref="MemoryReader"/>.
48	/// </summary>
49	/// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
50	/// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
51	/// <returns>The deserialized <see cref="WitnessCondition"/> array.</returns>
52	protected static WitnessCondition[] DeserializeConditions(ref MemoryReader reader, int maxNestDepth)
53	{	4✔
54	WitnessCondition[] conditions = new WitnessCondition[reader.ReadVarInt(MaxSubitems)];	4✔
55	for (int i = 0; i < conditions.Length; i++)	8!
56	conditions[i] = DeserializeFrom(ref reader, maxNestDepth);	4✔
57	return conditions;	×
58	}	×
59
60	/// <summary>
61	/// Deserializes an <see cref="WitnessCondition"/> object from a <see cref="MemoryReader"/>.
62	/// </summary>
63	/// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
64	/// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
65	/// <returns>The deserialized <see cref="WitnessCondition"/>.</returns>
66	public static WitnessCondition DeserializeFrom(ref MemoryReader reader, int maxNestDepth)
67	{	6✔
68	WitnessConditionType type = (WitnessConditionType)reader.ReadByte();	6✔
69	if (ReflectionCache<WitnessConditionType>.CreateInstance(type) is not WitnessCondition condition)	6!
70	throw new FormatException();	×
71	condition.DeserializeWithoutType(ref reader, maxNestDepth);	6✔
72	return condition;	×
73	}	×
74
75	/// <summary>
76	/// Deserializes the <see cref="WitnessCondition"/> object from a <see cref="MemoryReader"/>.
77	/// </summary>
78	/// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
79	/// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
80	protected abstract void DeserializeWithoutType(ref MemoryReader reader, int maxNestDepth);
81
82	/// <summary>
83	/// Checks whether the current context matches the condition.
84	/// </summary>
85	/// <param name="engine">The <see cref="ApplicationEngine"/> that is executing CheckWitness.</param>
86	/// <returns><see langword="true"/> if the condition matches; otherwise, <see langword="false"/>.</returns>
87	public abstract bool Match(ApplicationEngine engine);
88
89	void ISerializable.Serialize(BinaryWriter writer)
90	{	9✔
91	writer.Write((byte)Type);	9✔
92	SerializeWithoutType(writer);	9✔
93	}	9✔
94
95	/// <summary>
96	/// Serializes the <see cref="WitnessCondition"/> object to a <see cref="BinaryWriter"/>.
97	/// </summary>
98	/// <param name="writer">The <see cref="BinaryWriter"/> for writing data.</param>
99	protected abstract void SerializeWithoutType(BinaryWriter writer);
100
101	private protected abstract void ParseJson(JObject json, int maxNestDepth);
102
103	/// <summary>
104	/// Converts the <see cref="WitnessCondition"/> from a JSON object.
105	/// </summary>
106	/// <param name="json">The <see cref="WitnessCondition"/> represented by a JSON object.</param>
107	/// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
108	/// <returns>The converted <see cref="WitnessCondition"/>.</returns>
109	public static WitnessCondition FromJson(JObject json, int maxNestDepth)
110	{	24✔
111	WitnessConditionType type = Enum.Parse<WitnessConditionType>(json["type"].GetString());	24✔
112	if (ReflectionCache<WitnessConditionType>.CreateInstance(type) is not WitnessCondition condition)	24!
113	throw new FormatException("Invalid WitnessConditionType.");	×
114	condition.ParseJson(json, maxNestDepth);	24✔
115	return condition;	24✔
116	}	24✔
117
118	/// <summary>
119	/// Converts the condition to a JSON object.
120	/// </summary>
121	/// <returns>The condition represented by a JSON object.</returns>
122	public virtual JObject ToJson()
123	{	32✔
124	return new JObject	32✔
125	{	32✔
126	["type"] = Type	32✔
127	};	32✔
128	}	32✔
129
130	void IInteroperable.FromStackItem(StackItem stackItem)
131	{	×
132	throw new NotSupportedException();	×
133	}
134
135	public virtual StackItem ToStackItem(IReferenceCounter referenceCounter)
136	{	×
NEW 137	return new VM.Types.Array(new StackItem[] { (byte)Type });	×
138	}	×
139
140	[MethodImpl(MethodImplOptions.AggressiveInlining)]
141	public static bool operator ==(WitnessCondition left, WitnessCondition right)
142	{	3✔
143	if (left is null \|\| right is null)	3!
144	return Equals(left, right);	×
145
146	return left.Equals(right);	3✔
147	}	3✔
148
149	[MethodImpl(MethodImplOptions.AggressiveInlining)]
150	public static bool operator !=(WitnessCondition left, WitnessCondition right)
151	{	1✔
152	if (left is null \|\| right is null)	1!
153	return !Equals(left, right);	×
154
155	return !left.Equals(right);	1✔
156	}	1✔
157	}
158	}

neo-project / neo / 11871814215

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