/// <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); }