private async Task WriteOutAsync(HashedStream inStr, HashedStream outStr)
{
Random rand = new Random();
using (inStr)
using (outStr)
{
Assert.True(inStr.CanRead);
Assert.True(outStr.CanWrite);
if (inStr.CanTimeout)
Assert.NotEqual(0, inStr.ReadTimeout);
if (outStr.CanTimeout)
Assert.NotEqual(0, outStr.WriteTimeout);
for (;;)
{
var buffer = new byte[rand.Next(1, 20000)];
int read = await inStr.ReadAsync(buffer, 0, buffer.Length);
if (read == 0)
return;
await outStr.WriteAsync(buffer, 0, read);
int by = inStr.ReadByte();
if (by == -1)
return;
outStr.WriteByte((byte)by);
}
}
}
public async Task DefaultConstAsync()
{
var fs = GetFileStream();
var ms = Stream.Null;
var hashIn = new HashedStream(fs);
var hashOut = new HashedStream(ms);
await WriteOutAsync(hashIn, hashOut);
Assert.False(hashIn.WasMoved);
Assert.True(hashIn.ReadHash128 == hashOut.WriteHash128);
Assert.True(hashIn.ReadHash32 == hashOut.WriteHash32);
Assert.True(hashIn.ReadHash64 == hashOut.WriteHash64);
}
public void HashExternal64()
{
long hash;
using(var hs = new HashedStream(GetFileStream()))
{
hash = SpookyHasher.SpookyHash64(hs);
Assert.Equal(hash, hs.ReadHash64);
}
using(var fs = GetFileStream())
Assert.Equal((ulong)hash, SpookyHasher.SpookyHash64(fs, 0xDEADBEEFDEADBEEF));
using(var fs = GetFileStream())
Assert.Equal(hash, unchecked(SpookyHasher.SpookyHash64(fs, (long)0xDEADBEEFDEADBEEF)));
}
public async Task HashExternal64Async()
{
long hash;
using (var hs = new HashedStream(GetFileStream()))
{
hash = await SpookyHasher.SpookyHash64Async(hs);
Assert.Equal(hash, hs.ReadHash64);
}
using (var fs = GetFileStream())
Assert.Equal((ulong)hash, await SpookyHasher.SpookyHash64Async(fs, 0xDEADBEEFDEADBEEF));
using (var fs = GetFileStream())
Assert.Equal(hash, unchecked(await SpookyHasher.SpookyHash64Async(fs, (long)0xDEADBEEFDEADBEEF)));
}
public void HashExternal128()
{
HashCode128 hash;
using(var hs = new HashedStream(GetFileStream()))
{
hash = SpookyHasher.SpookyHash128(hs);
Assert.Equal(hash, hs.ReadHash128);
}
using(var fs = GetFileStream())
Assert.Equal(hash, SpookyHasher.SpookyHash128(fs, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF));
using(var fs = GetFileStream())
Assert.Equal(
hash,
unchecked(SpookyHasher.SpookyHash128(
fs,
(long)0xDEADBEEFDEADBEEF,
(long)0xDEADBEEFDEADBEEF)));
}
public async Task HashExternal128Async()
{
HashCode128 hash;
using (var hs = new HashedStream(GetFileStream()))
{
hash = await SpookyHasher.SpookyHash128Async(hs);
Assert.Equal(hash, hs.ReadHash128);
}
using (var fs = GetFileStream())
Assert.Equal(hash, await SpookyHasher.SpookyHash128Async(fs, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF));
using (var fs = GetFileStream())
Assert.Equal(
hash,
await unchecked(SpookyHasher.SpookyHash128Async(
fs,
(long)0xDEADBEEFDEADBEEF,
(long)0xDEADBEEFDEADBEEF)));
}
public void TimeoutWrite()
{
WebRequest wr = WebRequest.Create("http://www.google.com/");
wr.Method = "POST";
var stm = wr.GetRequestStream();
using(var hs = new HashedStream(stm))
{
Assert.Equal(stm.WriteTimeout, hs.WriteTimeout);
hs.WriteTimeout = stm.WriteTimeout;
}
}
public void TimeoutRead()
{
WebRequest wr = WebRequest.Create("http://www.google.com/");
using(var rsp = wr.GetResponse())
{
var stm = rsp.GetResponseStream();
using(var hs = new HashedStream(stm))
{
Assert.Equal(stm.ReadTimeout, hs.ReadTimeout);
hs.ReadTimeout = stm.ReadTimeout;
}
}
}
public async Task MoveStreamAsync()
{
using (var hashOut = new HashedStream(new MemoryStream()))
using (var tw = new StreamWriter(hashOut))
{
string asciiOnlyString = "Something or other";
await tw.WriteAsync(asciiOnlyString);
await tw.FlushAsync();
Assert.Equal(asciiOnlyString.Length, hashOut.Length);
Assert.Equal(asciiOnlyString.Length, hashOut.Position);
Assert.True(hashOut.CanSeek);
hashOut.Seek(0, SeekOrigin.Begin);
Assert.True(hashOut.WasMoved);
}
using (var hashOut = new HashedStream(new MemoryStream()))
using (var tw = new StreamWriter(hashOut))
{
await tw.WriteAsync("Something or other");
hashOut.SetLength(0);
Assert.True(hashOut.WasMoved);
}
using (var hashOut = new HashedStream(new MemoryStream()))
using (var tw = new StreamWriter(hashOut))
{
await tw.WriteAsync("Something or other");
Assert.True(hashOut.CanSeek);
hashOut.Position = 0;
Assert.True(hashOut.WasMoved);
}
}
public async Task LongDiffConstAsync()
{
var fs = GetFileStream();
var ms = Stream.Null;
var hashIn = new HashedStream(fs, 42L, 53L, 23L, 34L);
var hashOut = new HashedStream(ms, 42L, 53L, 23L, 34L);
await WriteOutAsync(hashIn, hashOut);
Assert.False(hashIn.WasMoved);
Assert.False(hashIn.ReadHash128 == hashOut.WriteHash128);
Assert.False(hashIn.ReadHash32 == hashOut.WriteHash32);
Assert.False(hashIn.ReadHash64 == hashOut.WriteHash64);
}
public void LongConst()
{
var fs = GetFileStream();
var ms = Stream.Null;
var hashIn = new HashedStream(fs, 42L, 53L);
var hashOut = new HashedStream(ms, 42L, 53L);
WriteOut(hashIn, hashOut);
Assert.False(hashIn.WasMoved);
Assert.True(hashIn.ReadHash128 == hashOut.WriteHash128);
Assert.True(hashIn.ReadHash32 == hashOut.WriteHash32);
Assert.True(hashIn.ReadHash64 == hashOut.WriteHash64);
}
