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