Exemple #1
0
        public void TestWriteReadTArrayStructure()
        {
            MockVector[] vectors = new MockVector[3]
            {
                new MockVector(12344.12323f, 177733.123f, 84717.1234f),
                new MockVector(1232444.12323f, 17237733.123f, 847317.1234f),
                new MockVector(1344.123f, 1733.123f, 717.1234f)
            };

            IntPtr address = Marshal.AllocHGlobal(vectors.Length * Marshal.SizeOf <MockVector>());

            try
            {
                Proc.Write(address, vectors);
                MockVector[] results = Proc.Read <MockVector>(address, 3);

                Assert.AreEqual(vectors.Length, results.Length);
                for (int i = 0; i < vectors.Length; i++)
                {
                    Assert.AreEqual(vectors[i].X, results[i].X);
                    Assert.AreEqual(vectors[i].Y, results[i].Y);
                    Assert.AreEqual(vectors[i].Z, results[i].Z);
                }
            }
            finally
            {
                Marshal.FreeHGlobal(address);
            }
        }
Exemple #2
0
        public void TestSerializeParseWithStructure()
        {
            MockVector vector = new MockVector(12304.123f, 12598.443f, 58387.183f);

            Seriz.Serialize(Buffer, vector);
            MockVector result = Seriz.Parse <MockVector>(Buffer);

            Assert.AreEqual(vector.X, result.X);
            Assert.AreEqual(vector.Y, result.Y);
            Assert.AreEqual(vector.Z, result.Z);
        }
Exemple #3
0
        public unsafe void TestReadTWithStructureArgument()
        {
            MockVector vector = new MockVector();

            vector.X = 123012.1023123f;
            vector.Y = 123123.123123f;
            vector.Z = 1222.1123123f;

            IntPtr     address = (IntPtr)(&vector);
            MockVector result  = Proc.Read <MockVector>(address);

            Assert.AreEqual(vector.X, result.X);
            Assert.AreEqual(vector.Y, result.Y);
            Assert.AreEqual(vector.Z, result.Z);
        }
Exemple #4
0
        public unsafe void TestWriteTWithStructureArgument()
        {
            MockVector vector = new MockVector();

            vector.X = 123123.012312f;
            vector.Y = 123123.1235f;
            vector.Z = 1231.11111f;

            MockVector result  = new MockVector();
            IntPtr     address = (IntPtr)(&result);

            Proc.Write(address, vector);
            Assert.AreEqual(vector.X, result.X);
            Assert.AreEqual(vector.Y, result.Y);
            Assert.AreEqual(vector.Z, result.Z);
        }
Exemple #5
0
        public void TestSerializeParseArrayWithStructure()
        {
            MockVector[] values = new MockVector[3];
            values[0] = new MockVector(12304.123f, 12598.443f, 58387.183f);
            values[1] = new MockVector(1230.123f, 1298.443f, 587.183f);
            values[2] = new MockVector(12323204.123f, 1259548.4143f, 583287.1f);

            Seriz.Serialize(Buffer, values);
            MockVector[] results = Seriz.Parse <MockVector>(Buffer, values.Length);

            Assert.AreEqual(values.Length, results.Length);
            for (int i = 0; i < values.Length; i++)
            {
                Assert.AreEqual(values[i].X, results[i].X);
                Assert.AreEqual(values[i].Y, results[i].Y);
                Assert.AreEqual(values[i].Z, results[i].Z);
            }
        }