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