コード例 #1
0
        public static void ReadWriteByteSafeBuffer()
        {
            var length = 1000;

            using (var buffer = new TestSafeBuffer(length))
            {
                var stream = new UnmanagedMemoryStream(buffer, 0, (long)buffer.ByteLength, FileAccess.ReadWrite);
                Assert.Equal(stream.Length, length);

                var bytes = ArrayHelpers.CreateByteArray(length);
                for (int index = 0; index < length; index++)
                {
                    stream.WriteByte(bytes[index]);
                }

                stream.Position = 0;
                for (int index = 0; index < length; index++)
                {
                    int value = stream.ReadByte();
                    Assert.Equal(bytes[index], (byte)value);
                }

                var memory = buffer.ToArray();
                Assert.True(ArrayHelpers.Comparer <byte>().Equals(bytes, memory));
            }
        }
コード例 #2
0
        public static void UmaReadWriteStructArray_Multiples()
        {
            const int numberOfStructs = 12;
            const int capacity        = numberOfStructs * UmaTestStruct_AlignedSize;

            UmaTestStruct[] inStructArr  = new UmaTestStruct[numberOfStructs];
            UmaTestStruct[] outStructArr = new UmaTestStruct[numberOfStructs];
            for (int i = 0; i < numberOfStructs; i++)
            {
                inStructArr[i] = new UmaTestStruct()
                {
                    bool1 = false, bool2 = true, int1 = i, int2 = i + 1, char1 = (char)i
                };
            }
            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    uma.WriteArray <UmaTestStruct>(0, inStructArr, 0, numberOfStructs);
                    Assert.Equal(numberOfStructs, uma.ReadArray <UmaTestStruct>(0, outStructArr, 0, numberOfStructs));
                    for (int i = 0; i < numberOfStructs; i++)
                    {
                        Assert.Equal(i, outStructArr[i].int1);
                        Assert.Equal(i + 1, outStructArr[i].int2);
                        Assert.Equal(false, outStructArr[i].bool1);
                        Assert.Equal((char)i, outStructArr[i].char1);
                        Assert.Equal(true, outStructArr[i].bool2);
                    }
                }
        }
コード例 #3
0
 public static void UmaWriteStruct_ReadMode()
 {
     const int capacity = 100;
     UmaTestStruct inStruct = new UmaTestStruct();
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.Read))
     {
         Assert.Throws<NotSupportedException>(() => uma.Write<UmaTestStruct>(0, ref inStruct));
     }
 }
コード例 #4
0
 public static void UmaReadStructArray_WriteMode()
 {
     const int capacity = 100;
     UmaTestStruct[] structArr = new UmaTestStruct[1];
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.Write))
     {
         Assert.Throws<NotSupportedException>(() => uma.ReadArray<UmaTestStruct>(0, structArr, 0, 1));
     }
 }
コード例 #5
0
        public static void UmaWriteStruct_ReadMode()
        {
            const int     capacity = 100;
            UmaTestStruct inStruct = new UmaTestStruct();

            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.Read))
                {
                    Assert.Throws <NotSupportedException>(() => uma.Write <UmaTestStruct>(0, ref inStruct));
                }
        }
コード例 #6
0
 public static void UmaReadWriteStruct_PositionGreaterThanCapacity()
 {
     const int capacity = 100;
     UmaTestStruct inStruct = new UmaTestStruct();
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         Assert.Throws<ArgumentOutOfRangeException>("position", () => uma.Write<UmaTestStruct>(capacity, ref inStruct));
         Assert.Throws<ArgumentOutOfRangeException>("position", () => uma.Read<UmaTestStruct>(capacity, out inStruct));
     }
 }
コード例 #7
0
        public static void UmaReadStructArray_WriteMode()
        {
            const int capacity = 100;

            UmaTestStruct[] structArr = new UmaTestStruct[1];
            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.Write))
                {
                    Assert.Throws <NotSupportedException>(() => uma.ReadArray <UmaTestStruct>(0, structArr, 0, 1));
                }
        }
コード例 #8
0
        public static void UmaReadWriteStruct_PositionGreaterThanCapacity()
        {
            const int     capacity = 100;
            UmaTestStruct inStruct = new UmaTestStruct();

            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("position", () => uma.Write <UmaTestStruct>(capacity, ref inStruct));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("position", () => uma.Read <UmaTestStruct>(capacity, out inStruct));
                }
        }
コード例 #9
0
 public static void UmaReadWriteStruct_Closed()
 {
     const int capacity = 100;
     UmaTestStruct inStruct = new UmaTestStruct();
     using (var buffer = new TestSafeBuffer(capacity))
     {
         UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite);
         uma.Dispose();
         Assert.Throws<ObjectDisposedException>(() => uma.Write<UmaTestStruct>(0, ref inStruct));
         Assert.Throws<ObjectDisposedException>(() => uma.Read<UmaTestStruct>(0, out inStruct));
     }
 }
コード例 #10
0
 public static void UmaReadWriteStructArray_InsufficientSpace()
 {
     const int capacity = 100;
     UmaTestStruct[] structArr = new UmaTestStruct[1];
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         Assert.Throws<ArgumentException>(() => uma.WriteArray<UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, structArr, 0, 1));
         Assert.Throws<ArgumentException>(() => uma.WriteArray<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, structArr, 0, 1));
         Assert.Equal(0, uma.ReadArray<UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, structArr, 0, 1));
         Assert.Equal(0, uma.ReadArray<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, structArr, 0, 1));
     }
 }
コード例 #11
0
        public static void UmaReadWriteStruct_Closed()
        {
            const int     capacity = 100;
            UmaTestStruct inStruct = new UmaTestStruct();

            using (var buffer = new TestSafeBuffer(capacity))
            {
                UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite);
                uma.Dispose();
                Assert.Throws <ObjectDisposedException>(() => uma.Write <UmaTestStruct>(0, ref inStruct));
                Assert.Throws <ObjectDisposedException>(() => uma.Read <UmaTestStruct>(0, out inStruct));
            }
        }
コード例 #12
0
 public static void UmaReadWriteStruct_InsufficientSpace()
 {
     const int capacity = 100;
     UmaTestStruct inStruct = new UmaTestStruct();
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         Assert.Throws<ArgumentException>(() => uma.Write<UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, ref inStruct));
         Assert.Throws<ArgumentException>(() => uma.Write<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, ref inStruct));
         Assert.Throws<ArgumentException>(() => uma.Read<UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, out inStruct));
         Assert.Throws<ArgumentException>(() => uma.Read<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, out inStruct));
     }
 }
コード例 #13
0
        public static void UmaReadWriteStructWithReferenceType_ThrowsArgumentException()
        {
            const int capacity = 100;
            UmaTestStruct_ContainsReferenceType inStruct = new UmaTestStruct_ContainsReferenceType {
                referenceType = new object()
            };

            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentException>(null, "type", () => uma.Write <UmaTestStruct_ContainsReferenceType>(0, ref inStruct));
                    AssertExtensions.Throws <ArgumentException>(null, "type", () => uma.Read <UmaTestStruct_ContainsReferenceType>(0, out inStruct));
                }
        }
コード例 #14
0
        public static void UmaReadWriteStructArray_InsufficientSpace()
        {
            const int capacity = 100;

            UmaTestStruct[] structArr = new UmaTestStruct[1];
            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentException>(null, () => uma.WriteArray <UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, structArr, 0, 1));
                    AssertExtensions.Throws <ArgumentException>(null, () => uma.WriteArray <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, structArr, 0, 1));
                    Assert.Equal(0, uma.ReadArray <UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, structArr, 0, 1));
                    Assert.Equal(0, uma.ReadArray <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, structArr, 0, 1));
                }
        }
コード例 #15
0
        public static void UmaReadWriteStruct_InsufficientSpace()
        {
            const int     capacity = 100;
            UmaTestStruct inStruct = new UmaTestStruct();

            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentException>("position", () => uma.Write <UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, ref inStruct));
                    AssertExtensions.Throws <ArgumentException>("position", () => uma.Write <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, ref inStruct));
                    AssertExtensions.Throws <ArgumentException>("position", () => uma.Read <UmaTestStruct>(capacity - UmaTestStruct_UnalignedSize + 1, out inStruct));
                    AssertExtensions.Throws <ArgumentException>("position", () => uma.Read <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize + 1, out inStruct));
                }
        }
コード例 #16
0
ファイル: UmaTests.cs プロジェクト: Rayislandstyle/corefx
        public static void UmaInvalidReadDecimal()
        {
            const int capacity = 16; // sizeof(decimal)

            using (var buffer = new TestSafeBuffer(capacity))
            using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
            {
                // UMA should throw when reading bad decimal values (some bits of flags are reserved and must be 0)
                uma.Write(0, 0); // lo
                uma.Write(4, 0); // mid
                uma.Write(8, 0); // hi
                uma.Write(12, -1); // flags (all bits are set, so this should raise an exception)
                Assert.Throws<ArgumentException>(() => uma.ReadDecimal(0)); // Should throw same exception as decimal(int[]) ctor for compat
            }
        }
コード例 #17
0
ファイル: UmaTests.cs プロジェクト: jnm2/corefx
        public static void UmaInvalidReadDecimal()
        {
            const int capacity = 16; // sizeof(decimal)

            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    // UMA should throw when reading bad decimal values (some bits of flags are reserved and must be 0)
                    uma.Write(0, 0);                                             // lo
                    uma.Write(4, 0);                                             // mid
                    uma.Write(8, 0);                                             // hi
                    uma.Write(12, -1);                                           // flags (all bits are set, so this should raise an exception)
                    Assert.Throws <ArgumentException>(() => uma.ReadDecimal(0)); // Should throw same exception as decimal(int[]) ctor for compat
                }
        }
コード例 #18
0
        public static void UmaReadWriteGenericStringStruct_ThrowsArgumentException()
        {
            const int capacity = 100;
            UmaTestStruct_Generic <string> inStruct = new UmaTestStruct_Generic <string>()
            {
                ofT = "Cats!"
            };

            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentException>(null, "type", () => uma.Write <UmaTestStruct_Generic <string> >(0, ref inStruct));
                    AssertExtensions.Throws <ArgumentException>(null, "type", () => uma.Read <UmaTestStruct_Generic <string> >(0, out inStruct));
                }
        }
コード例 #19
0
        public static void UmaReadWriteStructArrayWithReferenceType_ThrowsArgumentException()
        {
            const int capacity = 100;

            UmaTestStruct_ContainsReferenceType[] structArr = new UmaTestStruct_ContainsReferenceType[1] {
                new UmaTestStruct_ContainsReferenceType()
                {
                    referenceType = new object()
                }
            };
            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentException>("type", () => uma.WriteArray <UmaTestStruct_ContainsReferenceType>(0, structArr, 0, 1));
                    AssertExtensions.Throws <ArgumentException>("type", () => uma.ReadArray <UmaTestStruct_ContainsReferenceType>(0, structArr, 0, 1));
                }
        }
コード例 #20
0
        public static void UmaReadWriteGenericIntStruct_Valid()
        {
            const int capacity = 100;
            UmaTestStruct_Generic <int> inStruct = new UmaTestStruct_Generic <int> ()
            {
                ofT = 158
            };
            UmaTestStruct_Generic <int> outStruct;

            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    uma.Write <UmaTestStruct_Generic <int> >(0, ref inStruct);
                    uma.Read <UmaTestStruct_Generic <int> >(0, out outStruct);
                    Assert.Equal(inStruct.ofT, outStruct.ofT);
                }
        }
コード例 #21
0
        public static void UmaReadWriteGenericStringStructArray_ThrowsArgumentException()
        {
            const int capacity = 100;

            UmaTestStruct_Generic <string>[] structArr = new UmaTestStruct_Generic <string>[1] {
                new UmaTestStruct_Generic <string>()
                {
                    ofT = "Cats!"
                }
            };
            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentException>("type", () => uma.WriteArray <UmaTestStruct_Generic <string> >(0, structArr, 0, 1));
                    AssertExtensions.Throws <ArgumentException>("type", () => uma.ReadArray <UmaTestStruct_Generic <string> >(0, structArr, 0, 1));
                }
        }
コード例 #22
0
        public static void UmaReadWriteStructArrayGenericIntStruct_Valid()
        {
            const int capacity = 100;

            UmaTestStruct_Generic <int>[] inStructArr = new UmaTestStruct_Generic <int>[1] {
                new UmaTestStruct_Generic <int>()
                {
                    ofT = 190
                }
            };
            UmaTestStruct_Generic <int>[] outStructArr = new UmaTestStruct_Generic <int> [1];
            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    uma.WriteArray <UmaTestStruct_Generic <int> >(0, inStructArr, 0, 1);
                    Assert.Equal(1, uma.ReadArray <UmaTestStruct_Generic <int> >(0, outStructArr, 0, 1));
                    Assert.Equal(inStructArr[0].ofT, outStructArr[0].ofT);
                }
        }
コード例 #23
0
        public static void UmaReadWriteStructArray_TryToReadMoreThanAvailable()
        {
            const int capacity = 100;

            UmaTestStruct[] inStructArr = new UmaTestStruct[1] {
                new UmaTestStruct()
                {
                    int1 = 1, int2 = 2, bool1 = false, char1 = 'p', bool2 = true
                }
            };
            UmaTestStruct[] outStructArr = new UmaTestStruct[5000];
            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    uma.WriteArray <UmaTestStruct>(0, inStructArr, 0, 1);
                    int readCount = uma.ReadArray <UmaTestStruct>(0, outStructArr, 0, 5000);
                    Assert.Equal(capacity / UmaTestStruct_AlignedSize, readCount);
                }
        }
コード例 #24
0
        public static void WriteSafeBuffer()
        {
            var length = 1000;

            using (var buffer = new TestSafeBuffer(length))
            {
                var stream = new UnmanagedMemoryStream(buffer, 0, (long)buffer.ByteLength, FileAccess.Write);
                Assert.Equal(stream.Length, length);

                var bytes = ArrayHelpers.CreateByteArray(length);
                var copy  = bytes.Copy();
                stream.Write(copy, 0, length);

                var memory = buffer.ToArray();

                Assert.True(ArrayHelpers.Comparer <byte>().Equals(bytes, memory));

                stream.Write(new byte[0], 0, 0);
            }
        }
コード例 #25
0
ファイル: UmsCtorTests.cs プロジェクト: wpsmith/corefx
        public static unsafe void CtorsThatFail()
        {
            Assert.Throws <ArgumentNullException>(() => { var ums = new UnmanagedMemoryStream(null, 0); });

            TestSafeBuffer nullBuffer = null;
            FakeSafeBuffer fakeBuffer = new FakeSafeBuffer(99);

            Assert.Throws <ArgumentNullException>(() => new UnmanagedMemoryStream(nullBuffer, 0, 1));

            Assert.Throws <ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, 2, -1));
            Assert.Throws <ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, -1, 1));
            Assert.Throws <ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, 1, 2, (FileAccess)(-1)));
            Assert.Throws <ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, 1, 2, (FileAccess)42));

            Assert.Throws <ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, 2, 999));
            Assert.Throws <ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, 999, 9));
            Assert.Throws <ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, 1, 100));

            Assert.Throws <ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, Int32.MaxValue, 1));
        }
コード例 #26
0
        public static void UmaReadWriteStruct_Valid()
        {
            const int     capacity = 100;
            UmaTestStruct inStruct = new UmaTestStruct()
            {
                int1 = 1, int2 = 2, bool1 = false, char1 = 'p', bool2 = true
            };
            UmaTestStruct outStruct;

            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    uma.Write <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, ref inStruct);
                    uma.Read <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, out outStruct);
                    Assert.Equal(inStruct.int1, outStruct.int1);
                    Assert.Equal(inStruct.int2, outStruct.int2);
                    Assert.Equal(inStruct.bool1, outStruct.bool1);
                    Assert.Equal(inStruct.char1, outStruct.char1);
                    Assert.Equal(inStruct.bool2, outStruct.bool2);
                }
        }
コード例 #27
0
 public static void UmaReadWriteStructArray_InvalidParameters()
 {
     const int capacity = 100;
     UmaTestStruct[] structArr = new UmaTestStruct[1];
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         Assert.Throws<ArgumentNullException>("array", () => uma.WriteArray<UmaTestStruct>(0, null, 0, 1));
         Assert.Throws<ArgumentNullException>("array", () => uma.ReadArray<UmaTestStruct>(0, null, 0, 1));
         Assert.Throws<ArgumentOutOfRangeException>("offset", () => uma.WriteArray<UmaTestStruct>(0, structArr, -1, 1));
         Assert.Throws<ArgumentOutOfRangeException>("offset", () => uma.ReadArray<UmaTestStruct>(0, structArr, -1, 1));
         Assert.Throws<ArgumentOutOfRangeException>("count", () => uma.WriteArray<UmaTestStruct>(0, structArr, 0, -1));
         Assert.Throws<ArgumentOutOfRangeException>("count", () => uma.ReadArray<UmaTestStruct>(0, structArr, 0, -1));
         Assert.Throws<ArgumentException>(() => uma.WriteArray<UmaTestStruct>(0, structArr, 2, 0));
         Assert.Throws<ArgumentException>(() => uma.ReadArray<UmaTestStruct>(0, structArr, 2, 0));
         Assert.Throws<ArgumentException>(() => uma.WriteArray<UmaTestStruct>(0, structArr, 0, 2));
         Assert.Throws<ArgumentException>(() => uma.ReadArray<UmaTestStruct>(0, structArr, 0, 2));
         Assert.Throws<ArgumentOutOfRangeException>("position", () => uma.WriteArray<UmaTestStruct>(-1, structArr, 0, 1));
         Assert.Throws<ArgumentOutOfRangeException>("position", () => uma.ReadArray<UmaTestStruct>(-1, structArr, 0, 1));
         Assert.Throws<ArgumentOutOfRangeException>("position", () => uma.WriteArray<UmaTestStruct>(capacity, structArr, 0, 1));
         Assert.Throws<ArgumentOutOfRangeException>("position", () => uma.ReadArray<UmaTestStruct>(capacity, structArr, 0, 1));
     }
 }
コード例 #28
0
        public static void UmaReadWriteStructArray_OneItem()
        {
            const int capacity = 100;

            UmaTestStruct[] inStructArr = new UmaTestStruct[1] {
                new UmaTestStruct()
                {
                    int1 = 1, int2 = 2, bool1 = false, char1 = 'p', bool2 = true
                }
            };
            UmaTestStruct[] outStructArr = new UmaTestStruct[1];
            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    uma.WriteArray <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, inStructArr, 0, 1);
                    Assert.Equal(1, uma.ReadArray <UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, outStructArr, 0, 1));
                    Assert.Equal(inStructArr[0].int1, outStructArr[0].int1);
                    Assert.Equal(inStructArr[0].int2, outStructArr[0].int2);
                    Assert.Equal(inStructArr[0].bool1, outStructArr[0].bool1);
                    Assert.Equal(inStructArr[0].char1, outStructArr[0].char1);
                    Assert.Equal(inStructArr[0].bool2, outStructArr[0].bool2);
                }
        }
コード例 #29
0
        public static void UmaReadWriteStructArray_InvalidParameters()
        {
            const int capacity = 100;

            UmaTestStruct[] structArr = new UmaTestStruct[1];
            using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
                using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    AssertExtensions.Throws <ArgumentNullException>("array", () => uma.WriteArray <UmaTestStruct>(0, null, 0, 1));
                    AssertExtensions.Throws <ArgumentNullException>("array", () => uma.ReadArray <UmaTestStruct>(0, null, 0, 1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("offset", () => uma.WriteArray <UmaTestStruct>(0, structArr, -1, 1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("offset", () => uma.ReadArray <UmaTestStruct>(0, structArr, -1, 1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => uma.WriteArray <UmaTestStruct>(0, structArr, 0, -1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => uma.ReadArray <UmaTestStruct>(0, structArr, 0, -1));
                    AssertExtensions.Throws <ArgumentException>(null, () => uma.WriteArray <UmaTestStruct>(0, structArr, 2, 0));
                    AssertExtensions.Throws <ArgumentException>(null, () => uma.ReadArray <UmaTestStruct>(0, structArr, 2, 0));
                    AssertExtensions.Throws <ArgumentException>(null, () => uma.WriteArray <UmaTestStruct>(0, structArr, 0, 2));
                    AssertExtensions.Throws <ArgumentException>(null, () => uma.ReadArray <UmaTestStruct>(0, structArr, 0, 2));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("position", () => uma.WriteArray <UmaTestStruct>(-1, structArr, 0, 1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("position", () => uma.ReadArray <UmaTestStruct>(-1, structArr, 0, 1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("position", () => uma.WriteArray <UmaTestStruct>(capacity, structArr, 0, 1));
                    AssertExtensions.Throws <ArgumentOutOfRangeException>("position", () => uma.ReadArray <UmaTestStruct>(capacity, structArr, 0, 1));
                }
        }
コード例 #30
0
ファイル: UmaTests.cs プロジェクト: johnhhm/corefx
        public static void UmaReadWrite()
        {
            const int capacity = 199;

            const bool expectedBool = true; // 1
            const byte expectedByte = 123; // 1
            const sbyte expectedSByte = -128; // 1
            const char expectedChar = (char)255; // 2
            const ushort expectedUInt16 = ushort.MinValue; // 2
            const short expectedInt16 = short.MaxValue - 1; // 2
            const uint expectedUInt32 = 67890; // 4
            const int expectedInt32 = int.MinValue; // 4
            const float expectedSingle = 0.000123f; // 4
            const ulong expectedUInt64 = ulong.MaxValue - 12345; // 8
            const long expectedInt64 = 12345; // 8
            const double expectedDouble = 1234567.890; // 8
            const decimal expectedDecimal = 1.1m; //123.456m; // 16

            using (var buffer = new TestSafeBuffer(capacity))
            using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
            {
                long pos = 0;

                uma.Write(pos, expectedBool);
                pos += sizeof(bool);

                uma.Write(pos, expectedByte);
                pos += sizeof(byte);

                uma.Write(pos, expectedSByte);
                pos += sizeof(sbyte);

                pos = EnsureAligned(pos, sizeof(char));
                uma.Write(pos, expectedChar);
                pos += sizeof(char);

                pos = EnsureNotAligned(pos, sizeof(char));
                uma.Write(pos, expectedChar);
                pos += sizeof(char);

                pos = EnsureAligned(pos, sizeof(ushort));
                uma.Write(pos, expectedUInt16);
                pos += sizeof(ushort);

                pos = EnsureNotAligned(pos, sizeof(ushort));
                uma.Write(pos, expectedUInt16);
                pos += sizeof(ushort);

                pos = EnsureAligned(pos, sizeof(short));
                uma.Write(pos, expectedInt16);
                pos += sizeof(short);

                pos = EnsureNotAligned(pos, sizeof(short));
                uma.Write(pos, expectedInt16);
                pos += sizeof(short);

                pos = EnsureAligned(pos, sizeof(uint));
                uma.Write(pos, expectedUInt32);
                pos += sizeof(uint);

                pos = EnsureNotAligned(pos, sizeof(uint));
                uma.Write(pos, expectedUInt32);
                pos += sizeof(uint);

                pos = EnsureAligned(pos, sizeof(int));
                uma.Write(pos, expectedInt32);
                pos += sizeof(int);

                pos = EnsureNotAligned(pos, sizeof(int));
                uma.Write(pos, expectedInt32);
                pos += sizeof(int);

                pos = EnsureAligned(pos, sizeof(float));
                uma.Write(pos, expectedSingle);
                pos += sizeof(float);

                pos = EnsureNotAligned(pos, sizeof(float));
                uma.Write(pos, expectedSingle);
                pos += sizeof(float);

                pos = EnsureAligned(pos, sizeof(ulong));
                uma.Write(pos, expectedUInt64);
                pos += sizeof(ulong);

                pos = EnsureNotAligned(pos, sizeof(ulong));
                uma.Write(pos, expectedUInt64);
                pos += sizeof(ulong);

                pos = EnsureAligned(pos, sizeof(long));
                uma.Write(pos, expectedInt64);
                pos += sizeof(long);

                pos = EnsureNotAligned(pos, sizeof(long));
                uma.Write(pos, expectedInt64);
                pos += sizeof(long);

                pos = EnsureAligned(pos, sizeof(double));
                uma.Write(pos, expectedDouble);
                pos += sizeof(double);

                pos = EnsureNotAligned(pos, sizeof(double));
                uma.Write(pos, expectedDouble);
                pos += sizeof(double);

                pos = EnsureAligned(pos, sizeof(decimal));
                uma.Write(pos, expectedDecimal);
                pos += sizeof(decimal);

                pos = EnsureNotAligned(pos, sizeof(decimal));
                uma.Write(pos, expectedDecimal);

                pos = 0;
                Assert.Equal(expectedBool, uma.ReadBoolean(pos));
                pos += sizeof(bool);

                Assert.Equal(expectedByte, uma.ReadByte(pos));
                pos += sizeof(byte);

                Assert.Equal(expectedSByte, uma.ReadSByte(pos));
                pos += sizeof(sbyte);

                pos = EnsureAligned(pos, sizeof(char));
                Assert.Equal(expectedChar, uma.ReadChar(pos));
                pos += sizeof(char);

                pos = EnsureNotAligned(pos, sizeof(char));
                Assert.Equal(expectedChar, uma.ReadChar(pos));
                pos += sizeof(char);

                pos = EnsureAligned(pos, sizeof(ushort));
                Assert.Equal(expectedUInt16, uma.ReadUInt16(pos));
                pos += sizeof(ushort);

                pos = EnsureNotAligned(pos, sizeof(ushort));
                Assert.Equal(expectedUInt16, uma.ReadUInt16(pos));
                pos += sizeof(ushort);

                pos = EnsureAligned(pos, sizeof(short));
                Assert.Equal(expectedInt16, uma.ReadInt16(pos));
                pos += sizeof(short);

                pos = EnsureNotAligned(pos, sizeof(short));
                Assert.Equal(expectedInt16, uma.ReadInt16(pos));
                pos += sizeof(short);

                pos = EnsureAligned(pos, sizeof(uint));
                Assert.Equal(expectedUInt32, uma.ReadUInt32(pos));
                pos += sizeof(uint);

                pos = EnsureNotAligned(pos, sizeof(uint));
                Assert.Equal(expectedUInt32, uma.ReadUInt32(pos));
                pos += sizeof(uint);

                pos = EnsureAligned(pos, sizeof(int));
                Assert.Equal(expectedInt32, uma.ReadInt32(pos));
                pos += sizeof(int);

                pos = EnsureNotAligned(pos, sizeof(int));
                Assert.Equal(expectedInt32, uma.ReadInt32(pos));
                pos += sizeof(int);

                pos = EnsureAligned(pos, sizeof(float));
                Assert.Equal(expectedSingle, uma.ReadSingle(pos));
                pos += sizeof(float);

                pos = EnsureNotAligned(pos, sizeof(float));
                Assert.Equal(expectedSingle, uma.ReadSingle(pos));
                pos += sizeof(float);

                pos = EnsureAligned(pos, sizeof(ulong));
                Assert.Equal(expectedUInt64, uma.ReadUInt64(pos));
                pos += sizeof(ulong);

                pos = EnsureNotAligned(pos, sizeof(ulong));
                Assert.Equal(expectedUInt64, uma.ReadUInt64(pos));
                pos += sizeof(ulong);

                pos = EnsureAligned(pos, sizeof(long));
                Assert.Equal(expectedInt64, uma.ReadInt64(pos));
                pos += sizeof(long);

                pos = EnsureNotAligned(pos, sizeof(long));
                Assert.Equal(expectedInt64, uma.ReadInt64(pos));
                pos += sizeof(long);

                pos = EnsureAligned(pos, sizeof(double));
                Assert.Equal(expectedDouble, uma.ReadDouble(pos));
                pos += sizeof(double);

                pos = EnsureNotAligned(pos, sizeof(double));
                Assert.Equal(expectedDouble, uma.ReadDouble(pos));
                pos += sizeof(double);

                pos = EnsureAligned(pos, sizeof(decimal));
                Assert.Equal(expectedDecimal, uma.ReadDecimal(pos));
                pos += sizeof(decimal);

                pos = EnsureNotAligned(pos, sizeof(decimal));
                Assert.Equal(expectedDecimal, uma.ReadDecimal(pos));
            }
        }
コード例 #31
0
 public static void UmaReadWriteStructArray_OneItem()
 {
     const int capacity = 100;
     UmaTestStruct[] inStructArr = new UmaTestStruct[1] { new UmaTestStruct() { int1 = 1, int2 = 2, bool1 = false, char1 = 'p', bool2 = true } };
     UmaTestStruct[] outStructArr = new UmaTestStruct[1];
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         uma.WriteArray<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, inStructArr, 0, 1);
         Assert.Equal(1, uma.ReadArray<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, outStructArr, 0, 1));
         Assert.Equal(inStructArr[0].int1, outStructArr[0].int1);
         Assert.Equal(inStructArr[0].int2, outStructArr[0].int2);
         Assert.Equal(inStructArr[0].bool1, outStructArr[0].bool1);
         Assert.Equal(inStructArr[0].char1, outStructArr[0].char1);
         Assert.Equal(inStructArr[0].bool2, outStructArr[0].bool2);
     }
 }
コード例 #32
0
ファイル: UmsSafeBuffer.cs プロジェクト: ChuangYang/corefx
        public static void ReadWriteByteSafeBuffer()
        {
            const int length = 1000;
            using (var buffer = new TestSafeBuffer(length))
            {
                var stream = new UnmanagedMemoryStream(buffer, 0, (long)buffer.ByteLength, FileAccess.ReadWrite);
                Assert.Equal(stream.Length, length);

                var bytes = ArrayHelpers.CreateByteArray(length);
                for (int index = 0; index < length; index++)
                {
                    stream.WriteByte(bytes[index]);
                }

                stream.Position = 0;
                for (int index = 0; index < length; index++)
                {
                    int value = stream.ReadByte();
                    Assert.Equal(bytes[index], (byte)value);
                }

                var memory = buffer.ToArray();
                Assert.Equal(bytes, memory, ArrayHelpers.Comparer<byte>());
            }
        }
コード例 #33
0
 public static void UmaReadWriteStructArray_Multiples()
 {
     const int numberOfStructs = 12;
     const int capacity = numberOfStructs * UmaTestStruct_AlignedSize;
     UmaTestStruct[] inStructArr = new UmaTestStruct[numberOfStructs];
     UmaTestStruct[] outStructArr = new UmaTestStruct[numberOfStructs];
     for (int i = 0; i < numberOfStructs; i++)
     {
         inStructArr[i] = new UmaTestStruct() { bool1 = false, bool2 = true, int1 = i, int2 = i + 1, char1 = (char)i };
     }
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         uma.WriteArray<UmaTestStruct>(0, inStructArr, 0, numberOfStructs);
         Assert.Equal(numberOfStructs, uma.ReadArray<UmaTestStruct>(0, outStructArr, 0, numberOfStructs));
         for (int i = 0; i < numberOfStructs; i++)
         {
             Assert.Equal(i, outStructArr[i].int1);
             Assert.Equal(i+1, outStructArr[i].int2);
             Assert.Equal(false, outStructArr[i].bool1);
             Assert.Equal((char)i, outStructArr[i].char1);
             Assert.Equal(true, outStructArr[i].bool2);
         }
     }
 }
コード例 #34
0
 public static void UmaReadWriteStructArray_TryToReadMoreThanAvailable()
 {
     const int capacity = 100;
     UmaTestStruct[] inStructArr = new UmaTestStruct[1] { new UmaTestStruct() { int1 = 1, int2 = 2, bool1 = false, char1 = 'p', bool2 = true } };
     UmaTestStruct[] outStructArr = new UmaTestStruct[5000];
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         uma.WriteArray<UmaTestStruct>(0, inStructArr, 0, 1);
         int readCount = uma.ReadArray<UmaTestStruct>(0, outStructArr, 0, 5000);
         Assert.Equal(capacity / UmaTestStruct_AlignedSize, readCount);
     }
 }
コード例 #35
0
ファイル: UmaTests.cs プロジェクト: gitter-badger/corefx
        public static void UmaReadWrite()
        {
            var capacity = 99;

            Boolean v1 = true; // 1
            Byte v2 = (Byte)123; // 1
            Char v3 = (Char)255; // 1
            Int16 v4 = Int16.MaxValue - 1; // 2
            Int32 v5 = Int32.MinValue; // 4
            Int64 v6 = 12345; // 8
            Decimal v7 = 1.1m; //123.456m; // 16
            Single v8 = 0.000123f; // 4
            Double v9 = 1234567.890; // 8
            SByte v10 = (SByte)(-128); // 1
            UInt16 v11 = UInt16.MinValue; // 2
            UInt32 v12 = 67890; // 4
            UInt64 v13 = UInt32.MaxValue - 12345; // 8

            using (var buffer = new TestSafeBuffer(capacity))
            using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
            {
                long pos = 0;
                uma.Write(pos, v1);
                pos += sizeof(Boolean);
                uma.Write(pos, v2);
                pos += sizeof(Byte);
                uma.Write(pos, v3);
                pos += sizeof(Char);
                uma.Write(pos, v4);
                pos += sizeof(Int16);
                uma.Write(pos, v5);
                pos += sizeof(Int32);
                uma.Write(pos, v6);
                pos += sizeof(Int64);
                long pp = pos;
                uma.Write(pos, v7);
                pos += sizeof(Decimal);
                uma.Write(pos, v8);
                pos += sizeof(Single);
                uma.Write(pos, v9);
                pos += sizeof(Double);
                uma.Write(pos, v10);
                pos += sizeof(SByte);
                uma.Write(pos, v11);
                pos += sizeof(UInt16);
                uma.Write(pos, v12);
                pos += sizeof(UInt32);
                uma.Write(pos, v13);

                pos = 0;
                var v01 = uma.ReadBoolean(pos);
                Assert.Equal(v1, v01);
                pos += sizeof(Boolean);
                var v02 = uma.ReadByte(pos);
                Assert.Equal(v2, v02);
                pos += sizeof(Byte);
                var v03 = uma.ReadChar(pos);
                Assert.Equal(v3, v03);
                pos += sizeof(Char);
                var v04 = uma.ReadInt16(pos);
                Assert.Equal(v4, v04);
                pos += sizeof(Int16);
                var v05 = uma.ReadInt32(pos);
                Assert.Equal(v5, v05);
                pos += sizeof(Int32);
                var v06 = uma.ReadInt64(pos);
                Assert.Equal(v6, v06);
                pos += sizeof(Int64);
                var v07 = uma.ReadDecimal(pos);
                Assert.Equal(v7, v07);
                pos += sizeof(Decimal);
                var v08 = uma.ReadSingle(pos);
                Assert.Equal(v8, v08);
                pos += sizeof(Single);
                var v09 = uma.ReadDouble(pos);
                Assert.Equal(v9, v09);
                pos += sizeof(Double);
                var v010 = uma.ReadSByte(pos);
                Assert.Equal(v10, v010);
                pos += sizeof(SByte);
                var v011 = uma.ReadUInt16(pos);
                Assert.Equal(v11, v011);
                pos += sizeof(UInt16);
                var v012 = uma.ReadUInt32(pos);
                Assert.Equal(v12, v012);
                pos += sizeof(UInt32);
                var v013 = uma.ReadUInt64(pos);
                Assert.Equal(v13, v013);
            }
        }
コード例 #36
0
        public static void UmaReadWrite()
        {
            var capacity = 99;

            Boolean v1  = true;                    // 1
            Byte    v2  = (Byte)123;               // 1
            Char    v3  = (Char)255;               // 1
            Int16   v4  = Int16.MaxValue - 1;      // 2
            Int32   v5  = Int32.MinValue;          // 4
            Int64   v6  = 12345;                   // 8
            Decimal v7  = 1.1m;                    //123.456m; // 16
            Single  v8  = 0.000123f;               // 4
            Double  v9  = 1234567.890;             // 8
            SByte   v10 = (SByte)(-128);           // 1
            UInt16  v11 = UInt16.MinValue;         // 2
            UInt32  v12 = 67890;                   // 4
            UInt64  v13 = UInt32.MaxValue - 12345; // 8

            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    long pos = 0;
                    uma.Write(pos, v1);
                    pos += sizeof(Boolean);
                    uma.Write(pos, v2);
                    pos += sizeof(Byte);
                    uma.Write(pos, v3);
                    pos += sizeof(Char);
                    uma.Write(pos, v4);
                    pos += sizeof(Int16);
                    uma.Write(pos, v5);
                    pos += sizeof(Int32);
                    uma.Write(pos, v6);
                    pos += sizeof(Int64);
                    long pp = pos;
                    uma.Write(pos, v7);
                    pos += sizeof(Decimal);
                    uma.Write(pos, v8);
                    pos += sizeof(Single);
                    uma.Write(pos, v9);
                    pos += sizeof(Double);
                    uma.Write(pos, v10);
                    pos += sizeof(SByte);
                    uma.Write(pos, v11);
                    pos += sizeof(UInt16);
                    uma.Write(pos, v12);
                    pos += sizeof(UInt32);
                    uma.Write(pos, v13);

                    pos = 0;
                    var v01 = uma.ReadBoolean(pos);
                    Assert.Equal(v1, v01);
                    pos += sizeof(Boolean);
                    var v02 = uma.ReadByte(pos);
                    Assert.Equal(v2, v02);
                    pos += sizeof(Byte);
                    var v03 = uma.ReadChar(pos);
                    Assert.Equal(v3, v03);
                    pos += sizeof(Char);
                    var v04 = uma.ReadInt16(pos);
                    Assert.Equal(v4, v04);
                    pos += sizeof(Int16);
                    var v05 = uma.ReadInt32(pos);
                    Assert.Equal(v5, v05);
                    pos += sizeof(Int32);
                    var v06 = uma.ReadInt64(pos);
                    Assert.Equal(v6, v06);
                    pos += sizeof(Int64);
                    var v07 = uma.ReadDecimal(pos);
                    Assert.Equal(v7, v07);
                    pos += sizeof(Decimal);
                    var v08 = uma.ReadSingle(pos);
                    Assert.Equal(v8, v08);
                    pos += sizeof(Single);
                    var v09 = uma.ReadDouble(pos);
                    Assert.Equal(v9, v09);
                    pos += sizeof(Double);
                    var v010 = uma.ReadSByte(pos);
                    Assert.Equal(v10, v010);
                    pos += sizeof(SByte);
                    var v011 = uma.ReadUInt16(pos);
                    Assert.Equal(v11, v011);
                    pos += sizeof(UInt16);
                    var v012 = uma.ReadUInt32(pos);
                    Assert.Equal(v12, v012);
                    pos += sizeof(UInt32);
                    var v013 = uma.ReadUInt64(pos);
                    Assert.Equal(v13, v013);
                }
        }
コード例 #37
0
ファイル: UmaTests.cs プロジェクト: jnm2/corefx
        public static void UmaReadWrite()
        {
            const int capacity = 199;

            const bool    expectedBool    = true;                   // 1
            const byte    expectedByte    = 123;                    // 1
            const sbyte   expectedSByte   = -128;                   // 1
            const char    expectedChar    = (char)255;              // 2
            const ushort  expectedUInt16  = ushort.MinValue;        // 2
            const short   expectedInt16   = short.MaxValue - 1;     // 2
            const uint    expectedUInt32  = 67890;                  // 4
            const int     expectedInt32   = int.MinValue;           // 4
            const float   expectedSingle  = 0.000123f;              // 4
            const ulong   expectedUInt64  = ulong.MaxValue - 12345; // 8
            const long    expectedInt64   = 12345;                  // 8
            const double  expectedDouble  = 1234567.890;            // 8
            const decimal expectedDecimal = 1.1m;                   //123.456m; // 16

            using (var buffer = new TestSafeBuffer(capacity))
                using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
                {
                    long pos = 0;

                    uma.Write(pos, expectedBool);
                    pos += sizeof(bool);

                    uma.Write(pos, expectedByte);
                    pos += sizeof(byte);

                    uma.Write(pos, expectedSByte);
                    pos += sizeof(sbyte);

                    pos = EnsureAligned(pos, sizeof(char));
                    uma.Write(pos, expectedChar);
                    pos += sizeof(char);

                    pos = EnsureNotAligned(pos, sizeof(char));
                    uma.Write(pos, expectedChar);
                    pos += sizeof(char);

                    pos = EnsureAligned(pos, sizeof(ushort));
                    uma.Write(pos, expectedUInt16);
                    pos += sizeof(ushort);

                    pos = EnsureNotAligned(pos, sizeof(ushort));
                    uma.Write(pos, expectedUInt16);
                    pos += sizeof(ushort);

                    pos = EnsureAligned(pos, sizeof(short));
                    uma.Write(pos, expectedInt16);
                    pos += sizeof(short);

                    pos = EnsureNotAligned(pos, sizeof(short));
                    uma.Write(pos, expectedInt16);
                    pos += sizeof(short);

                    pos = EnsureAligned(pos, sizeof(uint));
                    uma.Write(pos, expectedUInt32);
                    pos += sizeof(uint);

                    pos = EnsureNotAligned(pos, sizeof(uint));
                    uma.Write(pos, expectedUInt32);
                    pos += sizeof(uint);

                    pos = EnsureAligned(pos, sizeof(int));
                    uma.Write(pos, expectedInt32);
                    pos += sizeof(int);

                    pos = EnsureNotAligned(pos, sizeof(int));
                    uma.Write(pos, expectedInt32);
                    pos += sizeof(int);

                    pos = EnsureAligned(pos, sizeof(float));
                    uma.Write(pos, expectedSingle);
                    pos += sizeof(float);

                    pos = EnsureNotAligned(pos, sizeof(float));
                    uma.Write(pos, expectedSingle);
                    pos += sizeof(float);

                    pos = EnsureAligned(pos, sizeof(ulong));
                    uma.Write(pos, expectedUInt64);
                    pos += sizeof(ulong);

                    pos = EnsureNotAligned(pos, sizeof(ulong));
                    uma.Write(pos, expectedUInt64);
                    pos += sizeof(ulong);

                    pos = EnsureAligned(pos, sizeof(long));
                    uma.Write(pos, expectedInt64);
                    pos += sizeof(long);

                    pos = EnsureNotAligned(pos, sizeof(long));
                    uma.Write(pos, expectedInt64);
                    pos += sizeof(long);

                    pos = EnsureAligned(pos, sizeof(double));
                    uma.Write(pos, expectedDouble);
                    pos += sizeof(double);

                    pos = EnsureNotAligned(pos, sizeof(double));
                    uma.Write(pos, expectedDouble);
                    pos += sizeof(double);

                    pos = EnsureAligned(pos, sizeof(decimal));
                    uma.Write(pos, expectedDecimal);
                    pos += sizeof(decimal);

                    pos = EnsureNotAligned(pos, sizeof(decimal));
                    uma.Write(pos, expectedDecimal);

                    pos = 0;
                    Assert.Equal(expectedBool, uma.ReadBoolean(pos));
                    pos += sizeof(bool);

                    Assert.Equal(expectedByte, uma.ReadByte(pos));
                    pos += sizeof(byte);

                    Assert.Equal(expectedSByte, uma.ReadSByte(pos));
                    pos += sizeof(sbyte);

                    pos = EnsureAligned(pos, sizeof(char));
                    Assert.Equal(expectedChar, uma.ReadChar(pos));
                    pos += sizeof(char);

                    pos = EnsureNotAligned(pos, sizeof(char));
                    Assert.Equal(expectedChar, uma.ReadChar(pos));
                    pos += sizeof(char);

                    pos = EnsureAligned(pos, sizeof(ushort));
                    Assert.Equal(expectedUInt16, uma.ReadUInt16(pos));
                    pos += sizeof(ushort);

                    pos = EnsureNotAligned(pos, sizeof(ushort));
                    Assert.Equal(expectedUInt16, uma.ReadUInt16(pos));
                    pos += sizeof(ushort);

                    pos = EnsureAligned(pos, sizeof(short));
                    Assert.Equal(expectedInt16, uma.ReadInt16(pos));
                    pos += sizeof(short);

                    pos = EnsureNotAligned(pos, sizeof(short));
                    Assert.Equal(expectedInt16, uma.ReadInt16(pos));
                    pos += sizeof(short);

                    pos = EnsureAligned(pos, sizeof(uint));
                    Assert.Equal(expectedUInt32, uma.ReadUInt32(pos));
                    pos += sizeof(uint);

                    pos = EnsureNotAligned(pos, sizeof(uint));
                    Assert.Equal(expectedUInt32, uma.ReadUInt32(pos));
                    pos += sizeof(uint);

                    pos = EnsureAligned(pos, sizeof(int));
                    Assert.Equal(expectedInt32, uma.ReadInt32(pos));
                    pos += sizeof(int);

                    pos = EnsureNotAligned(pos, sizeof(int));
                    Assert.Equal(expectedInt32, uma.ReadInt32(pos));
                    pos += sizeof(int);

                    pos = EnsureAligned(pos, sizeof(float));
                    Assert.Equal(expectedSingle, uma.ReadSingle(pos));
                    pos += sizeof(float);

                    pos = EnsureNotAligned(pos, sizeof(float));
                    Assert.Equal(expectedSingle, uma.ReadSingle(pos));
                    pos += sizeof(float);

                    pos = EnsureAligned(pos, sizeof(ulong));
                    Assert.Equal(expectedUInt64, uma.ReadUInt64(pos));
                    pos += sizeof(ulong);

                    pos = EnsureNotAligned(pos, sizeof(ulong));
                    Assert.Equal(expectedUInt64, uma.ReadUInt64(pos));
                    pos += sizeof(ulong);

                    pos = EnsureAligned(pos, sizeof(long));
                    Assert.Equal(expectedInt64, uma.ReadInt64(pos));
                    pos += sizeof(long);

                    pos = EnsureNotAligned(pos, sizeof(long));
                    Assert.Equal(expectedInt64, uma.ReadInt64(pos));
                    pos += sizeof(long);

                    pos = EnsureAligned(pos, sizeof(double));
                    Assert.Equal(expectedDouble, uma.ReadDouble(pos));
                    pos += sizeof(double);

                    pos = EnsureNotAligned(pos, sizeof(double));
                    Assert.Equal(expectedDouble, uma.ReadDouble(pos));
                    pos += sizeof(double);

                    pos = EnsureAligned(pos, sizeof(decimal));
                    Assert.Equal(expectedDecimal, uma.ReadDecimal(pos));
                    pos += sizeof(decimal);

                    pos = EnsureNotAligned(pos, sizeof(decimal));
                    Assert.Equal(expectedDecimal, uma.ReadDecimal(pos));
                }
        }
コード例 #38
0
 public static void UmaReadWriteGenericIntStruct_Valid()
 {
     const int capacity = 100;
     UmaTestStruct_Generic<int> inStruct = new UmaTestStruct_Generic<int> () { ofT = 158 };
     UmaTestStruct_Generic<int> outStruct;
     using (var buffer = new TestSafeBuffer(capacity))
     using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         uma.Write<UmaTestStruct_Generic<int>>(0, ref inStruct);
         uma.Read<UmaTestStruct_Generic<int>>(0, out outStruct);
         Assert.Equal(inStruct.ofT, outStruct.ofT);
     }
 }
コード例 #39
0
 public static void UmaReadWriteGenericStringStruct_ThrowsArgumentException()
 {
     const int capacity = 100;
     UmaTestStruct_Generic<string> inStruct = new UmaTestStruct_Generic<string>() { ofT = "Cats!" };
     using (var buffer = new TestSafeBuffer(capacity))
     using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         Assert.Throws<ArgumentException>("type", () => uma.Write<UmaTestStruct_Generic<string>>(0, ref inStruct));
         Assert.Throws<ArgumentException>("type", () => uma.Read<UmaTestStruct_Generic<string>>(0, out inStruct));
     }
 }
コード例 #40
0
 public static void UmaReadWriteStruct_Valid()
 {
     const int capacity = 100;
     UmaTestStruct inStruct = new UmaTestStruct(){ int1 = 1, int2 = 2, bool1 = false, char1 = 'p', bool2 = true};
     UmaTestStruct outStruct;
     using (TestSafeBuffer buffer = new TestSafeBuffer(capacity))
     using (UnmanagedMemoryAccessor uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         uma.Write<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, ref inStruct);
         uma.Read<UmaTestStruct>(capacity - UmaTestStruct_AlignedSize, out outStruct);
         Assert.Equal(inStruct.int1, outStruct.int1);
         Assert.Equal(inStruct.int2, outStruct.int2);
         Assert.Equal(inStruct.bool1, outStruct.bool1);
         Assert.Equal(inStruct.char1, outStruct.char1);
         Assert.Equal(inStruct.bool2, outStruct.bool2);
     }
 }
コード例 #41
0
 public static void UmaReadWriteStructWithReferenceType_ThrowsArgumentException()
 {
     const int capacity = 100;
     UmaTestStruct_ContainsReferenceType inStruct = new UmaTestStruct_ContainsReferenceType { referenceType = new object() };
     using (var buffer = new TestSafeBuffer(capacity))
     using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         Assert.Throws<ArgumentException>("type", () => uma.Write<UmaTestStruct_ContainsReferenceType>(0, ref inStruct));
         Assert.Throws<ArgumentException>("type", () => uma.Read<UmaTestStruct_ContainsReferenceType>(0, out inStruct));
     }
 }
コード例 #42
0
ファイル: UmsSafeBuffer.cs プロジェクト: ChuangYang/corefx
        public static void WriteSafeBuffer()
        {
            const int length = 1000;
            using (var buffer = new TestSafeBuffer(length))
            {
                var stream = new UnmanagedMemoryStream(buffer, 0, (long)buffer.ByteLength, FileAccess.Write);
                Assert.Equal(stream.Length, length);

                var bytes = ArrayHelpers.CreateByteArray(length);
                var copy = bytes.Copy();
                stream.Write(copy, 0, length);

                var memory = buffer.ToArray();

                Assert.Equal(bytes, memory, ArrayHelpers.Comparer<byte>());

                stream.Write(new byte[0], 0, 0);
            }
        }
コード例 #43
0
 public static void UmaReadWriteStructArrayGenericIntStruct_Valid()
 {
     const int capacity = 100;
     UmaTestStruct_Generic<int>[] inStructArr = new UmaTestStruct_Generic<int>[1] { new UmaTestStruct_Generic<int>() { ofT = 190 } };
     UmaTestStruct_Generic<int>[] outStructArr = new UmaTestStruct_Generic<int>[1];
     using (var buffer = new TestSafeBuffer(capacity))
     using (var uma = new UnmanagedMemoryAccessor(buffer, 0, capacity, FileAccess.ReadWrite))
     {
         uma.WriteArray<UmaTestStruct_Generic<int>>(0, inStructArr, 0, 1);
         Assert.Equal(1, uma.ReadArray<UmaTestStruct_Generic<int>>(0, outStructArr, 0, 1));
         Assert.Equal(inStructArr[0].ofT, outStructArr[0].ofT);
     }
 }