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