HashInstance RebuildHash(
object[] objects, int index, Composite composite, Func <int, object> reader, int version)
{
var result = new HashInstance();
objects [index] = result;
var length = composite.Elements.Length;
if (version > 4)
{
length -= 2;
}
for (var i = 0; i < length; i += 2)
{
var key = RebuildShovelValue(reader(composite.Elements [i]));
var value = RebuildShovelValue(reader(composite.Elements [i + 1]));
result [key] = value;
}
if (version > 4)
{
// The indirect get/set are stored as the last elements of the hash.
result.IndirectGet = RebuildShovelValue(reader(composite.Elements[length]));
result.IndirectSet = RebuildShovelValue(reader(composite.Elements[length + 1]));
}
return(result);
}
public void TestHashingNullDataIncrementalThrowsCorrectException() =>
Assert.Throws <ArgumentNullException>(() =>
{
HashInstance.Initialize();
HashInstance.TransformBytes(NullBytes, 0, 0);
HashInstance.TransformFinal();
});
public void TestAnotherChunkedDataIncrementalHash()
{
var hashInstanceClone = HashInstance.Clone();
for (var idx = 0; idx < ChunkSizes.Length / sizeof(int); idx++)
{
var size = ChunkSizes[idx];
HashInstance.Initialize();
var jdx = size;
byte[] temp;
while (jdx < ChunkedDataBytes.Length)
{
temp = new byte[size];
Array.Copy(ChunkedDataBytes, jdx - size, temp, 0, temp.Length);
HashInstance.TransformBytes(temp);
jdx += size;
}
temp = new byte[ChunkedDataBytes.Length - (jdx - size)];
Array.Copy(ChunkedDataBytes, jdx - size, temp, 0, temp.Length);
HashInstance.TransformBytes(temp);
ExpectedString = hashInstanceClone.ComputeBytes(ChunkedDataBytes).ToString();
ActualString = HashInstance.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
}
public void TestSplits()
{
var input = ZeroToNineteenBytes;
for (var i = 0; i < input.Length; i++)
{
HashInstance.Initialize();
HashInstance.TransformBytes(input, 0, i);
ExpectedString = HashInstance.TransformFinal().ToString();
for (var j = 0; j <= i; j++)
{
for (var k = j; k <= i; k++)
{
HashInstance.Initialize();
HashInstance.TransformBytes(input, 0, j);
HashInstance.TransformBytes(input, j, k - j);
HashInstance.TransformBytes(input, k, i - k);
ActualString = HashInstance.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
}
}
}
public void TestHMACWorkingKeyIsCorrectLongKey()
{
var key = GenerateByteArrayInRange(0x0, HMACInstance.BlockSize + 1);
HMACInstance.Key = key;
AssertAreEqual(HashInstance.ComputeBytes(key).GetBytes(), HMACInstance.WorkingKey,
$"Working key mismatch in '{HMACInstance.Name}'");
}
public void TestStreamAndArrayHashMatchOne()
{
LargeMemoryStream.Position = 0;
ActualString = HashInstance.ComputeStream(LargeMemoryStream).ToString();
ExpectedString = HashInstance.ComputeBytes(LargeMemoryStream.ToArray()).ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public void TestCheckUnKeyedTestVectors()
{
for (var idx = 0; idx < UnKeyedTestVectors.Length; idx++)
{
ActualString = HashInstance.ComputeBytes(GenerateByteArrayInRange(0, idx)).ToString();
ExpectedString = UnKeyedTestVectors[idx];
AssertAreEqual(ExpectedString, ActualString);
}
}
public void TestCancellationTokenWorks()
{
LargeMemoryStream.Position = 0;
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
Assert.CatchAsync <OperationCanceledException>(() =>
HashInstance.ComputeStreamAsync(LargeMemoryStream, -1, cancellationTokenSource.Token));
}
public void TestHashOfDefaultDataStream()
{
using (var stream = new MemoryStream(DefaultDataBytes))
{
ExpectedString = HashOfDefaultData;
ActualString = HashInstance.ComputeStream(stream).ToString();
AssertAreEqual(ExpectedString, ActualString);
}
}
public unsafe void TestUntypedInterface()
{
fixed(byte *srcPtr = SmallLettersAToEBytes)
{
ExpectedString = HashInstance.ComputeBytes(SmallLettersAToEBytes).ToString();
ActualString = HashInstance.ComputeUntyped(srcPtr, SmallLettersAToEBytes.Length)
.ToString();
AssertAreEqual(ExpectedString, ActualString);
}
}
public void TestStreamAndArrayHashMatchTwo()
{
LargeMemoryStream.Position = 0;
ActualString = HashInstance.ComputeStream(LargeMemoryStream, LargeMemoryStream.Length / 2).ToString();
HashInstance.Initialize();
HashInstance.TransformBytes(LargeMemoryStream.ToArray(), 0, (int)(LargeMemoryStream.Length / 2));
ExpectedString = HashInstance.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public async Task TestHashOfDefaultDataStreamAsync()
{
using (var stream = new MemoryStream(DefaultDataBytes))
{
ExpectedString = HashOfDefaultData;
var hashResult = await HashInstance.ComputeStreamAsync(stream);
ActualString = hashResult.ToString();
AssertAreEqual(ExpectedString, ActualString);
}
}
public void TestInitializeWorks()
{
HashInstance.Initialize();
HashInstance.TransformBytes(DefaultDataBytes);
ExpectedString = HashInstance.TransformFinal().ToString();
HashInstance.Initialize();
HashInstance.TransformBytes(DefaultDataBytes);
ActualString = HashInstance.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public void TestHashCloneIsUnique()
{
HashInstance.Initialize();
HashInstance.BufferSize = 64 * 1024; // 64Kb
ExpectedString = HashInstance.BufferSize.ToString();
// Make Clone Of Current State
var hashInstanceClone = HashInstance.Clone();
hashInstanceClone.BufferSize = 128 * 1024; // 128Kb
ActualString = hashInstanceClone.BufferSize.ToString();
AssertAreNotEqual(ExpectedString, ActualString);
}
public void TestIncrementalHash()
{
ExpectedString = HashOfDefaultData;
HashInstance.Initialize();
foreach (var b in DefaultDataBytes)
{
HashInstance.TransformBytes(new[] { b });
}
ActualString = HashInstance.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public void TestHashCloneMatchesMainHash()
{
HashInstance.Initialize();
foreach (var b in DefaultDataBytes)
{
HashInstance.TransformBytes(new[] { b });
}
var hashInstanceClone = HashInstance.Clone();
ExpectedString = HashInstance.TransformFinal().ToString();
ActualString = hashInstanceClone.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public void TestIndexChunkedDataIncrementalHash()
{
var hashInstanceClone = HashInstance.Clone();
for (var idx = 0; idx < ChunkedDataBytes.Length; idx++)
{
var count = ChunkedDataBytes.Length - idx;
var temp = new byte[count];
Array.Copy(ChunkedDataBytes, idx, temp, 0, count);
HashInstance.Initialize();
HashInstance.TransformBytes(ChunkedDataBytes, idx, count);
ExpectedString = hashInstanceClone.ComputeBytes(temp).ToString();
ActualString = HashInstance.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
}
int SerializeHash(HashInstance dict, object obj)
{
var composite = new Composite {
Kind = ObjectTypes.Hash,
Elements = new int[dict.Count * 2 + 2]
};
var result = SerializeOneHashed(composite, obj);
var cursor = 0;
foreach (var kv in dict)
{
composite.Elements [cursor] = Serialize(kv.Key);
composite.Elements [cursor + 1] = Serialize(kv.Value);
cursor += 2;
}
composite.Elements[cursor] = Serialize(dict.IndirectGet);
cursor++;
composite.Elements[cursor] = Serialize(dict.IndirectSet);
cursor++;
return(result);
}
public void TestMultiThreadingAndCloneWorks()
{
const int iterations = 20;
var h1 = HashInstance.Clone();
var h2 = HashInstance.Clone();
var h3 = HashInstance.Clone();
var h4 = HashInstance.Clone();
var a = Clone(DefaultDataBytes);
var b = Clone(DefaultDataBytes);
var c = Clone(DefaultDataBytes);
var d = Clone(DefaultDataBytes);
var t1 = Task.Factory.StartNew(() => HashComputation(ref a, h1, iterations));
var t2 = Task.Factory.StartNew(() => HashComputation(ref b, h2, iterations));
var t3 = Task.Factory.StartNew(() => HashComputation(ref c, h3, iterations));
var t4 = Task.Factory.StartNew(() => HashComputation(ref d, h4, iterations));
Task.WaitAll(t1, t2, t3, t4);
Assert.IsTrue(AreEqual(a, b) == AreEqual(c, d),
$"MultiThreading and Clone test failed for '{HashInstance.Name}'");
}
public void TestHashCloneIsCorrect()
{
var count = DefaultDataBytes.Length - 3;
var chunk1 = new byte[count];
Array.Copy(DefaultDataBytes, 0, chunk1, 0, chunk1.Length);
var chunk2 = new byte[DefaultDataBytes.Length - count];
Array.Copy(DefaultDataBytes, count, chunk1, 0, chunk2.Length);
HashInstance.Initialize();
HashInstance.TransformBytes(chunk1);
// Make Clone Of Current State
var hashInstanceClone = HashInstance.Clone();
HashInstance.TransformBytes(chunk2);
ExpectedString = HashInstance.TransformFinal().ToString();
hashInstanceClone.TransformBytes(chunk2);
ActualString = hashInstanceClone.TransformFinal().ToString();
AssertAreEqual(ExpectedString, ActualString);
}
static void HandleContext(Vm vm)
{
var stackTraceSb = new StringBuilder ();
vm.WriteStackTrace (stackTraceSb);
var stackTrace = stackTraceSb.ToString ();
var currentEnvironmentSb = new StringBuilder ();
vm.WriteCurrentEnvironment (currentEnvironmentSb);
var currentEnvironment = currentEnvironmentSb.ToString ();
var result = new HashInstance ();
result.Add (Value.Make ("stack"), Value.Make (stackTrace));
result.Add (Value.Make ("environment"), Value.Make (currentEnvironment));
vm.IncrementCells (6 + stackTrace.Length + currentEnvironment.Length);
vm.stack.Push (Value.Make (result));
vm.programCounter ++;
return;
}
static Value StructToHash(VmApi api, Value[] args, int start, int length)
{
if (args [start].Kind != Value.Kinds.StructInstance) {
api.RaiseShovelError ("First argument must be a struct instance.");
}
var result = new HashInstance ();
var structInstance = args [start].structInstanceValue;
var ztruct = structInstance.Struct;
var sizeIncrease = 1 + 2 * ztruct.Fields.Length;
api.CellsIncrementHerald (sizeIncrease);
for (int i = 0; i < ztruct.Fields.Length; i++) {
result [Value.Make (ztruct.Fields [i])] = structInstance.Values [i];
}
api.CellsIncrementer (sizeIncrease);
return Value.Make (result);
}
static Value DecodeTime(VmApi api, Value timeInSeconds)
{
if (timeInSeconds.Kind != Value.Kinds.Integer) {
api.RaiseShovelError ("Argument must be an integer.");
}
var epochTimeSpan = TimeSpan.FromSeconds (timeInSeconds.integerValue);
var date = Prim0.unixEpoch + epochTimeSpan;
var result = new HashInstance ();
result [Value.Make ("year")] = Value.MakeInt (date.Year);
result [Value.Make ("month")] = Value.MakeInt (date.Month);
result [Value.Make ("day")] = Value.MakeInt (date.Day);
var dayOfWeekKey = Value.Make ("dayOfWeek");
switch (date.DayOfWeek) {
case DayOfWeek.Monday:
result [dayOfWeekKey] = Value.MakeInt (1);
break;
case DayOfWeek.Tuesday:
result [dayOfWeekKey] = Value.MakeInt (2);
break;
case DayOfWeek.Wednesday:
result [dayOfWeekKey] = Value.MakeInt (3);
break;
case DayOfWeek.Thursday:
result [dayOfWeekKey] = Value.MakeInt (4);
break;
case DayOfWeek.Friday:
result [dayOfWeekKey] = Value.MakeInt (5);
break;
case DayOfWeek.Saturday:
result [dayOfWeekKey] = Value.MakeInt (6);
break;
case DayOfWeek.Sunday:
result [dayOfWeekKey] = Value.MakeInt (7);
break;
}
result [Value.Make ("hour")] = Value.MakeInt (date.Hour);
result [Value.Make ("minute")] = Value.MakeInt (date.Minute);
result [Value.Make ("second")] = Value.MakeInt (date.Second);
api.CellsIncrementer (8);
return Value.Make (result);
}
public void TestHashingNullDataThrowsCorrectException() => Assert.Throws <ArgumentNullException>(() => HashInstance.ComputeBytes(NullBytes));
static Value HashConstructor(VmApi api, Value[] args, int start, int length)
{
if (length % 2 != 0) {
api.RaiseShovelError ("Must provide an even number of arguments.");
}
var sizeIncrease = 1 + 2 * length;
api.CellsIncrementHerald (sizeIncrease);
var result = new HashInstance ();
for (var i = start; i < start + length; i += 2) {
if (args [i].Kind == Value.Kinds.String) {
result [args [i]] = args [i + 1];
} else {
api.RaiseShovelError ("Keys must be strings");
}
}
api.CellsIncrementer (sizeIncrease);
return Value.Make (result);
}
int SerializeHash(HashInstance dict, object obj)
{
var composite = new Composite {
Kind = ObjectTypes.Hash,
Elements = new int[dict.Count * 2 + 2]
};
var result = SerializeOneHashed (composite, obj);
var cursor = 0;
foreach (var kv in dict) {
composite.Elements [cursor] = Serialize (kv.Key);
composite.Elements [cursor + 1] = Serialize (kv.Value);
cursor += 2;
}
composite.Elements[cursor] = Serialize(dict.IndirectGet);
cursor++;
composite.Elements[cursor] = Serialize(dict.IndirectSet);
cursor++;
return result;
}
public void TestHashingEmptyReadOnlySpanVsEmptyArray() => AssertAreEqual(
HashInstance.ComputeByteSpan(ReadOnlySpan <byte> .Empty).ToString(),
HashInstance.ComputeBytes(EmptyBytes).ToString());
HashInstance RebuildHash(
object[] objects, int index, Composite composite, Func<int, object> reader, int version)
{
var result = new HashInstance ();
objects [index] = result;
var length = composite.Elements.Length;
if (version > 4)
{
length -= 2;
}
for (var i = 0; i < length; i+=2) {
var key = RebuildShovelValue (reader (composite.Elements [i]));
var value = RebuildShovelValue (reader (composite.Elements [i + 1]));
result [key] = value;
}
if (version > 4)
{
// The indirect get/set are stored as the last elements of the hash.
result.IndirectGet = RebuildShovelValue(reader(composite.Elements[length]));
result.IndirectSet = RebuildShovelValue(reader(composite.Elements[length + 1]));
}
return result;
}
public void TestHashingReadOnlySpanVsArray() =>
AssertAreEqual(HashInstance.ComputeByteSpan(new ReadOnlySpan <byte>(DefaultDataBytes)).ToString(),
HashInstance.ComputeBytes(DefaultDataBytes).ToString());
public void TestHashOfDefaultData()
{
ExpectedString = HashOfDefaultData;
ActualString = HashInstance.ComputeBytes(DefaultDataBytes).ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public void TestHashOfSmallLettersAToE()
{
ExpectedString = HashOfSmallLettersAToE;
ActualString = HashInstance.ComputeBytes(SmallLettersAToEBytes).ToString();
AssertAreEqual(ExpectedString, ActualString);
}
public void TestHashOfOneToNine()
{
ExpectedString = HashOfOneToNine;
ActualString = HashInstance.ComputeBytes(OneToNineBytes).ToString();
AssertAreEqual(ExpectedString, ActualString);
}
