public void TestCompareValues()
{
const int testSize = 100;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
var data1 = new DicomAttributeBinaryData <T>(array0, true);
AssertCompareValues(true, data0, data1, "initial");
data1.SetValue(0, default(T));
AssertCompareValues(false, data0, data1, "after setting 0 on one");
data0.SetValue(0, default(T));
AssertCompareValues(true, data0, data1, "after setting 0 on both");
data1.SetValue(testSize / 2, default(T));
AssertCompareValues(false, data0, data1, "after setting {0} on one", testSize / 2);
data0.SetValue(testSize / 2, default(T));
AssertCompareValues(true, data0, data1, "after setting {0} on both", testSize / 2);
data1.SetValue(testSize, default(T));
AssertCompareValues(false, data0, data1, "after setting {0} on one", testSize);
data0.SetValue(testSize, default(T));
AssertCompareValues(true, data0, data1, "after setting {0} on both", testSize);
data1.AppendValue(default(T));
AssertCompareValues(false, data0, data1, "after appending on one");
data0.AppendValue(default(T));
AssertCompareValues(true, data0, data1, "after appending on both");
}
public void TestAppendValue2()
{
const int testSize = 10000;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
data0.TestUseStream();
var array1 = GenerateValues(250);
for (var n = 0; n < 250; ++n)
{
data0.AppendValue(array1[n]);
}
for (var n = 0; n < 250; ++n)
{
data0[10250 + n] = array1[n];
}
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(array0[n], data0[n], "@[{0}]", n);
}
for (var n = testSize; n < testSize + 250; ++n)
{
Assert.AreEqual(array1[n - testSize], data0[n], "@[{0}]", n);
}
for (var n = testSize + 250; n < testSize + 500; ++n)
{
Assert.AreEqual(array1[n - testSize - 250], data0[n], "@[{0}]", n);
}
}
public void TestTryGetValue2()
{
const int testSize = 10000;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
data0.TestUseStream();
T value;
for (var n = -25; n < 0; ++n)
{
Assert.AreEqual(false, data0.TryGetValue(n, out value), "TryGet[{0}]", n);
}
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(true, data0.TryGetValue(n, out value), "TryGet[{0}]", n);
Assert.AreEqual(array0[n], value, "TryGet[{0}]", n);
}
for (var n = testSize; n < testSize + 25; ++n)
{
Assert.AreEqual(false, data0.TryGetValue(n, out value), "TryGet[{0}]", n);
}
}
public void TestGetSetValue2()
{
const int testSize = 10000;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
data0.TestUseStream();
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(array0[n], data0.GetValue(n), "get array[{0}]", n);
}
for (var n = 0; n < testSize; ++n)
{
data0.SetValue(n, array0[n] = array0[(n + 500) % testSize]);
}
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(array0[n], data0.GetValue(n), "set array[{0}]", n);
}
Assert.Throws <IndexOutOfRangeException>(() => data0.GetValue(-1), "Getting a value @-1");
Assert.Throws <IndexOutOfRangeException>(() => data0.GetValue(testSize), "Getting a value @10000");
Assert.Throws <IndexOutOfRangeException>(() => data0.GetValue(testSize + 1), "Getting a value @10001");
Assert.Throws <IndexOutOfRangeException>(() => data0.SetValue(-1, default(T)), "Setting a value @-1");
Assert.Throws <IndexOutOfRangeException>(() => data0.SetValue(testSize + 1, default(T)), "Setting a value @10001");
Assert.DoesNotThrow(() => data0.SetValue(testSize, default(T)), "Setting a value @10000");
}
public void TestIndexer2()
{
const int testSize = 10000;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
data0.TestUseStream();
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(array0[n], data0[n], "get array[{0}]", n);
}
for (var n = 0; n < testSize; ++n)
{
data0[n] = array0[n] = array0[(n + 25) % testSize];
}
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(array0[n], data0[n], "set array[{0}]", n);
}
var dummy = default(T);
Assert.Throws <IndexOutOfRangeException>(() => dummy = data0[-1], "Getting a value @-1");
Assert.Throws <IndexOutOfRangeException>(() => dummy = data0[testSize], "Getting a value @10000");
Assert.Throws <IndexOutOfRangeException>(() => dummy = data0[testSize + 1], "Getting a value @10001");
Assert.Throws <IndexOutOfRangeException>(() => data0[-1] = default(T), "Setting a value @-1");
Assert.Throws <IndexOutOfRangeException>(() => data0[testSize + 1] = default(T), "Setting a value @10001");
Assert.DoesNotThrow(() => data0[testSize] = default(T), "Setting a value @10000");
Assert.AreEqual(default(T), dummy);
}
public void TestConstructorCopy()
{
var array0 = GenerateValues(100);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
var data1 = new DicomAttributeBinaryData <T>(data0);
Assert.AreEqual(array0, data1.TestGetArray(), "arrays");
}
public void TestToArray()
{
const int testSize = 100;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
var array = data0.ToArray();
Assert.AreEqual(array0, array);
}
public void TestAppendValueConvertToStream()
{
var testSize = DicomAttributeBinaryData <T> .TestStreamThresholdInValues;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
Assert.IsNotNull(data0.TestGetArray(), "array before switch");
Assert.IsNull(data0.TestGetStream(), "stream before switch");
data0.AppendValue(default(T));
Assert.IsNull(data0.TestGetArray(), "array after switch");
Assert.IsNotNull(data0.TestGetStream(), "stream after switch");
}
public void TestConstructor()
{
Assert.AreEqual(0, new DicomAttributeBinaryData <T>().Count, ".ctor(0)");
Assert.AreEqual(10, new DicomAttributeBinaryData <T>(10).Count, ".ctor(10)");
var d = new DicomAttributeBinaryData <T>(DicomAttributeBinaryData <T> .TestStreamThresholdInValues);
Assert.IsNotNull(d.TestGetArray(), "array in .ctor(threshold)");
Assert.IsNull(d.TestGetStream(), "stream in .ctor(threshold)");
d = new DicomAttributeBinaryData <T>(DicomAttributeBinaryData <T> .TestStreamThresholdInValues + 1);
Assert.IsNull(d.TestGetArray(), "array in .ctor(threshold+1)");
Assert.IsNotNull(d.TestGetStream(), "stream in .ctor(threshold+1)");
}
private static void AssertCompareValues(bool expectedResult, DicomAttributeBinaryData <T> a, DicomAttributeBinaryData <T> b, string message, params object[] args)
{
var msg = string.Format(message, args);
if (expectedResult)
{
Assert.IsTrue(a.CompareValues(b), msg);
Assert.IsTrue(b.CompareValues(a), msg + " (Reversed)");
}
else
{
Assert.IsFalse(a.CompareValues(b), msg, args);
Assert.IsFalse(b.CompareValues(a), msg + " (Reversed)");
}
}
public void TestCreateByteBuffer()
{
const int testSize = 100;
var array0 = GenerateValues(testSize);
var buffer0 = new byte[testSize * SizeOfT];
Buffer.BlockCopy(array0, 0, buffer0, 0, buffer0.Length);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
var bb = data0.CreateByteBuffer(ByteBuffer.LocalMachineEndian);
var buffer1 = bb.GetChunk(0, bb.Length);
Assert.AreEqual(buffer0, buffer1);
}
public void TestGetEnumerator()
{
const int testSize = 100;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
var enumerator = data0.GetEnumerator();
for (var n = 0; n < testSize; ++n)
{
Assert.AreEqual(true, enumerator.MoveNext(), "MoveNext @{0}", n);
Assert.AreEqual(array0[n], enumerator.Current, "Current @{0}", n);
}
Assert.AreEqual(false, enumerator.MoveNext(), "MoveNext @END");
}
public void TestConstructorCopy2()
{
var array0 = GenerateValues(10000);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
data0.TestUseStream();
var data1 = new DicomAttributeBinaryData <T>(data0);
var buffer1 = data1.TestGetStream().ToArray();
var array1 = new T[10000];
Buffer.BlockCopy(buffer1, 0, array1, 0, buffer1.Length);
Assert.AreEqual(array0, array1, "arrays");
}
public void TestConstructorArray()
{
var array0 = GenerateValues(100);
var data0 = new DicomAttributeBinaryData <T>(array0, false);
Assert.AreSame(array0, data0.TestGetArray(), "no copy");
data0 = new DicomAttributeBinaryData <T>(array0, true);
Assert.AreNotSame(array0, data0.TestGetArray(), "copy (reference)");
Assert.AreEqual(array0, data0.TestGetArray(), "copy (contents)");
array0 = GenerateValues(DicomAttributeBinaryData <T> .TestStreamThresholdInValues + 1);
data0 = new DicomAttributeBinaryData <T>(array0, true);
Assert.IsNull(data0.TestGetArray(), "copy to stream (array)");
Assert.AreEqual(array0, ConvertToTArray(data0.TestGetStream().ToArray()), "copy to stream (contents)");
}
public void TestAsStream2()
{
const int testSize = 10000;
var array0 = GenerateValues(testSize);
var data0 = new DicomAttributeBinaryData <T>(array0, true);
data0.TestUseStream();
var bufferT = new byte[SizeOfT];
// just assert that different stream instances act as independent views
// the semantics of the stream implementation is more rigourously asserted by DicomAttributeBinaryDataViewStreamTests
using (var stream0 = data0.AsStream())
{
using (var stream1 = data0.AsStream())
using (var stream2 = data0.AsStream())
{
for (var n = 0; n < testSize; ++n)
{
// sequential reading, no seek
stream0.Read(bufferT, 0, SizeOfT);
Assert.AreEqual(array0[n], ConvertToT(bufferT), "stream0, @{0}", n);
// sequential reading, with seek
var index1 = (n + 43) % testSize;
stream1.Position = index1 * SizeOfT;
stream1.Read(bufferT, 0, SizeOfT);
Assert.AreEqual(array0[index1], ConvertToT(bufferT), "stream1, @{1} (n = {0})", n, index1);
// random access reading
var index2 = n % 2 == 0 ? (n + 7) % testSize : (n + 7 + testSize / 2) % testSize;
stream2.Position = index2 * SizeOfT;
stream2.Read(bufferT, 0, SizeOfT);
Assert.AreEqual(array0[index2], ConvertToT(bufferT), "stream2, @{1} (n = {0})", n, index2);
}
}
stream0.Position = 0;
for (var n = 0; n < testSize; ++n)
{
// sequential reading, no seek
stream0.Read(bufferT, 0, SizeOfT);
Assert.AreEqual(array0[n], ConvertToT(bufferT), "stream0 after other streams disposed, @{0}", n);
}
}
}
protected override Stream CreateStream(byte[] seedData)
{
// the view stream implementation does not depend on the type parameter
return(DicomAttributeBinaryData <int> .TestCreateViewStream(seedData));
}
