public void WriteHashInReservedSpace2Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicWriteHashInReservedSpace(TestUtilities.CreateNonWritableStream(), null);
}
}
public void CreateEncryptingStream2Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicCreateEncryptingStream(TestUtilities.CreateNonWritableStream());
}
}
public void ReserveSpaceForHash2Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicReserveSpaceForHash(TestUtilities.CreateNonWritableStream());
}
}
public void LoadHashToValidate2Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
using (var stream = TestUtilities.CreateNonReadableStream())
target.PublicLoadHashToValidate(stream);
}
}
public void BeforeReadDecrypted2Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
using (var stream = TestUtilities.CreateNonReadableStream())
target.PublicBeforeReadDecrypted(stream);
}
}
public void InitializeHasher3Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicInitializeHasher(" \t");
Assert.AreEqual(Algorithms.Hash.Default, target.PublicHashAlgorithmName);
}
}
public void FinalizeHashAfterWrite4Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicFinalizeHashAfterWrite(
new MemoryStream(new byte[10], true),
new CryptoStream(TestUtilities.CreateNonWritableStream(), target.PublicHasher, CryptoStreamMode.Read));
}
}
public void FinalizeHashAfterWrite2Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicFinalizeHashAfterWrite(
TestUtilities.CreateNonWritableStream(),
new CryptoStream(new NullStream(), target.PublicHasher, CryptoStreamMode.Write));
}
}
public void FinalizeHashAfterRead4Test()
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
using (var stream = TestUtilities.CreateNonReadableStream())
target.PublicFinalizeHashAfterRead(
new MemoryStream(new byte[10], true),
new CryptoStream(stream, target.PublicHasher, CryptoStreamMode.Write));
}
}
public void LoadHashToValidateAsync1Test()
{
TestUtilities.AsyncTestWrapper(TestContext, () =>
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicLoadHashToValidateAsync(null).Wait();
}
});
}
public void BeforeReadDecryptedAsync1Test()
{
TestUtilities.AsyncTestWrapper(TestContext, () =>
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicBeforeReadDecryptedAsync(null).Wait();
}
});
}
public void LoadHashToValidateAsync2Test()
{
TestUtilities.AsyncTestWrapper(TestContext, () =>
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
using (var stream = TestUtilities.CreateNonReadableStream())
target.PublicLoadHashToValidateAsync(stream).Wait();
}
});
}
public void BeforeWriteEncryptedAsync2Test()
{
try
{
using (var target = new InheritedEncryptedNewKeyHashedCipher())
{
target.PublicBeforeWriteEncryptedAsync(TestUtilities.CreateNonWritableStream()).Wait();
}
}
catch (AggregateException x)
{
throw x.InnerExceptions.First();
}
}
