/// <summary>
/// Write length + byte[]
/// </summary>
/// <param name="stream"></param>
/// <param name="buffer"></param>
/// <param name="length"></param>
/// <returns></returns>
internal static async Task WriteAsync(this Stream stream, byte[] buffer, SizeLength length)
{
byte[] bytesLength;
switch (length)
{
case SizeLength.BYTE:
bytesLength = new byte[] { (byte)buffer.Length };
break;
case SizeLength.SHORT:
bytesLength = BitConverter.GetBytes((Int16)buffer.Length);
break;
case SizeLength.INT:
bytesLength = BitConverter.GetBytes(buffer.Length);
break;
case SizeLength.LONG:
bytesLength = BitConverter.GetBytes(buffer.LongLength);
break;
default:
throw new InvalidCastException("Can´t find match for length: " + length.ToString());
}
await stream.WriteAsync(bytesLength);
await stream.WriteAsync(buffer);
}
private static byte[] SizedArrayRandom(SizeLength size, Random rd)
{
var length = LongRandom(1, MaxLengthBySize(size), rd);
var buffer = new byte[length];
rd.NextBytes(buffer);
return(buffer);
}
private static (int size, byte[] sizeBytes) GetRandomSize(SizeLength length, Random rand = null)
{
var random = rand ?? new Random();
int max = length == SizeLength.BYTE ? 255 : short.MaxValue;
var size = random.Next(1, max);
return(size, BitConverter.GetBytes(size));
}
public async Task ReadUnkownStringListAsync(IEnumerable <string> source, SizeLength length, byte[] input)
{
using (var stream = new MemoryStream(input))
{
var subject = await stream.ReadStringList(length, ";");
Assert.True(subject.HasValue(out var result));
Assert.True(CompareIEnumerable(source, result));
}
}
public async Task ReadUnknownStringAsync(string source, SizeLength length, byte[] input)
{
using (var stream = new MemoryStream(input))
{
var subject = await stream.ReadUnkownStringAsync(length);
Assert.True(subject.HasValue(out var result));
Assert.Equal(source, result);
}
}
public static IEnumerable <object[]> GetStringListArray(SizeLength length, IEnumerable <string> list)
{
var value = string.Join(";", list);
var resultobject = GetStringByteArray(length, value);
var result = resultobject.First()[2];
return(new[]
{
new object[] { list, length, result }
});
}
private static long MaxLengthBySize(SizeLength length)
{
switch (length)
{
case SizeLength.INT:
return(int.MaxValue);
case SizeLength.LONG:
return(long.MaxValue);
case SizeLength.SHORT:
return(short.MaxValue);
}
return(byte.MaxValue);
}
public async Task ReadUnknonwBytesAsync(SizeLength length, byte[] input)
{
try
{
var expected = new byte[input.Length - (int)length];
input.Skip((int)length).ToArray().CopyTo(expected, 0);
using (var stream = new MemoryStream(input))
{
var subject = await stream.ReadUnknonwBytesAsync(length);
Assert.True(subject.HasValue(out var result));
Assert.True(CompareIEnumerable(expected, result));
}
}
catch (Exception ex)
{
Assert.True(false, $"{length} message: {ex.Message}");
}
}
/// <summary>
/// Generate byte array with size + content as length
/// </summary>
/// <returns></returns>
public static IEnumerable <object[]> GetSizedByteArray(SizeLength length)
{
var rdm = new Random();
for (byte i = 0; i < 10; i++)
{
// generate a random size
var(size, sizeArray) = GetRandomSize(length, rdm);
// generate content with size of number
var contentArray = GetRandomByteArray(size, rdm);
// calculate total length (size + content)
var finalSize = size + (int)length;
// generate result
var finalArray = new byte[finalSize];
sizeArray.CopyTo(finalArray, 0);
contentArray.CopyTo(finalArray, (int)length);
yield return(new object[] { length, finalArray });
}
}
public static IEnumerable <object[]> GetStringByteArray(SizeLength length, string text)
{
byte[] size = new byte[0];
switch (length)
{
case SizeLength.BYTE:
size = new byte[] { (byte)text.Length };
break;
case SizeLength.SHORT:
size = BitConverter.GetBytes((short)text.Length);
break;
case SizeLength.INT:
size = BitConverter.GetBytes(text.Length);
break;
case SizeLength.LONG:
size = BitConverter.GetBytes((long)text.Length);
break;
default:
throw new NotImplementedException();
}
byte[] utf8String = Encoding.UTF8.GetBytes(text);
byte[] result = new byte[size.Length + utf8String.Length];
size.CopyTo(result, 0);
utf8String.CopyTo(result, size.Length);
return(new[]
{
new object[] { text, length, result }
});
}
/// <summary>
/// when you have the length + message to read
/// </summary>
/// <param name="stream"></param>
/// <param name="length"></param>
/// <returns></returns>
internal static async Task <Option <byte[]> > ReadUnknonwBytesAsync(this Stream stream, SizeLength length)
{
var maybeBytesToRead = await stream.ReadBytesAsync((int)length);
if (!maybeBytesToRead.ToLong().HasValue(out var bytesToRead))
{
return(None <byte[]>());
}
return(await stream.ReadBytesAsync(bytesToRead));
}
public static IEnumerable <object[]> GetUnknownListString(SizeLength size)
=> DataGenerator.GetStringListArray(size, new string[] { "32321", "dsadsa", "321", "dajyujuy", "fapo" });
public static IEnumerable <object[]> GetUnkownSizeString(SizeLength size) => DataGenerator.GetStringByteArray(size, "some string to show");
public static IEnumerable <object[]> GetUnkownSizeArray(SizeLength size) => DataGenerator.GetSizedByteArray(size);
/// <summary>
/// Read a UTF8 string and split it using the separator
/// </summary>
/// <param name="stream"></param>
/// <param name="length"></param>
/// <param name="separator"></param>
/// <returns></returns>
internal static async Task <Option <IEnumerable <string> > > ReadStringList(this Stream stream, SizeLength length, string separator)
{
var rawString = await stream.ReadUnkownStringAsync(length);
return(rawString
.Pipe(e => e.Split(separator, StringSplitOptions.RemoveEmptyEntries))
.Pipe(e => e.AsEnumerable()));
}
/// <summary>
/// read a UTF8 string from a byte array
/// </summary>
/// <param name="stream"></param>
/// <param name="length"></param>
/// <returns></returns>
internal static async Task <Option <string> > ReadUnkownStringAsync(this Stream stream, SizeLength length)
{
var maybeBytes = await stream.ReadUnknonwBytesAsync(length);
if (!maybeBytes.HasValue(out var bytes))
{
return(None <string>());
}
return(Some(Encoding.UTF8.GetString(bytes)));
}
/// <summary>
/// Write a UTF8 string
/// </summary>
/// <param name="stream"></param>
/// <param name="value"></param>
/// <param name="length"></param>
/// <returns></returns>
internal static async Task WriteUTF8Async(this Stream stream, string value, SizeLength length)
{
await stream.WriteAsync(Encoding.UTF8.GetBytes(value), length);
}
