74d16c3aa44c22de75cb274a756ae4a091aae3fe-PR-1374

Build # 74d16c3aa44c22de75cb274a756ae4a091aae3fe-PR-1374

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/neo-project/neo/commit/<a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/74d16c3aa44c22de75cb274a756ae4a091aae3fe">74d16c3aa">&lt;a href=&quot;https://github.com/neo-project/neo/commit/</a><a class="double-link" href="https://github.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/74d16c3aa44c22de75cb274a756ae4a091aae3fe">74d16c3aa</a><a href="https://github.com/neo-project/neo/commit/74d16c3aa44c22de75cb274a756ae4a091aae3fe">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/neo-project/neo/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/74d16c3aa44c22de75cb274a756ae4a091aae3fe&quot;&gt;74d16c3aa&lt;/a&gt;&lt;a href=&quot;https://github.com/neo-project/neo/commit/74d16c3aa44c22de75cb274a756ae4a091aae3fe&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/neo-project/neo/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/neo-project/neo/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&am... (continued)

Pull Request Pull Request #1374: Neo.VM.3.0.0-CI00201

Run Details

2987 of 4354 branches covered (68.6%)

Branch coverage included in aggregate %.

140 of 140 new or added lines in 10 files covered. (100.0%)

10112 of 12448 relevant lines covered (81.23%)

127672.99 hits per line

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

95.54

/src/neo/IO/Helper.cs

using K4os.Compression.LZ4;
using System;
using System.Buffers;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;

namespace Neo.IO
{
    public static class Helper
    {
        public const int GroupingSizeInBytes = 16;

        public static T AsSerializable<T>(this byte[] value, int start = 0) where T : ISerializable, new()
        {
            using (MemoryStream ms = new MemoryStream(value, start, value.Length - start, false))
            using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))
            {
                return reader.ReadSerializable<T>();
            }
        }

        public static unsafe T AsSerializable<T>(this ReadOnlySpan<byte> value) where T : ISerializable, new()
        {
            if (value.IsEmpty) throw new FormatException();
            fixed (byte* pointer = value)
            {
                using UnmanagedMemoryStream ms = new UnmanagedMemoryStream(pointer, value.Length);
                using BinaryReader reader = new BinaryReader(ms, Encoding.UTF8);
                return reader.ReadSerializable<T>();
            }
        }

        public static ISerializable AsSerializable(this byte[] value, Type type)
        {
            if (!typeof(ISerializable).GetTypeInfo().IsAssignableFrom(type))
                throw new InvalidCastException();
            ISerializable serializable = (ISerializable)Activator.CreateInstance(type);
            using (MemoryStream ms = new MemoryStream(value, false))
            using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))
            {
                serializable.Deserialize(reader);
            }
            return serializable;
        }

        public static T[] AsSerializableArray<T>(this byte[] value, int max = 0x1000000) where T : ISerializable, new()
        {
            using (MemoryStream ms = new MemoryStream(value, false))
            using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))
            {
                return reader.ReadSerializableArray<T>(max);
            }
        }

        public static unsafe T[] AsSerializableArray<T>(this ReadOnlySpan<byte> value, int max = 0x1000000) where T : ISerializable, new()
        {
            if (value.IsEmpty) throw new FormatException();
            fixed (byte* pointer = value)
            {
                using UnmanagedMemoryStream ms = new UnmanagedMemoryStream(pointer, value.Length);
                using BinaryReader reader = new BinaryReader(ms, Encoding.UTF8);
                return reader.ReadSerializableArray<T>(max);
            }
        }

        public static byte[] CompressLz4(this byte[] data)
        {
            int maxLength = LZ4Codec.MaximumOutputSize(data.Length);
            using var buffer = MemoryPool<byte>.Shared.Rent(maxLength);
            int length = LZ4Codec.Encode(data, buffer.Memory.Span);
            byte[] result = new byte[length];
            buffer.Memory[..length].CopyTo(result);
            return result;
        }

        public static byte[] DecompressLz4(this byte[] data, int maxOutput)
        {
            var maxDecompressDataLength = data.Length * 255;
            if (maxDecompressDataLength > 0) maxOutput = Math.Min(maxOutput, maxDecompressDataLength);
            using var buffer = MemoryPool<byte>.Shared.Rent(maxOutput);
            int length = LZ4Codec.Decode(data, buffer.Memory.Span);
            if (length < 0 || length > maxOutput) throw new FormatException();
            byte[] result = new byte[length];
            buffer.Memory[..length].CopyTo(result);
            return result;
        }

        public static void FillBuffer(this BinaryReader reader, Span<byte> buffer)
        {
            while (!buffer.IsEmpty)
            {
                int count = reader.Read(buffer);
                if (count == 0) throw new EndOfStreamException();
                buffer = buffer[count..];
            }
        }

        public static int GetVarSize(int value)
        {
            if (value < 0xFD)
                return sizeof(byte);
            else if (value <= 0xFFFF)
                return sizeof(byte) + sizeof(ushort);
            else
                return sizeof(byte) + sizeof(uint);
        }

        public static int GetVarSize<T>(this IReadOnlyCollection<T> value)
        {
            int value_size;
            Type t = typeof(T);
            if (typeof(ISerializable).IsAssignableFrom(t))
            {
                value_size = value.OfType<ISerializable>().Sum(p => p.Size);
            }
            else if (t.GetTypeInfo().IsEnum)
            {
                int element_size;
                Type u = t.GetTypeInfo().GetEnumUnderlyingType();
                if (u == typeof(sbyte) || u == typeof(byte))
                    element_size = 1;
                else if (u == typeof(short) || u == typeof(ushort))
                    element_size = 2;
                else if (u == typeof(int) || u == typeof(uint))
                    element_size = 4;
                else //if (u == typeof(long) || u == typeof(ulong))
                    element_size = 8;
                value_size = value.Count * element_size;
            }
            else
            {
                value_size = value.Count * Marshal.SizeOf<T>();
            }
            return GetVarSize(value.Count) + value_size;
        }

        public static int GetVarSize(this string value)
        {
            int size = Encoding.UTF8.GetByteCount(value);
            return GetVarSize(size) + size;
        }

        public static byte[] ReadBytesWithGrouping(this BinaryReader reader)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                int count;
                do
                {
                    byte[] group = reader.ReadBytes(GroupingSizeInBytes);
                    count = reader.ReadByte();
                    if (count > GroupingSizeInBytes)
                        throw new FormatException();
                    if (count > 0)
                        ms.Write(group, 0, count);
                } while (count == GroupingSizeInBytes);
                return ms.ToArray();
            }
        }

        public static string ReadFixedString(this BinaryReader reader, int length)
        {
            byte[] data = reader.ReadBytes(length);
            return Encoding.UTF8.GetString(data.TakeWhile(p => p != 0).ToArray());
        }

        public static T[] ReadNullableArray<T>(this BinaryReader reader, int max = 0x1000000) where T : class, ISerializable, new()
        {
            T[] array = new T[reader.ReadVarInt((ulong)max)];
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadBoolean() ? reader.ReadSerializable<T>() : null;
            return array;
        }

        public static T ReadSerializable<T>(this BinaryReader reader) where T : ISerializable, new()
        {
            T obj = new T();
            obj.Deserialize(reader);
            return obj;
        }

        public static T[] ReadSerializableArray<T>(this BinaryReader reader, int max = 0x1000000) where T : ISerializable, new()
        {
            T[] array = new T[reader.ReadVarInt((ulong)max)];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = new T();
                array[i].Deserialize(reader);
            }
            return array;
        }

        public static byte[] ReadVarBytes(this BinaryReader reader, int max = 0x1000000)
        {
            return reader.ReadBytes((int)reader.ReadVarInt((ulong)max));
        }

        public static ulong ReadVarInt(this BinaryReader reader, ulong max = ulong.MaxValue)
        {
            byte fb = reader.ReadByte();
            ulong value;
            if (fb == 0xFD)
                value = reader.ReadUInt16();
            else if (fb == 0xFE)
                value = reader.ReadUInt32();
            else if (fb == 0xFF)
                value = reader.ReadUInt64();
            else
                value = fb;
            if (value > max) throw new FormatException();
            return value;
        }

        public static string ReadVarString(this BinaryReader reader, int max = 0x1000000)
        {
            return Encoding.UTF8.GetString(reader.ReadVarBytes(max));
        }

        public static byte[] ToArray(this ISerializable value)
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter writer = new BinaryWriter(ms, Encoding.UTF8))
            {
                value.Serialize(writer);
                writer.Flush();
                return ms.ToArray();
            }
        }

        public static byte[] ToByteArray<T>(this IReadOnlyCollection<T> value) where T : ISerializable
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter writer = new BinaryWriter(ms, Encoding.UTF8))
            {
                writer.Write(value);
                writer.Flush();
                return ms.ToArray();
            }
        }

        public static void Write(this BinaryWriter writer, ISerializable value)
        {
            value.Serialize(writer);
        }

        public static void Write<T>(this BinaryWriter writer, IReadOnlyCollection<T> value) where T : ISerializable
        {
            writer.WriteVarInt(value.Count);
            foreach (T item in value)
            {
                item.Serialize(writer);
            }
        }

        public static void WriteBytesWithGrouping(this BinaryWriter writer, byte[] value)
        {
            int index = 0;
            int remain = value.Length;
            while (remain >= GroupingSizeInBytes)
            {
                writer.Write(value, index, GroupingSizeInBytes);
                writer.Write((byte)GroupingSizeInBytes);
                index += GroupingSizeInBytes;
                remain -= GroupingSizeInBytes;
            }
            if (remain > 0)
                writer.Write(value, index, remain);
            int padding = GroupingSizeInBytes - remain;
            for (int i = 0; i < padding; i++)
                writer.Write((byte)0);
            writer.Write((byte)remain);
        }

        public static void WriteFixedString(this BinaryWriter writer, string value, int length)
        {
            if (value == null)
                throw new ArgumentNullException(nameof(value));
            if (value.Length > length)
                throw new ArgumentException();
            byte[] bytes = Encoding.UTF8.GetBytes(value);
            if (bytes.Length > length)
                throw new ArgumentException();
            writer.Write(bytes);
            if (bytes.Length < length)
                writer.Write(stackalloc byte[length - bytes.Length]);
        }

        public static void WriteNullableArray<T>(this BinaryWriter writer, T[] value) where T : class, ISerializable
        {
            writer.WriteVarInt(value.Length);
            foreach (var item in value)
            {
                bool isNull = item is null;
                writer.Write(!isNull);
                if (isNull) continue;
                item.Serialize(writer);
            }
        }

        public static void WriteVarBytes(this BinaryWriter writer, ReadOnlySpan<byte> value)
        {
            writer.WriteVarInt(value.Length);
            writer.Write(value);
        }

        public static void WriteVarInt(this BinaryWriter writer, long value)
        {
            if (value < 0)
                throw new ArgumentOutOfRangeException();
            if (value < 0xFD)
            {
                writer.Write((byte)value);
            }
            else if (value <= 0xFFFF)
            {
                writer.Write((byte)0xFD);
                writer.Write((ushort)value);
            }
            else if (value <= 0xFFFFFFFF)
            {
                writer.Write((byte)0xFE);
                writer.Write((uint)value);
            }
            else
            {
                writer.Write((byte)0xFF);
                writer.Write(value);
            }
        }

        public static void WriteVarString(this BinaryWriter writer, string value)
        {
            writer.WriteVarBytes(Encoding.UTF8.GetBytes(value));
        }
    }
}

1	using K4os.Compression.LZ4;
2	using System;
3	using System.Buffers;
4	using System.Collections.Generic;
5	using System.IO;
6	using System.Linq;
7	using System.Reflection;
8	using System.Runtime.InteropServices;
9	using System.Text;
10
11	namespace Neo.IO
12	{
13	public static class Helper
14	{
15	public const int GroupingSizeInBytes = 16;
16
17	public static T AsSerializable<T>(this byte[] value, int start = 0) where T : ISerializable, new()
18	{	2,714✔
19	using (MemoryStream ms = new MemoryStream(value, start, value.Length - start, false))	2,714✔
20	using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))	2,714✔
21	{	2,714✔
22	return reader.ReadSerializable<T>();	2,714✔
23	}
24	}	2,678✔
25
26	public static unsafe T AsSerializable<T>(this ReadOnlySpan<byte> value) where T : ISerializable, new()
27	{	96✔
28	if (value.IsEmpty) throw new FormatException();	102✔
29	fixed (byte* pointer = value)	90✔
30	{	90✔
31	using UnmanagedMemoryStream ms = new UnmanagedMemoryStream(pointer, value.Length);	90✔
32	using BinaryReader reader = new BinaryReader(ms, Encoding.UTF8);	90✔
33	return reader.ReadSerializable<T>();	90✔
34	}
35	}	78✔
36
37	public static ISerializable AsSerializable(this byte[] value, Type type)
38	{	150✔
39	if (!typeof(ISerializable).GetTypeInfo().IsAssignableFrom(type))	150✔
40	throw new InvalidCastException();	6✔
41	ISerializable serializable = (ISerializable)Activator.CreateInstance(type);	144✔
42	using (MemoryStream ms = new MemoryStream(value, false))	144✔
43	using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))	144✔
44	{	144✔
45	serializable.Deserialize(reader);	144✔
46	}	144✔
47	return serializable;	144✔
48	}	144✔
49
50	public static T[] AsSerializableArray<T>(this byte[] value, int max = 0x1000000) where T : ISerializable, new()
51	{	180✔
52	using (MemoryStream ms = new MemoryStream(value, false))	180✔
53	using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))	180✔
54	{	180✔
55	return reader.ReadSerializableArray<T>(max);	180✔
56	}
57	}	180✔
58
59	public static unsafe T[] AsSerializableArray<T>(this ReadOnlySpan<byte> value, int max = 0x1000000) where T : ISerializable, new()
60	{	133✔
61	if (value.IsEmpty) throw new FormatException();	133!
62	fixed (byte* pointer = value)	133✔
63	{	133✔
64	using UnmanagedMemoryStream ms = new UnmanagedMemoryStream(pointer, value.Length);	133✔
65	using BinaryReader reader = new BinaryReader(ms, Encoding.UTF8);	133✔
66	return reader.ReadSerializableArray<T>(max);	133✔
67	}
68	}	133✔
69
70	public static byte[] CompressLz4(this byte[] data)
71	{	12✔
72	int maxLength = LZ4Codec.MaximumOutputSize(data.Length);	12✔
73	using var buffer = MemoryPool<byte>.Shared.Rent(maxLength);	12✔
74	int length = LZ4Codec.Encode(data, buffer.Memory.Span);	12✔
75	byte[] result = new byte[length];	12✔
76	buffer.Memory[..length].CopyTo(result);	12✔
77	return result;	12✔
78	}	12✔
79
80	public static byte[] DecompressLz4(this byte[] data, int maxOutput)
81	{	6✔
82	var maxDecompressDataLength = data.Length * 255;	6✔
83	if (maxDecompressDataLength > 0) maxOutput = Math.Min(maxOutput, maxDecompressDataLength);	12✔
84	using var buffer = MemoryPool<byte>.Shared.Rent(maxOutput);	6✔
85	int length = LZ4Codec.Decode(data, buffer.Memory.Span);	6✔
86	if (length < 0 \|\| length > maxOutput) throw new FormatException();	6!
87	byte[] result = new byte[length];	6✔
88	buffer.Memory[..length].CopyTo(result);	6✔
89	return result;	6✔
90	}	6✔
91
92	public static void FillBuffer(this BinaryReader reader, Span<byte> buffer)
93	{	×
94	while (!buffer.IsEmpty)	×
95	{	×
96	int count = reader.Read(buffer);	×
97	if (count == 0) throw new EndOfStreamException();	×
98	buffer = buffer[count..];	×
99	}	×
100	}	×
101
102	public static int GetVarSize(int value)
103	{	105,828✔
104	if (value < 0xFD)	105,828✔
105	return sizeof(byte);	105,516✔
106	else if (value <= 0xFFFF)	312✔
107	return sizeof(byte) + sizeof(ushort);	294✔
108	else
109	return sizeof(byte) + sizeof(uint);	18✔
110	}	105,828✔
111
112	public static int GetVarSize<T>(this IReadOnlyCollection<T> value)
113	{	105,408✔
114	int value_size;
115	Type t = typeof(T);	105,408✔
116	if (typeof(ISerializable).IsAssignableFrom(t))	105,408✔
117	{	64,554✔
118	value_size = value.OfType<ISerializable>().Sum(p => p.Size);	77,122✔
119	}	64,554✔
120	else if (t.GetTypeInfo().IsEnum)	40,854✔
121	{	48✔
122	int element_size;
123	Type u = t.GetTypeInfo().GetEnumUnderlyingType();	48✔
124	if (u == typeof(sbyte) \|\| u == typeof(byte))	48✔
125	element_size = 1;	18✔
126	else if (u == typeof(short) \|\| u == typeof(ushort))	30✔
127	element_size = 2;	12✔
128	else if (u == typeof(int) \|\| u == typeof(uint))	18✔
129	element_size = 4;	12✔
130	else //if (u == typeof(long) \|\| u == typeof(ulong))
131	element_size = 8;	6✔
132	value_size = value.Count * element_size;	48✔
133	}	48✔
134	else
135	{	40,806✔
136	value_size = value.Count * Marshal.SizeOf<T>();	40,806✔
137	}	40,806✔
138	return GetVarSize(value.Count) + value_size;	105,408✔
139	}	105,408✔
140
141	public static int GetVarSize(this string value)
142	{	18✔
143	int size = Encoding.UTF8.GetByteCount(value);	18✔
144	return GetVarSize(size) + size;	18✔
145	}	18✔
146
147	public static byte[] ReadBytesWithGrouping(this BinaryReader reader)
148	{	228✔
149	using (MemoryStream ms = new MemoryStream())	228✔
150	{	228✔
151	int count;
152	do
153	{	672✔
154	byte[] group = reader.ReadBytes(GroupingSizeInBytes);	672✔
155	count = reader.ReadByte();	672✔
156	if (count > GroupingSizeInBytes)	672✔
157	throw new FormatException();	6✔
158	if (count > 0)	666✔
159	ms.Write(group, 0, count);	666✔
160	} while (count == GroupingSizeInBytes);	1,332✔
161	return ms.ToArray();	222✔
162	}
163	}	222✔
164
165	public static string ReadFixedString(this BinaryReader reader, int length)
166	{	48✔
167	byte[] data = reader.ReadBytes(length);	48✔
168	return Encoding.UTF8.GetString(data.TakeWhile(p => p != 0).ToArray());	852✔
169	}	48✔
170
171	public static T[] ReadNullableArray<T>(this BinaryReader reader, int max = 0x1000000) where T : class, ISerializable, new()
172	{	36✔
173	T[] array = new T[reader.ReadVarInt((ulong)max)];	36✔
174	for (int i = 0; i < array.Length; i++)	432✔
175	array[i] = reader.ReadBoolean() ? reader.ReadSerializable<T>() : null;	186✔
176	return array;	30✔
177	}	30✔
178
179	public static T ReadSerializable<T>(this BinaryReader reader) where T : ISerializable, new()
180	{	6,382✔
181	T obj = new T();	6,382✔
182	obj.Deserialize(reader);	6,382✔
183	return obj;	6,334✔
184	}	6,334✔
185
186	public static T[] ReadSerializableArray<T>(this BinaryReader reader, int max = 0x1000000) where T : ISerializable, new()
187	{	5,569✔
188	T[] array = new T[reader.ReadVarInt((ulong)max)];	5,569✔
189	for (int i = 0; i < array.Length; i++)	26,978✔
190	{	7,926✔
191	array[i] = new T();	7,926✔
192	array[i].Deserialize(reader);	7,926✔
193	}	7,926✔
194	return array;	5,563✔
195	}	5,563✔
196
197	public static byte[] ReadVarBytes(this BinaryReader reader, int max = 0x1000000)
198	{	20,914✔
199	return reader.ReadBytes((int)reader.ReadVarInt((ulong)max));	20,914✔
200	}	20,908✔
201
202	public static ulong ReadVarInt(this BinaryReader reader, ulong max = ulong.MaxValue)
203	{	27,571✔
204	byte fb = reader.ReadByte();	27,571✔
205	ulong value;
206	if (fb == 0xFD)	27,571✔
207	value = reader.ReadUInt16();	216✔
208	else if (fb == 0xFE)	27,355✔
209	value = reader.ReadUInt32();	6✔
210	else if (fb == 0xFF)	27,349✔
211	value = reader.ReadUInt64();	12✔
212	else
213	value = fb;	27,337✔
214	if (value > max) throw new FormatException();	27,601✔
215	return value;	27,541✔
216	}	27,541✔
217
218	public static string ReadVarString(this BinaryReader reader, int max = 0x1000000)
219	{	162✔
220	return Encoding.UTF8.GetString(reader.ReadVarBytes(max));	162✔
221	}	162✔
222
223	public static byte[] ToArray(this ISerializable value)
224	{	23,812✔
225	using (MemoryStream ms = new MemoryStream())	23,812✔
226	using (BinaryWriter writer = new BinaryWriter(ms, Encoding.UTF8))	23,812✔
227	{	23,812✔
228	value.Serialize(writer);	23,812✔
229	writer.Flush();	23,806✔
230	return ms.ToArray();	23,806✔
231	}
232	}	23,806✔
233
234	public static byte[] ToByteArray<T>(this IReadOnlyCollection<T> value) where T : ISerializable
235	{	292✔
236	using (MemoryStream ms = new MemoryStream())	292✔
237	using (BinaryWriter writer = new BinaryWriter(ms, Encoding.UTF8))	292✔
238	{	292✔
239	writer.Write(value);	292✔
240	writer.Flush();	292✔
241	return ms.ToArray();	292✔
242	}
243	}	292✔
244
245	public static void Write(this BinaryWriter writer, ISerializable value)
246	{	25,140✔
247	value.Serialize(writer);	25,140✔
248	}	25,140✔
249
250	public static void Write<T>(this BinaryWriter writer, IReadOnlyCollection<T> value) where T : ISerializable
251	{	42,985✔
252	writer.WriteVarInt(value.Count);	42,985✔
253	foreach (T item in value)	143,397✔
254	{	7,221✔
255	item.Serialize(writer);	7,221✔
256	}	7,221✔
257	}	42,985✔
258
259	public static void WriteBytesWithGrouping(this BinaryWriter writer, byte[] value)
260	{	2,442✔
261	int index = 0;	2,442✔
262	int remain = value.Length;	2,442✔
263	while (remain >= GroupingSizeInBytes)	3,560✔
264	{	1,118✔
265	writer.Write(value, index, GroupingSizeInBytes);	1,118✔
266	writer.Write((byte)GroupingSizeInBytes);	1,118✔
267	index += GroupingSizeInBytes;	1,118✔
268	remain -= GroupingSizeInBytes;	1,118✔
269	}	1,118✔
270	if (remain > 0)	2,442✔
271	writer.Write(value, index, remain);	2,430✔
272	int padding = GroupingSizeInBytes - remain;	2,442✔
273	for (int i = 0; i < padding; i++)	73,104✔
274	writer.Write((byte)0);	34,110✔
275	writer.Write((byte)remain);	2,442✔
276	}	2,442✔
277
278	public static void WriteFixedString(this BinaryWriter writer, string value, int length)
279	{	168✔
280	if (value == null)	168✔
281	throw new ArgumentNullException(nameof(value));	6✔
282	if (value.Length > length)	162✔
283	throw new ArgumentException();	12✔
284	byte[] bytes = Encoding.UTF8.GetBytes(value);	150✔
285	if (bytes.Length > length)	150✔
286	throw new ArgumentException();	6✔
287	writer.Write(bytes);	144✔
288	if (bytes.Length < length)	144✔
289	writer.Write(stackalloc byte[length - bytes.Length]);	54✔
290	}	144✔
291
292	public static void WriteNullableArray<T>(this BinaryWriter writer, T[] value) where T : class, ISerializable
293	{	54✔
294	writer.WriteVarInt(value.Length);	54✔
295	foreach (var item in value)	870✔
296	{	354✔
297	bool isNull = item is null;	354✔
298	writer.Write(!isNull);	354✔
299	if (isNull) continue;	600✔
300	item.Serialize(writer);	108✔
301	}	108✔
302	}	54✔
303
304	public static void WriteVarBytes(this BinaryWriter writer, ReadOnlySpan<byte> value)
305	{	44,586✔
306	writer.WriteVarInt(value.Length);	44,586✔
307	writer.Write(value);	44,586✔
308	}	44,586✔
309
310	public static void WriteVarInt(this BinaryWriter writer, long value)
311	{	88,330✔
312	if (value < 0)	88,330✔
313	throw new ArgumentOutOfRangeException();	6✔
314	if (value < 0xFD)	88,324✔
315	{	88,123✔
316	writer.Write((byte)value);	88,123✔
317	}	88,123✔
318	else if (value <= 0xFFFF)	201✔
319	{	153✔
320	writer.Write((byte)0xFD);	153✔
321	writer.Write((ushort)value);	153✔
322	}	153✔
323	else if (value <= 0xFFFFFFFF)	48✔
324	{	30✔
325	writer.Write((byte)0xFE);	30✔
326	writer.Write((uint)value);	30✔
327	}	30✔
328	else
329	{	18✔
330	writer.Write((byte)0xFF);	18✔
331	writer.Write(value);	18✔
332	}	18✔
333	}	88,324✔
334
335	public static void WriteVarString(this BinaryWriter writer, string value)
336	{	41✔
337	writer.WriteVarBytes(Encoding.UTF8.GetBytes(value));	41✔
338	}	41✔
339	}
340	}

neo-project / neo / 74d16c3aa44c22de75cb274a756ae4a091aae3fe-PR-1374

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