tests/DotPulsar.Tests/Internal/SequenceBuilderTests.cs

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace DotPulsar.Tests.Internal
{
    using DotPulsar.Internal;
    using FluentAssertions;
    using System.Buffers;
    using System.Linq;
    using Xunit;

    public class SequenceBuilderTests
    {
        [Fact]
        public void Append_GivenMultipleArrayInputs_ShouldArrangeInCorrectOrder()
        {
            //Arrange
            var a = new byte[] { 0x00, 0x01, 0x02, 0x03 };
            var b = new byte[] { 0x04, 0x05, 0x06, 0x07, 0x08 };
            var c = new byte[] { 0x09 };

            var builder = new SequenceBuilder<byte>().Append(a).Append(b).Append(c);

            //Act
            var actual = builder.Build().ToArray();

            //Assert
            var expected = Enumerable.Range(0, 10).ToArray();
            actual.Should().Equal(expected);
        }

        [Fact]
        public void Append_GivenMultipleArrayAndSequenceInputs_ShouldArrangeInCorrectOrder()
        {
            //Arrange
            var a = new byte[] { 0x00, 0x01 };
            var b = new byte[] { 0x02, 0x03 };
            var c = new byte[] { 0x04, 0x05 };
            var d = new byte[] { 0x06, 0x07 };
            var e = new byte[] { 0x08, 0x09 };

            var seq = new SequenceBuilder<byte>().Append(b).Append(c).Append(d).Build();
            var builder = new SequenceBuilder<byte>().Append(a).Append(seq).Append(e);

            //Act
            var actual = builder.Build().ToArray();

            //Assert
            var expected = Enumerable.Range(0, 10).ToArray();
            actual.Should().Equal(expected);
        }

        [Fact]
        public void Prepend_GivenMultipleArrayInputs_ShouldArrangeInCorrectOrder()
        {
            //Arrange
            var a = new byte[] { 0x00, 0x01, 0x02, 0x03 };
            var b = new byte[] { 0x04, 0x05, 0x06, 0x07, 0x08 };
            var c = new byte[] { 0x09 };

            var builder = new SequenceBuilder<byte>().Prepend(c).Prepend(b).Prepend(a);

            //Act
            var actual = builder.Build().ToArray();

            //Assert
            var expected = Enumerable.Range(0, 10).ToArray();
            actual.Should().Equal(expected);
        }

        [Fact]
        public void Prepend_GivenMultipleArrayAndSequenceInputs_ShouldArrangeInCorrectOrder()
        {
            //Arrange
            var a = new byte[] { 0x00, 0x01 };
            var b = new byte[] { 0x02, 0x03 };
            var c = new byte[] { 0x04, 0x05 };
            var d = new byte[] { 0x06, 0x07 };
            var e = new byte[] { 0x08, 0x09 };

            var seq = new SequenceBuilder<byte>().Prepend(d).Prepend(c).Prepend(b).Build();
            var builder = new SequenceBuilder<byte>().Prepend(e).Prepend(seq).Prepend(a);

            //Act
            var actual = builder.Build().ToArray();

            //Assert
            var expected = Enumerable.Range(0, 10).ToArray();
            actual.Should().Equal(expected);
        }

        [Fact]
        public void Build_GivenMultipleInvocations_ShouldCreateIdenticalSequences()
        {
            //Arrange
            var a = new byte[] { 0x00, 0x01 };
            var b = new byte[] { 0x02, 0x03 };

            var builder = new SequenceBuilder<byte>().Append(a).Append(b);

            //Act
            var actual1 = builder.Build().ToArray();
            var actual2 = builder.Build().ToArray();

            //Assert
            var expected = Enumerable.Range(0, 4).ToArray();
            actual1.Should().Equal(expected);
            actual2.Should().Equal(expected);
        }
    }
}