public void TestReadFromSinglePage_FullCopy()
        {
            var obj = new Dummy {
                Number1 = 123, Number2 = 456
            };
            var dummySize = Marshal.SizeOf(typeof(Dummy));

            Dummy *objPtr = &obj;
            var    data   = new byte *[1];

            data[0] = (byte *)objPtr;

            using (var stream = new UnmanagedVectorMemoryStream(data, 0, dummySize))
            {
                var readData = new byte[dummySize];
                stream.Read(readData, 0, dummySize);

                fixed(byte *readDataPtr = readData)
                Assert.Equal(0, NativeMethods.memcmp(data[0], readDataPtr, dummySize));
            }
        }
        public void TestReadFromMultiplePages()
        {
            var obj1 = new Dummy {
                Number1 = 123, Number2 = 456
            };
            var obj2 = new Dummy {
                Number1 = 789, Number2 = 123
            };
            var obj3 = new Dummy {
                Number1 = 901, Number2 = 234
            };
            var    dummySize = Marshal.SizeOf(typeof(Dummy));
            Dummy *ptrObj1   = &obj1;
            Dummy *ptrObj2   = &obj2;
            Dummy *ptrObj3   = &obj3;
            {
                var data = new byte *[3];
                data[0] = (byte *)ptrObj1;
                data[1] = (byte *)ptrObj2;
                data[2] = (byte *)ptrObj3;


                var dataBufferPtr = IntPtr.Zero;
                try
                {
                    dataBufferPtr = Marshal.AllocHGlobal(dummySize * 3 + 1);
                    var dataBuffer = (byte *)dataBufferPtr.ToPointer();
                    NativeMethods.memcpy(dataBuffer, data[0], dummySize);
                    NativeMethods.memcpy(dataBuffer + dummySize, data[1], dummySize);
                    NativeMethods.memcpy(dataBuffer + (dummySize * 2), data[2], dummySize);

                    using (var stream = new UnmanagedVectorMemoryStream(data, 0, dummySize))
                    {
                        var readData = new byte[dummySize * 3];
                        stream.Read(readData, 0, dummySize * 3);
                        fixed(byte *readDataPtr = readData)
                        {
//						Assert.Equal(0, NativeMethods.memcmp(dataBuffer, readDataPtr, dummySize * 3));
                            var fetchedObj1Ptr = (Dummy *)readDataPtr;

                            Assert.Equal(obj1.Number1, fetchedObj1Ptr->Number1);
                            Assert.Equal(obj1.Number2, fetchedObj1Ptr->Number2);

                            var fetchedObj2Ptr = (Dummy *)(readDataPtr + dummySize);

                            Assert.Equal(obj2.Number1, fetchedObj2Ptr->Number1);
                            Assert.Equal(obj2.Number2, fetchedObj2Ptr->Number2);

                            var fetchedObj3Ptr = (Dummy *)(readDataPtr + (dummySize * 2));

                            Assert.Equal(obj3.Number1, fetchedObj3Ptr->Number1);
                            Assert.Equal(obj3.Number2, fetchedObj3Ptr->Number2);
                        }
                    }
                }
                finally
                {
                    Marshal.FreeHGlobal(dataBufferPtr);
                }
            }
        }