Ejemplo n.º 1
0
        public void EnsureAvailableSpaceTest()
        {
            MultiArrayBuffer buffer = new MultiArrayBuffer(0);

            Assert.Equal(0, buffer.ActiveMemory.Length);
            Assert.Equal(0, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(0);
            Assert.Equal(0, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(1);
            Assert.Equal(BlockSize, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(2);
            Assert.Equal(BlockSize, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(BlockSize - 1);
            Assert.Equal(BlockSize, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(BlockSize);
            Assert.Equal(BlockSize, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(BlockSize + 1);
            Assert.Equal(BlockSize * 2, buffer.AvailableMemory.Length);

            buffer.Commit(BlockSize - 1);
            Assert.Equal(BlockSize - 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize + 1, buffer.AvailableMemory.Length);

            buffer.Commit(BlockSize);
            Assert.Equal(BlockSize * 2 - 1, buffer.ActiveMemory.Length);
            Assert.Equal(1, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(0);
            Assert.Equal(1, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(1);
            Assert.Equal(1, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(2);
            Assert.Equal(BlockSize + 1, buffer.AvailableMemory.Length);

            buffer.Commit(2);
            Assert.Equal(BlockSize * 2 + 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 1, buffer.AvailableMemory.Length);

            buffer.Discard(1);
            Assert.Equal(BlockSize * 2, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 1, buffer.AvailableMemory.Length);

            buffer.Discard(1);
            Assert.Equal(BlockSize * 2 - 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 1, buffer.AvailableMemory.Length);

            // This should not free the first block
            buffer.Discard(BlockSize - 3);
            Assert.Equal(BlockSize + 2, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 1, buffer.AvailableMemory.Length);

            // This should free the first block
            buffer.Discard(1);
            Assert.Equal(BlockSize + 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 1, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(BlockSize - 1);
            Assert.Equal(BlockSize - 1, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(BlockSize);
            Assert.Equal(BlockSize * 2 - 1, buffer.AvailableMemory.Length);

            buffer.Discard(BlockSize - 1);
            Assert.Equal(2, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 2 - 1, buffer.AvailableMemory.Length);

            // This will cause shifting the block array down, but not reallocating
            buffer.EnsureAvailableSpace(BlockSize * 2);
            Assert.Equal(BlockSize * 3 - 1, buffer.AvailableMemory.Length);

            buffer.Commit(BlockSize - 2);
            Assert.Equal(BlockSize, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 2 + 1, buffer.AvailableMemory.Length);

            buffer.Commit(1);
            Assert.Equal(BlockSize + 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 2, buffer.AvailableMemory.Length);

            buffer.Commit(1);
            Assert.Equal(BlockSize + 2, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 2 - 1, buffer.AvailableMemory.Length);

            buffer.Discard(1);
            Assert.Equal(BlockSize + 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 2 - 1, buffer.AvailableMemory.Length);

            // This will cause reallocating the block array, and dealing with an unused block in the first slot
            buffer.EnsureAvailableSpace(BlockSize * 4);
            Assert.Equal(BlockSize + 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 5 - 1, buffer.AvailableMemory.Length);

            buffer.Discard(2);
            Assert.Equal(BlockSize - 1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 5 - 1, buffer.AvailableMemory.Length);

            buffer.Commit(1);
            Assert.Equal(BlockSize, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 5 - 2, buffer.AvailableMemory.Length);

            // This will discard all active bytes, which will reset the buffer
            buffer.Discard(BlockSize);
            Assert.Equal(0, buffer.ActiveMemory.Length);
            Assert.Equal(0, buffer.AvailableMemory.Length);

            buffer.EnsureAvailableSpace(2);
            buffer.Commit(2);
            Assert.Equal(2, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 2, buffer.AvailableMemory.Length);

            buffer.Discard(1);
            Assert.Equal(1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize - 2, buffer.AvailableMemory.Length);

            // Request a very large amount of available space.
            buffer.EnsureAvailableSpace(BlockSize * 64 + 1);
            Assert.Equal(1, buffer.ActiveMemory.Length);
            Assert.Equal(BlockSize * 65 - 2, buffer.AvailableMemory.Length);

            buffer.DiscardAll();
            Assert.Equal(0, buffer.ActiveMemory.Length);
            Assert.Equal(0, buffer.AvailableMemory.Length);
        }