コード例 #1
0
        public void Test_AppendBytes_Resize_Buffer()
        {
            // check buffer resize occurs as intended
            var original = new byte[32];
            var writer   = new SliceWriter(original);

            Assert.That(writer.Buffer, Is.SameAs(original));

            // first write should not resize the buffer
            var aaa = writer.AppendBytes(Slice.Repeat((byte)'a', 24));

            Assert.That(aaa.Array, Is.SameAs(original));

            // second write should resize the buffer
            var bbb = writer.AppendBytes(Slice.Repeat((byte)'b', 24));

            Assert.That(bbb.Array, Is.SameAs(writer.Buffer));
            //note: buffer should have been copied between both calls, so 'aaa' should point to the OLD buffer
            Assert.That(bbb.Array, Is.Not.SameAs(original));
            //but the content should be unchanged
            Assert.That(writer.ToSlice().ToStringAscii(), Is.EqualTo("aaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbb"));
            // => mutating aaa should not change the buffer
            aaa.Array[aaa.Offset] = (byte)'Z';
            Assert.That(writer.ToSlice().ToStringAscii(), Is.EqualTo("aaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbb"));
            // => but mutating bbb should change the buffer
            bbb.Array[bbb.Offset] = (byte)'Z';
            Assert.That(writer.ToSlice().ToStringAscii(), Is.EqualTo("aaaaaaaaaaaaaaaaaaaaaaaaZbbbbbbbbbbbbbbbbbbbbbbb"));
        }
コード例 #2
0
        public void Test_AppendBytes()
        {
            var writer = new SliceWriter(64);
            var slice  = writer.AppendBytes(Slice.Empty);

            //note: slice.Array is not guaranteed to be equal to writer.Buffer
            Assert.That(slice.Offset, Is.EqualTo(0));
            Assert.That(slice.Count, Is.EqualTo(0));

            slice = writer.AppendBytes(Slice.FromString("hello world!"));
            Assert.That(slice.Array, Is.SameAs(writer.Buffer));
            Assert.That(slice.Offset, Is.EqualTo(0));
            Assert.That(slice.Count, Is.EqualTo(12));
            Assert.That(slice.ToStringUtf8(), Is.EqualTo("hello world!"));
            Assert.That(writer.ToSlice().ToStringUtf8(), Is.EqualTo("hello world!"));

            var foo = Slice.FromString("foo");

            slice = writer.AppendBytes(foo);
            Assert.That(slice.Array, Is.SameAs(writer.Buffer));
            Assert.That(slice.Offset, Is.EqualTo(12));
            Assert.That(slice.Count, Is.EqualTo(3));
            Assert.That(slice.ToStringUtf8(), Is.EqualTo("foo"));
            Assert.That(writer.ToSlice().ToStringUtf8(), Is.EqualTo("hello world!foo"));

            var bar = Slice.FromString("bar");

            unsafe
            {
                fixed(byte *ptr = &bar.DangerousGetPinnableReference())
                {
                    slice = writer.AppendBytes(ptr, 3);
                }
            }
            Assert.That(slice.Array, Is.SameAs(writer.Buffer));
            Assert.That(slice.Offset, Is.EqualTo(15));
            Assert.That(slice.Count, Is.EqualTo(3));
            Assert.That(slice.ToStringUtf8(), Is.EqualTo("bar"));
            Assert.That(writer.ToSlice().ToStringUtf8(), Is.EqualTo("hello world!foobar"));

            var baz = Slice.FromString("baz");

            unsafe
            {
                fixed(byte *ptr = &baz.DangerousGetPinnableReference())
                {
                    //TODO: this test was using ReadOnlySpan<byte>, update it once we enable support for these!
                    slice = writer.AppendBytes(ptr, 3);
                }
            }
            Assert.That(slice.Array, Is.SameAs(writer.Buffer));
            Assert.That(slice.Offset, Is.EqualTo(18));
            Assert.That(slice.Count, Is.EqualTo(3));
            Assert.That(slice.ToStringUtf8(), Is.EqualTo("baz"));
            Assert.That(writer.ToSlice().ToStringUtf8(), Is.EqualTo("hello world!foobarbaz"));

            unsafe
            {
                slice = writer.AppendBytes(null, 0);
            }
            //note: slice.Array is not guaranteed to be equal to writer.Buffer
            Assert.That(slice.Offset, Is.EqualTo(0));             //REVIEW: should we return (Buffer, Position, 0) instead of (EmptyArray, 0, 0) ?
            Assert.That(slice.Count, Is.EqualTo(0));
        }