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