1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
3 // See the LICENSE file in the project root for more information.
4 
5 using Xunit;
6 
7 namespace System.Tests
8 {
9     public class BitConverterSpan : BitConverterBase
10     {
11         [Fact]
TryWriteBytes_DestinationSpanNotLargeEnough()12         public void TryWriteBytes_DestinationSpanNotLargeEnough()
13         {
14             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, false));
15             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, 'a'));
16             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, (short)2));
17             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, 2));
18             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, (long)2));
19             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, (ushort)2));
20             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, (uint)2));
21             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, (ulong)2));
22             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, (float)2));
23             Assert.False(BitConverter.TryWriteBytes(Span<byte>.Empty, 2.0));
24         }
25 
26         [Fact]
ToMethods_DestinationSpanNotLargeEnough()27         public void ToMethods_DestinationSpanNotLargeEnough()
28         {
29             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToChar(Span<byte>.Empty); });
30             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToInt16(Span<byte>.Empty); });
31             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToInt32(Span<byte>.Empty); });
32             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToInt64(Span<byte>.Empty); });
33             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToUInt16(Span<byte>.Empty); });
34             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToUInt32(Span<byte>.Empty); });
35             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToUInt64(Span<byte>.Empty); });
36             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToSingle(Span<byte>.Empty); });
37             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToDouble(Span<byte>.Empty); });
38             Assert.Throws<ArgumentOutOfRangeException>(() => { BitConverter.ToBoolean(Span<byte>.Empty); });
39         }
40 
ConvertFromBool(bool boolean, byte[] expected)41         public override void ConvertFromBool(bool boolean, byte[] expected)
42         {
43             Span<byte> span = new Span<byte>(new byte[1]);
44             Assert.True(BitConverter.TryWriteBytes(span, boolean));
45             Assert.Equal(expected, span.ToArray());
46         }
47 
ConvertFromShort(short num, byte[] expected)48         public override void ConvertFromShort(short num, byte[] expected)
49         {
50             Span<byte> span = new Span<byte>(new byte[2]);
51             Assert.True(BitConverter.TryWriteBytes(span, num));
52             Assert.Equal(expected, span.ToArray());
53         }
54 
ConvertFromChar(char character, byte[] expected)55         public override void ConvertFromChar(char character, byte[] expected)
56         {
57             Span<byte> span = new Span<byte>(new byte[2]);
58             Assert.True(BitConverter.TryWriteBytes(span, character));
59             Assert.Equal(expected, span.ToArray());
60         }
61 
ConvertFromInt(int num, byte[] expected)62         public override void ConvertFromInt(int num, byte[] expected)
63         {
64             Span<byte> span = new Span<byte>(new byte[4]);
65             Assert.True(BitConverter.TryWriteBytes(span, num));
66             Assert.Equal(expected, span.ToArray());
67         }
68 
ConvertFromLong(long num, byte[] expected)69         public override void ConvertFromLong(long num, byte[] expected)
70         {
71             Span<byte> span = new Span<byte>(new byte[8]);
72             Assert.True(BitConverter.TryWriteBytes(span, num));
73             Assert.Equal(expected, span.ToArray());
74         }
75 
ConvertFromUShort(ushort num, byte[] expected)76         public override void ConvertFromUShort(ushort num, byte[] expected)
77         {
78             Span<byte> span = new Span<byte>(new byte[2]);
79             Assert.True(BitConverter.TryWriteBytes(span, num));
80             Assert.Equal(expected, span.ToArray());
81         }
82 
ConvertFromUInt(uint num, byte[] expected)83         public override void ConvertFromUInt(uint num, byte[] expected)
84         {
85             Span<byte> span = new Span<byte>(new byte[4]);
86             Assert.True(BitConverter.TryWriteBytes(span, num));
87             Assert.Equal(expected, span.ToArray());
88         }
89 
ConvertFromULong(ulong num, byte[] expected)90         public override void ConvertFromULong(ulong num, byte[] expected)
91         {
92             Span<byte> span = new Span<byte>(new byte[8]);
93             Assert.True(BitConverter.TryWriteBytes(span, num));
94             Assert.Equal(expected, span.ToArray());
95         }
96 
ConvertFromFloat(float num, byte[] expected)97         public override void ConvertFromFloat(float num, byte[] expected)
98         {
99             Span<byte> span = new Span<byte>(new byte[4]);
100             Assert.True(BitConverter.TryWriteBytes(span, num));
101             Assert.Equal(expected, span.ToArray());
102         }
103 
ConvertFromDouble(double num, byte[] expected)104         public override void ConvertFromDouble(double num, byte[] expected)
105         {
106             Span<byte> span = new Span<byte>(new byte[8]);
107             Assert.True(BitConverter.TryWriteBytes(span, num));
108             Assert.Equal(expected, span.ToArray());
109         }
110 
ToChar(int index, char expected, byte[] byteArray)111         public override void ToChar(int index, char expected, byte[] byteArray)
112         {
113             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
114             BitConverter.ToChar(span);
115             Assert.Equal(expected, BitConverter.ToChar(span.Slice(index)));
116         }
117 
ToInt16(int index, short expected, byte[] byteArray)118         public override void ToInt16(int index, short expected, byte[] byteArray)
119         {
120             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
121             Assert.Equal(expected, BitConverter.ToInt16(span.Slice(index)));
122         }
123 
ToInt32(int expected, byte[] byteArray)124         public override void ToInt32(int expected, byte[] byteArray)
125         {
126             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
127             Assert.Equal(expected, BitConverter.ToInt32(byteArray));
128         }
129 
ToInt64(int index, long expected, byte[] byteArray)130         public override void ToInt64(int index, long expected, byte[] byteArray)
131         {
132             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
133             Assert.Equal(expected, BitConverter.ToInt64(span.Slice(index)));
134         }
135 
ToUInt16(int index, ushort expected, byte[] byteArray)136         public override void ToUInt16(int index, ushort expected, byte[] byteArray)
137         {
138             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
139             Assert.Equal(expected, BitConverter.ToUInt16(span.Slice(index)));
140         }
141 
ToUInt32(int index, uint expected, byte[] byteArray)142         public override void ToUInt32(int index, uint expected, byte[] byteArray)
143         {
144             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
145             Assert.Equal(expected, BitConverter.ToUInt32(span.Slice(index)));
146         }
147 
ToUInt64(int index, ulong expected, byte[] byteArray)148         public override void ToUInt64(int index, ulong expected, byte[] byteArray)
149         {
150             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
151             Assert.Equal(expected, BitConverter.ToUInt64(span.Slice(index)));
152         }
153 
ToSingle(int index, float expected, byte[] byteArray)154         public override void ToSingle(int index, float expected, byte[] byteArray)
155         {
156             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
157             Assert.Equal(expected, BitConverter.ToSingle(span.Slice(index)));
158         }
159 
ToDouble(int index, double expected, byte[] byteArray)160         public override void ToDouble(int index, double expected, byte[] byteArray)
161         {
162             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
163             Assert.Equal(expected, BitConverter.ToDouble(span.Slice(index)));
164         }
165 
ToBoolean(int index, bool expected, byte[] byteArray)166         public override void ToBoolean(int index, bool expected, byte[] byteArray)
167         {
168             ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(byteArray);
169             Assert.Equal(expected, BitConverter.ToBoolean(span.Slice(index)));
170         }
171     }
172 }
173