public static async Task Test_Buffered_Peeking_Can_Peek_Counted_Bytes_Async()
{
//arrange
DefaultStreamReaderStrategyAsync reader = new DefaultStreamReaderStrategyAsync(new byte[] { 5, 6, 7, 5 });
//act
IWireStreamReaderStrategyAsync peekedBufferReader = reader.PeekWithBufferingAsync();
byte[] peekedBytes = await peekedBufferReader.PeekBytesAsync(4);
byte[] peekedBytesAgain = await peekedBufferReader.PeekBytesAsync(2);
byte[] readBytes = await peekedBufferReader.ReadBytesAsync(4);
//assert
Assert.AreEqual(4, readBytes.Length);
for (int i = 0; i < peekedBytes.Length; i++)
{
Assert.AreEqual(peekedBytes[i], readBytes[i]);
}
for (int i = 0; i < peekedBytesAgain.Length; i++)
{
Assert.AreEqual(peekedBytes[i], peekedBytesAgain[i]);
}
Assert.Throws <InvalidOperationException>(() => peekedBufferReader.ReadByte());
}
public static async Task Test_Buffered_Peeking_Can_Peek_Bytes_Async()
{
//arrange
DefaultStreamReaderStrategyAsync reader = new DefaultStreamReaderStrategyAsync(new byte[] { 5, 6, 7, 5 });
//act
IWireStreamReaderStrategyAsync peekedBufferReader = reader.PeekWithBufferingAsync();
//assert
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(5, await peekedBufferReader.PeekByteAsync());
}
Assert.AreEqual(5, await peekedBufferReader.ReadByteAsync());
Assert.AreEqual(6, await peekedBufferReader.ReadByteAsync());
byte[] readBytes = await peekedBufferReader.ReadAllBytesAsync();
Assert.AreEqual(7, readBytes[0]);
Assert.AreEqual(5, readBytes[1]);
Assert.Throws <AggregateException>(() =>
{
byte b = peekedBufferReader.ReadByteAsync().Result;
});
}
public static async Task Test_That_Prepended_Reader_Contains_Bytes_Async(byte[] bytes)
{
//arrange
DefaultStreamReaderStrategyAsync reader = new DefaultStreamReaderStrategyAsync(new byte[0]);
//act
IWireStreamReaderStrategyAsync bufferedReader = reader.PreprendWithBytesAsync(bytes);
//assert
for (int i = 0; i < bytes.Length; i++)
{
Assert.AreEqual(await bufferedReader.ReadByteAsync(), bytes[i]);
}
}
public static async Task Test_Buffered_Peeking_Can_Peek_Byte_Async(byte b)
{
//arrange
DefaultStreamReaderStrategyAsync reader = new DefaultStreamReaderStrategyAsync(new byte[] { b });
//act
IWireStreamReaderStrategyAsync peekedBufferReader = reader.PeekWithBufferingAsync();
//assert
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(b, await peekedBufferReader.PeekByteAsync());
}
Assert.AreEqual(b, await peekedBufferReader.ReadByteAsync());
Assert.Throws <AggregateException>(() =>
{
byte sdsdf = peekedBufferReader.ReadByteAsync().Result;
});
}
public static void Test_That_Prepended_Reader_Contains_Bytes_After_The_Prended_Portion(byte[] bytes)
{
//arrange
DefaultStreamReaderStrategyAsync reader = new DefaultStreamReaderStrategyAsync(new byte[] { 5, 7 });
//act
IWireStreamReaderStrategyAsync bufferedReader = reader.PreprendWithBytesAsync(bytes);
byte[] readBytes = bufferedReader.ReadBytes(bytes.Length);
//assert
for (int i = 0; i < bytes.Length; i++)
{
Assert.AreEqual(readBytes[i], bytes[i]);
}
Assert.AreEqual(5, bufferedReader.ReadByte());
Assert.AreEqual(7, bufferedReader.ReadByte());
Assert.Throws <InvalidOperationException>(() => bufferedReader.ReadByte());
}
//TODO: Does this work for 0 length blocks?
private async Task <Dictionary <uint, string> > ReadDBCStringBlock(DBCHeader header)
{
Dictionary <uint, string> stringMap = new Dictionary <uint, string>(1000);
DBCStream.Position = header.StartStringPosition;
byte[] bytes = new byte[DBCStream.Length - DBCStream.Position];
await ReadBytesIntoArrayFromStream(bytes);
DefaultStreamReaderStrategyAsync stringReader = new DefaultStreamReaderStrategyAsync(bytes);
for (int currentOffset = 0; currentOffset < bytes.Length;)
{
string readString = (await Serializer.DeserializeAsync <StringDBC>(stringReader)).StringValue;
stringMap.Add((uint)currentOffset, readString);
//We must move the offset forward length + null terminator
currentOffset += readString.Length + 1;
}
return(stringMap);
}
public static async Task Test_That_Prepended_Reader_Contains_Bytes_After_The_Prended_Portion_Async(byte[] bytes)
{
//arrange
DefaultStreamReaderStrategyAsync reader = new DefaultStreamReaderStrategyAsync(new byte[] { 5, 7 });
//act
IWireStreamReaderStrategyAsync bufferedReader = reader.PreprendWithBytesAsync(bytes);
byte[] readBytes = await bufferedReader.ReadBytesAsync(bytes.Length);
//assert
for (int i = 0; i < bytes.Length; i++)
{
Assert.AreEqual(readBytes[i], bytes[i]);
}
Assert.AreEqual(5, await bufferedReader.ReadByteAsync());
Assert.AreEqual(7, await bufferedReader.ReadByteAsync());
Assert.Throws <AggregateException>(() =>
{
byte b = bufferedReader.ReadByteAsync().Result;
});
}
