11749148627

Committed 08 Nov 2024 08:32PM UTC coverage: 55.81% (-0.04%) from 55.851%

Build # 11749148627

Build Type

Pull #3410

github

Committed by

web-flow

Commit Message

Merge bee29d124 into 406414b6f

Pull Request Pull Request #3410: `[Move]` Part-6 Classes into Different Library - `Neo.Extensions`

Run Details

5778 of 8946 branches covered (64.59%)

Branch coverage included in aggregate %.

157 of 275 new or added lines in 10 files covered. (57.09%)

46 existing lines in 3 files now uncovered.

21773 of 40420 relevant lines covered (53.87%)

85855.39 hits per line

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

80.95

/src/Neo/Extensions/SpanExtensions.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// SpanExtensions.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 K4os.Compression.LZ4;
using System;
using System.Buffers.Binary;

namespace Neo.Extensions
{
    public static class SpanExtensions
    {
        /// <summary>
        /// Compresses the specified data using the LZ4 algorithm.
        /// </summary>
        /// <param name="data">The data to be compressed.</param>
        /// <returns>The compressed data.</returns>
        public static ReadOnlyMemory<byte> CompressLz4(this ReadOnlySpan<byte> data)
        {
            var maxLength = LZ4Codec.MaximumOutputSize(data.Length);
            var buffer = new byte[sizeof(uint) + maxLength];
            BinaryPrimitives.WriteInt32LittleEndian(buffer, data.Length);
            var length = LZ4Codec.Encode(data, buffer.AsSpan(sizeof(uint)));
            return buffer.AsMemory(0, sizeof(uint) + length);
        }

        /// <summary>
        /// Compresses the specified data using the LZ4 algorithm.
        /// </summary>
        /// <param name="data">The data to be compressed.</param>
        /// <returns>The compressed data.</returns>
        public static ReadOnlyMemory<byte> CompressLz4(this Span<byte> data)
        {
            var maxLength = LZ4Codec.MaximumOutputSize(data.Length);
            var buffer = new byte[sizeof(uint) + maxLength];
            BinaryPrimitives.WriteInt32LittleEndian(buffer, data.Length);
            var length = LZ4Codec.Encode(data, buffer.AsSpan(sizeof(uint)));
            return buffer.AsMemory(0, sizeof(uint) + length);
        }

        /// <summary>
        /// Decompresses the specified data using the LZ4 algorithm.
        /// </summary>
        /// <param name="data">The compressed data.</param>
        /// <param name="maxOutput">The maximum data size after decompression.</param>
        /// <returns>The original data.</returns>
        public static byte[] DecompressLz4(this ReadOnlySpan<byte> data, int maxOutput)
        {
            var length = BinaryPrimitives.ReadInt32LittleEndian(data);
            if (length < 0 || length > maxOutput) throw new FormatException();
            var result = new byte[length];
            if (LZ4Codec.Decode(data[4..], result) != length)
                throw new FormatException();
            return result;
        }

        /// <summary>
        /// Decompresses the specified data using the LZ4 algorithm.
        /// </summary>
        /// <param name="data">The compressed data.</param>
        /// <param name="maxOutput">The maximum data size after decompression.</param>
        /// <returns>The original data.</returns>
        public static byte[] DecompressLz4(this Span<byte> data, int maxOutput)
        {
            var length = BinaryPrimitives.ReadInt32LittleEndian(data);
            if (length < 0 || length > maxOutput) throw new FormatException();
            var result = new byte[length];
            if (LZ4Codec.Decode(data[4..], result) != length)
                throw new FormatException();
            return result;
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// SpanExtensions.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 K4os.Compression.LZ4;
13	using System;
14	using System.Buffers.Binary;
15
16	namespace Neo.Extensions
17	{
18	public static class SpanExtensions
19	{
20	/// <summary>
21	/// Compresses the specified data using the LZ4 algorithm.
22	/// </summary>
23	/// <param name="data">The data to be compressed.</param>
24	/// <returns>The compressed data.</returns>
25	public static ReadOnlyMemory<byte> CompressLz4(this ReadOnlySpan<byte> data)
26	{	1✔
27	var maxLength = LZ4Codec.MaximumOutputSize(data.Length);	1✔
28	var buffer = new byte[sizeof(uint) + maxLength];	1✔
29	BinaryPrimitives.WriteInt32LittleEndian(buffer, data.Length);	1✔
30	var length = LZ4Codec.Encode(data, buffer.AsSpan(sizeof(uint)));	1✔
31	return buffer.AsMemory(0, sizeof(uint) + length);	1✔
32	}	1✔
33
34	/// <summary>
35	/// Compresses the specified data using the LZ4 algorithm.
36	/// </summary>
37	/// <param name="data">The data to be compressed.</param>
38	/// <returns>The compressed data.</returns>
39	public static ReadOnlyMemory<byte> CompressLz4(this Span<byte> data)
40	{	2✔
41	var maxLength = LZ4Codec.MaximumOutputSize(data.Length);	2✔
42	var buffer = new byte[sizeof(uint) + maxLength];	2✔
43	BinaryPrimitives.WriteInt32LittleEndian(buffer, data.Length);	2✔
44	var length = LZ4Codec.Encode(data, buffer.AsSpan(sizeof(uint)));	2✔
45	return buffer.AsMemory(0, sizeof(uint) + length);	2✔
46	}	2✔
47
48	/// <summary>
49	/// Decompresses the specified data using the LZ4 algorithm.
50	/// </summary>
51	/// <param name="data">The compressed data.</param>
52	/// <param name="maxOutput">The maximum data size after decompression.</param>
53	/// <returns>The original data.</returns>
54	public static byte[] DecompressLz4(this ReadOnlySpan<byte> data, int maxOutput)
55	{	5✔
56	var length = BinaryPrimitives.ReadInt32LittleEndian(data);	5✔
57	if (length < 0 \|\| length > maxOutput) throw new FormatException();	7!
58	var result = new byte[length];	3✔
59	if (LZ4Codec.Decode(data[4..], result) != length)	3!
NEW 60	throw new FormatException();	×
61	return result;	3✔
62	}	3✔
63
64	/// <summary>
65	/// Decompresses the specified data using the LZ4 algorithm.
66	/// </summary>
67	/// <param name="data">The compressed data.</param>
68	/// <param name="maxOutput">The maximum data size after decompression.</param>
69	/// <returns>The original data.</returns>
70	public static byte[] DecompressLz4(this Span<byte> data, int maxOutput)
71	{	1✔
72	var length = BinaryPrimitives.ReadInt32LittleEndian(data);	1✔
73	if (length < 0 \|\| length > maxOutput) throw new FormatException();	1!
74	var result = new byte[length];	1✔
75	if (LZ4Codec.Decode(data[4..], result) != length)	1!
76	throw new FormatException();	1✔
NEW 77	return result;	×
NEW 78	}	×
79	}
80	}

neo-project / neo / 11749148627

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