public void TestRandomEvidenceHashes() { var rng = new PseudoRandom(0x262E5635); var data = new byte[512]; using (var sha1 = new SHA1CryptoServiceProvider()) using (var ms = new MemoryStream()) { var bf = new BinaryFormatter(); for (var n = 0; n < 10000; ++n) { rng.NextBytes(data); var evidenceInfo = Convert.ToBase64String(data); ms.SetLength(0); bf.Serialize(ms, evidenceInfo); var expectedHash = ToBase32(sha1.ComputeHash(ms.ToArray())); var actualHash = UserUpgradeStrategy.ComputeEvidenceHash(evidenceInfo); Assert.AreEqual(expectedHash, actualHash, "n = {0}", n); } } }
public void TestVolumeS16() { const short expectedMinimum = -100; const short expectedMaximum = 200; var rng = new PseudoRandom(0x48E4B0B4); var data = new short[1000]; for (var n = 1; n < data.Length - 1; ++n) data[n] = (short) rng.Next(expectedMinimum + 1, expectedMaximum - 1); data[0] = expectedMaximum; data[999] = expectedMinimum; var volume = new S16Volume(data, new Size3D(5, 10, 20), new Vector3D(2, 1, 0.5f), new Vector3D(5, 0, -5), new Matrix3D(new float[,] {{0, 1, 0}, {0, 0, 1}, {1, 0, 0}}), new DicomAttributeCollection(), 123); Assert.AreSame(data, volume.Array, "Array"); Assert.AreSame(data, volume.ArrayData, "ArrayData"); Assert.AreEqual(new Size3D(5, 10, 20), volume.ArrayDimensions, "ArrayDimensions"); Assert.AreEqual(1000, volume.ArrayLength, "ArrayLength"); Assert.AreEqual(16, volume.BitsPerVoxel, "BitsPerVoxel"); Assert.AreEqual(true, volume.Signed, "Signed"); Assert.AreEqual(123, volume.PaddingValue, "PaddingValue"); Assert.AreEqual(new Vector3D(10, 10, 10), volume.VolumeSize, "VolumeSize"); Assert.AreEqual(new Rectangle3D(0, 0, 0, 10, 10, 10), volume.VolumeBounds, "VolumeBounds"); Assert.AreEqual(new Vector3D(5, 5, 5), volume.VolumeCenter, "VolumeCenter"); Assert.AreEqual(new Vector3D(10, 5, 0), volume.VolumeCenterPatient, "VolumeCenterPatient"); Assert.AreEqual(new Vector3D(0, 1, 0), volume.VolumeOrientationPatientX, "VolumeOrientationPatientX"); Assert.AreEqual(new Vector3D(0, 0, 1), volume.VolumeOrientationPatientY, "VolumeOrientationPatientY"); Assert.AreEqual(new Vector3D(1, 0, 0), volume.VolumeOrientationPatientZ, "VolumeOrientationPatientZ"); Assert.AreEqual(new Vector3D(5, 0, -5), volume.VolumePositionPatient, "VolumePositionPatient"); Assert.AreEqual(expectedMinimum, volume.MinimumVolumeValue, "MinimumVolumeValue"); Assert.AreEqual(expectedMaximum, volume.MaximumVolumeValue, "MaximumVolumeValue"); }
public void TestRandomAccess() { const int operationCount = 2500; var rng = new PseudoRandom(-0x522C5EF5); var seedData = new byte[1 << 17]; using (var s = CreateStream(seedData)) using (var r = new MemoryStream()) { if (!(s.CanRead && s.CanWrite && s.CanSeek)) { Console.WriteLine("Test skipped because {0} doesn't support Read, Write and Seek", s.GetType().FullName); return; } r.Write(seedData, 0, seedData.Length); r.Position = 0; Console.WriteLine("Preparing to execute {0} randomized operations", operationCount); for (var k = 0; k < operationCount; ++k) { var opcode = rng.Next(0, 12); // slightly biased towards write operations, in order to ensure "interesting" data switch (opcode) { case 0: // Read case 6: { var size = rng.Next(1024, 32768); var offset = rng.Next(0, 1024); var count = rng.Next(0, size - offset); var sBuffer = new byte[size]; var rBuffer = new byte[size]; rng.NextBytes(sBuffer); Buffer.BlockCopy(sBuffer, 0, rBuffer, 0, size); var sResult = Read(s, sBuffer, offset, count); var rResult = r.Read(rBuffer, offset, count); Assert.AreEqual(rResult, sResult, "Function return from Read at step k={0}", k); Assert.AreEqual(r.Position, s.Position, "Position after Read at step k={0}", k); Assert.AreEqual(r.Length, s.Length, "Length after Read at step k={0}", k); AssertAreEqual(rBuffer, sBuffer, "Buffer after Read at step k={0}", k); } break; case 1: // ReadByte { var sResult = ReadByte(s); var rResult = r.ReadByte(); Assert.AreEqual(rResult, sResult, "Function return from ReadByte at step k={0}", k); Assert.AreEqual(r.Position, s.Position, "Position after ReadByte at step k={0}", k); Assert.AreEqual(r.Length, s.Length, "Length after ReadByte at step k={0}", k); } break; case 2: // Write case 7: case 8: case 9: { var oldLength = s.Length; var size = rng.Next(1024, 32768); var offset = rng.Next(0, 1024); var count = rng.Next(0, size - offset); var sBuffer = new byte[size]; var rBuffer = new byte[size]; rng.NextBytes(sBuffer); Buffer.BlockCopy(sBuffer, 0, rBuffer, 0, size); Write(s, sBuffer, offset, count); r.Write(rBuffer, offset, count); Assert.AreEqual(r.Position, s.Position, "Position after Write at step k={0}", k); Assert.AreEqual(r.Length, s.Length, "Length after Write at step k={0}", k); AssertAreEqual(rBuffer, sBuffer, "Buffer after Write at step k={0}", k); // because the behaviour of uninitialized bytes caused by buffer expansion is not explicitly defined, // we explicitly initialize those bytes in order to continue the test deterministically if (s.Length > oldLength) { var pos = s.Position; var zero = new byte[s.Length - oldLength]; Seek(s, oldLength, SeekOrigin.Begin); r.Seek(oldLength, SeekOrigin.Begin); Write(s, zero, 0, zero.Length); r.Write(zero, 0, zero.Length); Seek(s, pos, SeekOrigin.Begin); r.Seek(pos, SeekOrigin.Begin); } } break; case 3: // WriteByte case 11: { var oldLength = s.Length; var value = (byte)rng.Next(0, 256); WriteByte(s, value); r.WriteByte(value); Assert.AreEqual(r.Position, s.Position, "Position after WriteByte at step k={0}", k); Assert.AreEqual(r.Length, s.Length, "Length after WriteByte at step k={0}", k); // because the behaviour of uninitialized bytes caused by buffer expansion is not explicitly defined, // we explicitly initialize those bytes in order to continue the test deterministically if (s.Length > oldLength) { var pos = s.Position; var zero = new byte[s.Length - oldLength]; Seek(s, oldLength, SeekOrigin.Begin); r.Seek(oldLength, SeekOrigin.Begin); Write(s, zero, 0, zero.Length); r.Write(zero, 0, zero.Length); Seek(s, pos, SeekOrigin.Begin); r.Seek(pos, SeekOrigin.Begin); } } break; case 4: // Seek case 10: { int offset; SeekOrigin origin; switch (rng.Next(0, 3)) { case 0: offset = rng.Next(0, (int)s.Length + 1024); origin = SeekOrigin.Begin; break; case 1: offset = rng.Next(-(int)s.Position, (int)s.Length - (int)s.Position + 1024); origin = SeekOrigin.Current; break; case 2: default: offset = rng.Next(-(int)s.Length, 1024); origin = SeekOrigin.End; break; } Seek(s, offset, origin); r.Seek(offset, origin); Assert.AreEqual(r.Position, s.Position, "Position after Seek at step k={0}", k); Assert.AreEqual(r.Length, s.Length, "Length after Seek at step k={0}", k); } break; case 5: // SetLength { var oldLength = s.Length; var length = (int)s.Length + rng.Next(-4096, 4096); // because the behaviour of Position after a SetLength call is not explicitly defined, // we explicitly set it here in order to continue the test deterministically var newPosition = rng.Next(0, (int)s.Length + 1024); SetLength(s, length); r.SetLength(length); Assert.AreEqual(r.Length, s.Length, "Length after SetLength at step k={0}", k); // because the behaviour of uninitialized bytes caused by buffer expansion is not explicitly defined, // we explicitly initialize those bytes in order to continue the test deterministically if (s.Length > oldLength) { var zero = new byte[s.Length - oldLength]; Seek(s, oldLength, SeekOrigin.Begin); r.Seek(oldLength, SeekOrigin.Begin); Write(s, zero, 0, zero.Length); r.Write(zero, 0, zero.Length); } Seek(s, newPosition, SeekOrigin.Begin); r.Seek(newPosition, SeekOrigin.Begin); } break; default: throw new InvalidOperationException("Invalid OP code generated"); } } Console.WriteLine("Completed executing {0} randomized operations", operationCount); var rArray = r.ToArray(); var sArray = new byte[s.Length]; Seek(s, 0, SeekOrigin.Begin); Assert.AreEqual(sArray.Length, Read(s, sArray, 0, sArray.Length), "Bytes Read while dumping stream contents"); //AssertAreEqual(rArray, sArray, "Dump of Stream Contents"); using (var hashProvider = new SHA256CryptoServiceProvider2()) { var rHash = hashProvider.ComputeHash(rArray); var sHash = hashProvider.ComputeHash(sArray); Assert.AreEqual(rHash, sHash, "Hash of Stream Contents"); var hashString = StringUtilities.ToHexString(sHash); Console.WriteLine("Final stream has a hash value of {0}", hashString); } } }