< Summary

Information
Class: Renci.SshNet.Common.Pack
Assembly: Renci.SshNet
File(s): \home\appveyor\projects\ssh-net\src\Renci.SshNet\Common\Pack.cs
Line coverage
90%
Covered lines: 126
Uncovered lines: 13
Coverable lines: 139
Total lines: 271
Line coverage: 90.6%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
LittleEndianToUInt16(...)100%1100%
LittleEndianToUInt32(...)100%10%
LittleEndianToUInt32(...)100%1100%
LittleEndianToUInt64(...)100%1100%
UInt16ToLittleEndian(...)100%1100%
UInt16ToLittleEndian(...)100%1100%
UInt32ToLittleEndian(...)100%1100%
UInt32ToLittleEndian(...)100%1100%
UInt32ToLittleEndian(...)100%10%
UInt64ToLittleEndian(...)100%1100%
UInt64ToLittleEndian(...)100%1100%
UInt16ToBigEndian(...)100%1100%
UInt16ToBigEndian(...)100%1100%
UInt16ToBigEndian(...)100%1100%
UInt32ToBigEndian(...)100%1100%
UInt32ToBigEndian(...)100%1100%
UInt32ToBigEndian(...)100%1100%
UInt64ToBigEndian(...)100%1100%
BigEndianToUInt16(...)100%1100%
BigEndianToUInt32(...)100%1100%
BigEndianToUInt32(...)100%1100%
BigEndianToUInt64(...)100%1100%

File(s)

\home\appveyor\projects\ssh-net\src\Renci.SshNet\Common\Pack.cs

#LineLine coverage
 1namespace Renci.SshNet.Common
 2{
 3    /// <summary>
 4    /// Provides convenience methods for conversion to and from both Big Endian and Little Endian.
 5    /// </summary>
 6    internal static class Pack
 7    {
 8        /// <summary>
 9        /// Converts little endian bytes into number.
 10        /// </summary>
 11        /// <param name="buffer">The buffer.</param>
 12        /// <returns>Converted <see cref="ushort" />.</returns>
 13        internal static ushort LittleEndianToUInt16(byte[] buffer)
 1814        {
 1815            ushort n = buffer[0];
 1816            n |= (ushort) (buffer[1] << 8);
 1817            return n;
 1818        }
 19
 20        /// <summary>
 21        /// Converts little endian bytes into number.
 22        /// </summary>
 23        /// <param name="buffer">The buffer.</param>
 24        /// <param name="offset">The buffer offset.</param>
 25        /// <returns>Converted <see cref="uint" />.</returns>
 26        internal static uint LittleEndianToUInt32(byte[] buffer, int offset)
 027        {
 028            uint n = buffer[offset];
 029            n |= (uint) buffer[offset + 1] << 8;
 030            n |= (uint) buffer[offset + 2] << 16;
 031            n |= (uint) buffer[offset + 3] << 24;
 032            return n;
 033        }
 34
 35        /// <summary>
 36        /// Converts little endian bytes into number.
 37        /// </summary>
 38        /// <param name="buffer">The buffer.</param>
 39        /// <returns>Converted <see cref="uint" />.</returns>
 40        internal static uint LittleEndianToUInt32(byte[] buffer)
 2741        {
 2742            uint n = buffer[0];
 2743            n |= (uint) buffer[1] << 8;
 2744            n |= (uint) buffer[2] << 16;
 2745            n |= (uint) buffer[3] << 24;
 2746            return n;
 2747        }
 48
 49        /// <summary>
 50        /// Converts little endian bytes into number.
 51        /// </summary>
 52        /// <param name="buffer">The buffer.</param>
 53        /// <returns>Converted <see cref="ulong" />.</returns>
 54        internal static ulong LittleEndianToUInt64(byte[] buffer)
 3955        {
 3956            ulong n = buffer[0];
 3957            n |= (ulong) buffer[1] << 8;
 3958            n |= (ulong) buffer[2] << 16;
 3959            n |= (ulong) buffer[3] << 24;
 3960            n |= (ulong) buffer[4] << 32;
 3961            n |= (ulong) buffer[5] << 40;
 3962            n |= (ulong) buffer[6] << 48;
 3963            n |= (ulong) buffer[7] << 56;
 3964            return n;
 3965        }
 66
 67        /// <summary>
 68        /// Populates buffer with little endian number representation.
 69        /// </summary>
 70        /// <param name="value">The number to convert.</param>
 71        internal static byte[] UInt16ToLittleEndian(ushort value)
 1872        {
 1873            var buffer = new byte[2];
 1874            UInt16ToLittleEndian(value, buffer);
 1875            return buffer;
 1876        }
 77
 78        /// <summary>
 79        /// Populates buffer with little endian number representation.
 80        /// </summary>
 81        /// <param name="value">The number to convert.</param>
 82        /// <param name="buffer">The buffer.</param>
 83        internal static void UInt16ToLittleEndian(ushort value, byte[] buffer)
 1884        {
 1885            buffer[0] = (byte) (value & 0x00FF);
 1886            buffer[1] = (byte) ((value & 0xFF00) >> 8);
 1887        }
 88
 89        /// <summary>
 90        /// Populates buffer with little endian number representation.
 91        /// </summary>
 92        /// <param name="value">The number to convert.</param>
 93        internal static byte[] UInt32ToLittleEndian(uint value)
 2794        {
 2795            var buffer = new byte[4];
 2796            UInt32ToLittleEndian(value, buffer);
 2797            return buffer;
 2798        }
 99
 100        /// <summary>
 101        /// Populates buffer with little endian number representation.
 102        /// </summary>
 103        /// <param name="value">The number to convert.</param>
 104        /// <param name="buffer">The buffer.</param>
 105        internal static void UInt32ToLittleEndian(uint value, byte[] buffer)
 27106        {
 27107            buffer[0] = (byte) (value & 0x000000FF);
 27108            buffer[1] = (byte) ((value & 0x0000FF00) >> 8);
 27109            buffer[2] = (byte) ((value & 0x00FF0000) >> 16);
 27110            buffer[3] = (byte) ((value & 0xFF000000) >> 24);
 27111        }
 112
 113        /// <summary>
 114        /// Populates buffer with little endian number representation.
 115        /// </summary>
 116        /// <param name="value">The number to convert.</param>
 117        /// <param name="buffer">The buffer.</param>
 118        /// <param name="offset">The buffer offset.</param>
 119        internal static void UInt32ToLittleEndian(uint value, byte[] buffer, int offset)
 0120        {
 0121            buffer[offset] = (byte) (value & 0x000000FF);
 0122            buffer[offset + 1] = (byte) ((value & 0x0000FF00) >> 8);
 0123            buffer[offset + 2] = (byte) ((value & 0x00FF0000) >> 16);
 0124            buffer[offset + 3] = (byte) ((value & 0xFF000000) >> 24);
 0125        }
 126
 127        /// <summary>
 128        /// Populates buffer with little endian number representation.
 129        /// </summary>
 130        /// <param name="value">The number to convert.</param>
 131        internal static byte[] UInt64ToLittleEndian(ulong value)
 39132        {
 39133            var buffer = new byte[8];
 39134            UInt64ToLittleEndian(value, buffer);
 39135            return buffer;
 39136        }
 137
 138        /// <summary>
 139        /// Populates buffer with little endian number representation.
 140        /// </summary>
 141        /// <param name="value">The number to convert.</param>
 142        /// <param name="buffer">The buffer.</param>
 143        internal static void UInt64ToLittleEndian(ulong value, byte[] buffer)
 39144        {
 39145            buffer[0] = (byte) (value & 0x00000000000000FF);
 39146            buffer[1] = (byte) ((value & 0x000000000000FF00) >> 8);
 39147            buffer[2] = (byte) ((value & 0x0000000000FF0000) >> 16);
 39148            buffer[3] = (byte) ((value & 0x00000000FF000000) >> 24);
 39149            buffer[4] = (byte) ((value & 0x000000FF00000000) >> 32);
 39150            buffer[5] = (byte) ((value & 0x0000FF0000000000) >> 40);
 39151            buffer[6] = (byte) ((value & 0x00FF000000000000) >> 48);
 39152            buffer[7] = (byte) ((value & 0xFF00000000000000) >> 56);
 39153        }
 154
 155        internal static byte[] UInt16ToBigEndian(ushort value)
 18156        {
 18157            var buffer = new byte[2];
 18158            UInt16ToBigEndian(value, buffer);
 18159            return buffer;
 18160        }
 161
 162        internal static void UInt16ToBigEndian(ushort value, byte[] buffer)
 18163        {
 18164            buffer[0] = (byte) (value >> 8);
 18165            buffer[1] = (byte) (value & 0x00FF);
 18166        }
 167
 168        internal static void UInt16ToBigEndian(ushort value, byte[] buffer, int offset)
 102169        {
 102170            buffer[offset] = (byte) (value >> 8);
 102171            buffer[offset + 1] = (byte) (value & 0x00FF);
 102172        }
 173
 174        internal static void UInt32ToBigEndian(uint value, byte[] buffer)
 475589175        {
 475589176            buffer[0] = (byte) ((value & 0xFF000000) >> 24);
 475589177            buffer[1] = (byte) ((value & 0x00FF0000) >> 16);
 475589178            buffer[2] = (byte) ((value & 0x0000FF00) >> 8);
 475589179            buffer[3] = (byte) (value & 0x000000FF);
 475589180        }
 181
 182        internal static void UInt32ToBigEndian(uint value, byte[] buffer, int offset)
 13980183        {
 13980184            buffer[offset++] = (byte) ((value & 0xFF000000) >> 24);
 13980185            buffer[offset++] = (byte) ((value & 0x00FF0000) >> 16);
 13980186            buffer[offset++] = (byte) ((value & 0x0000FF00) >> 8);
 13980187            buffer[offset] = (byte) (value & 0x000000FF);
 13980188        }
 189
 190        internal static byte[] UInt32ToBigEndian(uint value)
 368731191        {
 368731192            var buffer = new byte[4];
 368731193            UInt32ToBigEndian(value, buffer);
 368731194            return buffer;
 368731195        }
 196
 197        /// <summary>
 198        /// Returns the specified 64-bit unsigned integer value as an array of bytes.
 199        /// </summary>
 200        /// <param name="value">The number to convert.</param>
 201        /// <returns>An array of bytes with length 8.</returns>
 202        internal static byte[] UInt64ToBigEndian(ulong value)
 8221203        {
 8221204            return new[]
 8221205                {
 8221206                    (byte) ((value & 0xFF00000000000000) >> 56),
 8221207                    (byte) ((value & 0x00FF000000000000) >> 48),
 8221208                    (byte) ((value & 0x0000FF0000000000) >> 40),
 8221209                    (byte) ((value & 0x000000FF00000000) >> 32),
 8221210                    (byte) ((value & 0x00000000FF000000) >> 24),
 8221211                    (byte) ((value & 0x0000000000FF0000) >> 16),
 8221212                    (byte) ((value & 0x000000000000FF00) >> 8),
 8221213                    (byte) (value & 0x00000000000000FF)
 8221214                };
 8221215        }
 216
 217        /// <summary>
 218        /// Converts big endian bytes into number.
 219        /// </summary>
 220        /// <param name="buffer">The buffer.</param>
 221        /// <returns>Converted <see cref="ushort" />.</returns>
 222        internal static ushort BigEndianToUInt16(byte[] buffer)
 97223        {
 97224            return (ushort) (buffer[0] << 8 | buffer[1]);
 97225        }
 226
 227        /// <summary>
 228        /// Converts big endian bytes into number.
 229        /// </summary>
 230        /// <param name="buffer">The buffer.</param>
 231        /// <param name="offset">The buffer offset.</param>
 232        /// <returns>Converted <see cref="uint" />.</returns>
 233        internal static uint BigEndianToUInt32(byte[] buffer, int offset)
 13980234        {
 13980235            return (uint) buffer[offset + 0] << 24 |
 13980236                   (uint) buffer[offset + 1] << 16 |
 13980237                   (uint) buffer[offset + 2] << 8 |
 13980238                   buffer[offset + 3];
 13980239        }
 240
 241        /// <summary>
 242        /// Converts big endian bytes into number.
 243        /// </summary>
 244        /// <param name="buffer">The buffer.</param>
 245        /// <returns>Converted <see cref="uint" />.</returns>
 246        internal static uint BigEndianToUInt32(byte[] buffer)
 416495247        {
 416495248            return (uint) buffer[0] << 24 |
 416495249                   (uint) buffer[1] << 16 |
 416495250                   (uint) buffer[2] << 8 |
 416495251                   buffer[3];
 416495252        }
 253
 254        /// <summary>
 255        /// Converts big endian bytes into number.
 256        /// </summary>
 257        /// <param name="buffer">The buffer.</param>
 258        /// <returns>Converted <see cref="ulong" />.</returns>
 259        internal static ulong BigEndianToUInt64(byte[] buffer)
 10817260        {
 10817261            return (ulong) buffer[0] << 56 |
 10817262                   (ulong) buffer[1] << 48 |
 10817263                   (ulong) buffer[2] << 40 |
 10817264                   (ulong) buffer[3] << 32 |
 10817265                   (ulong) buffer[4] << 24 |
 10817266                   (ulong) buffer[5] << 16 |
 10817267                   (ulong) buffer[6] << 8 |
 10817268                   buffer[7];
 10817269        }
 270    }
 271}
Generated by: ReportGenerator 5.2.0.0
11/29/2023 - 11:22:39 AM
GitHub | reportgenerator.io

Methods/Properties

LittleEndianToUInt16(System.Byte[])
LittleEndianToUInt32(System.Byte[],System.Int32)
LittleEndianToUInt32(System.Byte[])
LittleEndianToUInt64(System.Byte[])
UInt16ToLittleEndian(System.UInt16)
UInt16ToLittleEndian(System.UInt16,System.Byte[])
UInt32ToLittleEndian(System.UInt32)
UInt32ToLittleEndian(System.UInt32,System.Byte[])
UInt32ToLittleEndian(System.UInt32,System.Byte[],System.Int32)
UInt64ToLittleEndian(System.UInt64)
UInt64ToLittleEndian(System.UInt64,System.Byte[])
UInt16ToBigEndian(System.UInt16)
UInt16ToBigEndian(System.UInt16,System.Byte[])
UInt16ToBigEndian(System.UInt16,System.Byte[],System.Int32)
UInt32ToBigEndian(System.UInt32,System.Byte[])
UInt32ToBigEndian(System.UInt32,System.Byte[],System.Int32)
UInt32ToBigEndian(System.UInt32)
UInt64ToBigEndian(System.UInt64)
BigEndianToUInt16(System.Byte[])
BigEndianToUInt32(System.Byte[],System.Int32)
BigEndianToUInt32(System.Byte[])
BigEndianToUInt64(System.Byte[])