示例#1
0
        public void OscBundleManyMessagesTest_1()
        {
            OscBundle target   = OscBundle.Parse("#bundle, 0, { /ping }, { /moop }, { /ping }, { /ping }, { /ping }");
            OscBundle expected = new OscBundle(new OscTimeTag(0),
                                               new OscMessage("/ping"), new OscMessage("/moop"), new OscMessage("/ping"), new OscMessage("/ping"), new OscMessage("/ping"));

            UnitTestHelper.AreEqual(target, expected);
        }
示例#2
0
        public void Nested_ParseTest()
        {
            string    str      = UnitTestHelper.DoubleNestedBundleString;
            OscBundle expected = UnitTestHelper.DoubleNestedBundle();
            OscBundle actual;

            actual = OscBundle.Parse(str);
            UnitTestHelper.AreEqual(expected, actual);
        }
示例#3
0
        public void OscBundleConstructorTest()
        {
            OscTimeTag timestamp = new OscTimeTag(14236589681638796952);

            OscMessage[] messages = new OscMessage[] { UnitTestHelper.Message_Array_Ints(), UnitTestHelper.Message_Array_Ints() };
            OscBundle    target   = new OscBundle(timestamp, messages);

            Assert.AreEqual(timestamp, target.Timestamp);
            UnitTestHelper.AreEqual(messages, target.ToArray());
        }
示例#4
0
        public void Nested_ToArrayTest()
        {
            OscBundle target = UnitTestHelper.DoubleNestedBundle();

            byte[] expected = UnitTestHelper.DoubleNestedBundleBody;
            byte[] actual;
            actual = target.ToByteArray();

            Assert.AreEqual(expected.Length, actual.Length);
            UnitTestHelper.AreEqual(expected, actual);
        }
示例#5
0
        public void OscBundleManyMessagesTest_2()
        {
            OscBundle target   = OscBundle.Parse("#bundle, 0, { /ping }, { /moop }, { /ping }, { /ping }, { /ping }");
            OscBundle expected = new OscBundle(new OscTimeTag(0),
                                               new OscMessage("/ping"), new OscMessage("/moop"), new OscMessage("/ping"), new OscMessage("/ping"), new OscMessage("/ping"));

            byte[] targetBytes = target.ToByteArray();

            OscBundle actual = OscBundle.Read(targetBytes, targetBytes.Length);

            UnitTestHelper.AreEqual(actual, expected);
        }
示例#6
0
        public void Nested_ReadTest()
        {
            OscBundle expected = UnitTestHelper.DoubleNestedBundle();

            byte[] bytes = UnitTestHelper.DoubleNestedBundleBody;

            int       count = bytes.Length;
            OscBundle actual;

            actual = OscBundle.Read(bytes, count);

            UnitTestHelper.AreEqual(expected, actual);
        }
示例#7
0
        public void WriteTest_Float()
        {
            byte[] expected = new byte[] { 0x41, 0xCA, 0x00, 0x00 };
            float  value    = 25.25F;

            using (MemoryStream stream = new MemoryStream())
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    Helper.Write(writer, value);

                    UnitTestHelper.AreEqual(expected, stream.GetBuffer(), stream.Length);
                }
        }
示例#8
0
        public void WriteTest_UInt64()
        {
            byte[] expected = new byte[] { 0xA1, 0xC2, 0xE3, 0xF4, 0xA5, 0xC6, 0xE7, 0xF8 };
            ulong  value    = 0xA1C2E3F4A5C6E7F8;

            using (MemoryStream stream = new MemoryStream())
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    Helper.Write(writer, value);

                    UnitTestHelper.AreEqual(expected, stream.GetBuffer(), stream.Length);
                }
        }
示例#9
0
        public void WriteTest_UInt32()
        {
            byte[] expected = new byte[] { 0xAB, 0xCD, 0xEF, 0xF2 };
            uint   value    = 0xABCDEFF2;

            using (MemoryStream stream = new MemoryStream())
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    Helper.Write(writer, value);

                    UnitTestHelper.AreEqual(expected, stream.GetBuffer(), stream.Length);
                }
        }
示例#10
0
        public void Nested_WriteTest()
        {
            OscBundle target = UnitTestHelper.DoubleNestedBundle();

            byte[] data     = new byte[UnitTestHelper.DoubleNestedBundleBody.Length];
            int    index    = 0;
            int    expected = UnitTestHelper.DoubleNestedBundleBody.Length;
            int    actual;

            actual = target.Write(data, index);

            Assert.AreEqual(expected, actual);
            UnitTestHelper.AreEqual(data, UnitTestHelper.DoubleNestedBundleBody);
        }
示例#11
0
        public void WriteTest_Double()
        {
            // 0x4028d8c7e28240b8
            // 12.4234
            byte[] expected = new byte[] { 0x40, 0x28, 0xd8, 0xc7, 0xe2, 0x82, 0x40, 0xb8 };
            double value    = 12.4234;

            using (MemoryStream stream = new MemoryStream())
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    Helper.Write(writer, value);

                    UnitTestHelper.AreEqual(expected, stream.GetBuffer(), stream.Length);
                }
        }
示例#12
0
        public void ReadTest()
        {
            OscTimeTag timestamp = new OscTimeTag(14236589681638796952);

            OscMessage[] messages = new OscMessage[] { UnitTestHelper.Message_Array_Ints(), UnitTestHelper.Message_Array_Ints() };
            OscBundle    expected = new OscBundle(timestamp, messages);

            byte[]    bytes = expected.ToByteArray();
            int       index = 0;
            int       count = bytes.Length;
            OscBundle actual;

            actual = OscBundle.Read(bytes, index, count);
            UnitTestHelper.AreEqual(expected, actual);

            Assert.IsTrue(actual.Equals(expected));
        }
示例#13
0
        public void ReadTest_MultiLine()
        {
            using (MemoryStream stream = new MemoryStream())
                using (StreamWriter writer = new StreamWriter(stream))
                    using (OscReader target = new OscReader(stream, OscPacketFormat.String))
                    {
                        writer.WriteLine(UnitTestHelper.BundleString_MultiLineString);
                        writer.Flush();
                        stream.Position = 0;

                        OscPacket expected = UnitTestHelper.Bundle_MultiLineString();
                        OscPacket actual;

                        actual = target.Read();

                        UnitTestHelper.AreEqual(expected, actual);
                    }
        }