Esempio n. 1
0
        public void TestArrayEq()
        {
            var ia  = new[] { 0, 0 };
            var ias = new ArraySegment <int>(new[] { 0, 0 });
            var ib  = new[] { 0, 0 };
            var ibs = new ArraySegment <int>(new[] { 0, 0 });
            var ic  = new[] { 0, 0, 0 };
            var ics = new ArraySegment <int>(new[] { 0, 0, 0 });
            var id  = new[] { 0, 1 };
            var ids = new ArraySegment <int>(new[] { 0, 1 });

            Assert.IsTrue(ia.Eq(ib));
            Assert.IsTrue(ia.Eq(ias));
            Assert.IsFalse(ia.Eq(ic));
            Assert.IsFalse(ia.Eq(id));
            Assert.IsFalse(ia.Eq(ics));
            Assert.IsFalse(ia.Eq(ids));

            Assert.IsTrue(ias.Eq(ia));
            Assert.IsTrue(ias.Eq(ibs));
            Assert.IsFalse(ias.Eq(ic));
            Assert.IsFalse(ias.Eq(id));
            Assert.IsFalse(ias.Eq(ics));
            Assert.IsFalse(ias.Eq(ids));
        }
Esempio n. 2
0
        public void Test()
        {
            var bytes   = new byte[] { 3, 4, 5, 6 };
            var byteSeg = new ArraySegment <byte>(bytes, 1, 2);

            const string thisIsATest = "this is a test \u3333 \x22";
            const double d           = 1.2345e-200;
            const float  f           = 1.2345e22f;
            const ulong  ul          = 0xddddccccbbbbaaaaL;
            const long   l           = 0x4dddcc3cbb2baa1aL;

            var bb = new ByteBuffer(4);

            for (var i = 0; i < 4; ++i)
            {
                Console.WriteLine(i);
                var startingPos = ByteBuffer.StartWritePacket(bb);
                ByteBuffer.WriteUlong(bb, ul);
                ByteBuffer.WriteUshort(bb, 2345);
                ByteBuffer.WriteBool(bb, true);
                ByteBuffer.WriteLong(bb, l);
                ByteBuffer.WriteBool(bb, false);
                ByteBuffer.WriteByte(bb, 0x44);
                ByteBuffer.WriteDouble(bb, d);
                ByteBuffer.WriteFloat(bb, f);
                ByteBuffer.WriteInt(bb, 45);
                ByteBuffer.WriteUint(bb, 33);
                ByteBuffer.WriteBytes(bb, bytes);
                ByteBuffer.WriteBytes(bb, byteSeg);
                ByteBuffer.WriteString(bb, thisIsATest);
                ByteBuffer.WriteString(bb, null);
                ByteBuffer.WriteUlong(bb, 0xFDECBA9876543210L);
                ByteBuffer.WriteInt(bb, 0); // not read by reader
                ByteBuffer.EndWritePacket(bb, startingPos, 0);

                var startingPos1 = ByteBuffer.StartWritePacket(bb);
                ByteBuffer.WriteInt(bb, 55);
                ByteBuffer.EndWritePacket(bb, startingPos1, 0);

                Assert.IsFalse(ByteBuffer.TryReadPacket(bb, r => { }, 0));

                ByteBuffer.WriteCommit(bb);

                Assert.IsTrue(ByteBuffer.TryReadPacket(bb, r =>
                {
                    Assert.AreEqual(ul, ByteBuffer.ReadUlong(r));
                    Assert.AreEqual(2345, ByteBuffer.ReadUshort(r));
                    Assert.AreEqual(true, ByteBuffer.ReadBool(r));
                    Assert.AreEqual(l, ByteBuffer.ReadLong(r));
                    Assert.AreEqual(false, ByteBuffer.ReadBool(r));
                    Assert.AreEqual(0x44, ByteBuffer.ReadByte(r));
                    Assert.AreEqual(d, ByteBuffer.ReadDouble(r));
                    Assert.AreEqual(f, ByteBuffer.ReadFloat(r));
                    Assert.AreEqual(45, ByteBuffer.ReadInt(r));
                    Assert.AreEqual(33, ByteBuffer.ReadUint(r));
                    var readBytes = ByteBuffer.ReadBytes(r);
                    Assert.IsTrue(bytes.Eq(readBytes));
                    readBytes = ByteBuffer.ReadBytes(r);
                    Assert.IsTrue(byteSeg.Eq(readBytes));
                    var readString = ByteBuffer.ReadString(r);
                    Assert.AreEqual(thisIsATest, readString);
                    Assert.IsNull(ByteBuffer.ReadString(r));
                    Assert.AreEqual(0xFDECBA9876543210L, ByteBuffer.ReadUlong(r));
                },
                                                       0));

                var rp = bb.ReadPosition;
                Assert.Greater(rp, 0);
                ByteBuffer.ReadCommit(bb);
                Assert.Greater(bb.WriteCommitPosition, 0);
                Assert.AreEqual(0, bb.ReadPosition);
                ByteBuffer.ReadCommit(bb);

                Assert.IsTrue(ByteBuffer.TryReadPacket(bb, r => { Assert.AreEqual(55, ByteBuffer.ReadInt(r)); }, 0));

                ByteBuffer.ReadCommit(bb);
                Assert.AreEqual(0, bb.ReadPosition);
                Assert.AreEqual(0, bb.WritePosition);
                Assert.AreEqual(0, bb.WriteCommitPosition);

                var x = ByteBuffer.StartWritePacket(bb);
                ByteBuffer.WriteUlong(bb, 0xddddccccbbbbaaaaL);
                ByteBuffer.WriteString(bb, thisIsATest);
                ByteBuffer.WriteInt(bb, 45);
                ByteBuffer.WriteUint(bb, 33);
                ByteBuffer.WriteUlong(bb, 0xFDECBA9876543210L);
                ByteBuffer.WriteInt(bb, 0); // not read by reader
                ByteBuffer.EndWritePacket(bb, x, 0);
                ByteBuffer.WriteCommit(bb);
                int ep;
                ByteBuffer.StartTryReadPacket(bb, out ep, 0);
                Assert.AreEqual(0xddddccccbbbbaaaaL, ByteBuffer.ReadUlong(bb));
                Assert.AreEqual(thisIsATest, ByteBuffer.ReadString(bb));
                Assert.AreEqual(45, ByteBuffer.ReadInt(bb));
                Assert.AreEqual(33, ByteBuffer.ReadUint(bb));
                Assert.AreEqual(0xFDECBA9876543210L, ByteBuffer.ReadUlong(bb));
                ByteBuffer.EndReadPacket(bb, ep);

                ByteBuffer.ReadCommit(bb);
                Assert.AreEqual(0, bb.ReadPosition);
                Assert.AreEqual(0, bb.WritePosition);
                Assert.AreEqual(0, bb.WriteCommitPosition);
            }
        }
Esempio n. 3
0
 public static bool Eq <T>(this ArraySegment <T> sa, T[] sb)
 {
     return(sa.Eq(sb, EqualityComparer <T> .Default));
 }