public void Given_TheDataContainsTheWrongVector_When_ParseIsCalled_Then_NullIsReturned()
        {
            List <byte> bytes         = new List <byte>();
            int         universeCount = 5;
            byte        length        = (byte)(UniverseDiscoveryLayer.MinLength + (universeCount << 1));

            bytes.AddRange(new byte[] { 0x7 << 4, (length) });             // flags and length
            UInt32 expectedVector = 250;

            bytes.AddRange(new byte[] { 0, 0, 0, (byte)expectedVector });             // Vector

            byte page = 27;

            bytes.Add(page);
            byte lastPage = 28;

            bytes.Add(lastPage);

            var expectedUniverses = new UInt16[]
            {
                1,
                2,
                3,
                4,
                5
            };

            foreach (var expectedUniverse in expectedUniverses)
            {
                bytes.Add(0);
                bytes.Add((byte)expectedUniverse);
            }

            Assert.Null(UniverseDiscoveryLayer.Parse(bytes.ToArray()));
        }
Beispiel #2
0
        public static Span <byte> GetUniverseDiscoveryPacket(byte[] CID, string sourceName, byte page, byte lastPage, UInt16[] universes)
        {
            var rootLayer = new RootLayer
            {
                CID    = CID,
                Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
            };

            var framingLayer = new UniverseDiscoveryPacketFramingLayer
            {
                SourceName = sourceName
            };

            var universeDiscoveryLayer = new UniverseDiscoveryLayer
            {
                Page      = page,
                LastPage  = lastPage,
                Universes = universes
            };


            int totalLength = RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length + universeDiscoveryLayer.Length;

            using var owner = MemoryPool <byte> .Shared.Rent(totalLength);

            var bytes = owner.Memory.Span.Slice(0, totalLength);

            rootLayer.Write(bytes, (UInt16)(SynchronizationPacketFramingLayer.Length + universeDiscoveryLayer.Length));
            framingLayer.Write(bytes.Slice(RootLayer.Length), universeDiscoveryLayer.Length);
            universeDiscoveryLayer.Write(bytes.Slice(RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length));

            return(bytes);
        }
 public UniverseDiscoveryPacket()
 {
     RootLayer = new RootLayer
     {
         Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
     };
     FramingLayer           = new UniverseDiscoveryPacketFramingLayer();
     UniverseDiscoveryLayer = new UniverseDiscoveryLayer();
 }
        public void Given_TheDataIsCorrect_When_ParseIsCalled_Then_TheDataIsParsedAsExpected()
        {
            byte page     = 27;
            byte lastPage = 28;

            var expectedUniverses = Enumerable.Range(byte.MaxValue, 1023)
                                    .Select(x => (UInt16)x)
                                    .ToArray();

            var bytes = GetUniverseDiscoveryLayer(expectedUniverses, page, lastPage);

            var universeDiscoveryLayer = UniverseDiscoveryLayer.Parse(bytes.ToArray());

            Assert.Equal(UniverseDiscoveryLayerVector.VECTOR_UNIVERSE_DISCOVERY_UNIVERSE_LIST, universeDiscoveryLayer.Vector);
            Assert.Equal(page, universeDiscoveryLayer.Page);
            Assert.Equal(lastPage, universeDiscoveryLayer.LastPage);
            Assert.Equal(expectedUniverses, universeDiscoveryLayer.Universes);
        }
        public void Given_ThePacketIsAValidUniverseDiscoveryPacket_When_ParseIsCalled_Then_ThePacketIsParsedCorrectly()
        {
            byte[] CID       = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
            var    rootLayer = new RootLayer
            {
                CID    = CID,
                Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
            };

            string sourceName = "Source name";

            var framingLayer = new UniverseDiscoveryPacketFramingLayer
            {
                SourceName = sourceName
            };

            UInt16[] universes = Enumerable.Range(200, 1000)
                                 .Select(x => (UInt16)x)
                                 .ToArray();

            var discoveryLayer = new UniverseDiscoveryLayer
            {
                Universes = universes,
                Page      = 25,
                LastPage  = 25
            };

            int totalLength = discoveryLayer.Length + UniverseDiscoveryPacketFramingLayer.Length + RootLayer.Length;

            using var owner = MemoryPool <byte> .Shared.Rent(totalLength);

            var bytes = owner.Memory.Span.Slice(0, totalLength);

            rootLayer.Write(bytes, (UInt16)(UniverseDiscoveryPacketFramingLayer.Length + discoveryLayer.Length));
            framingLayer.Write(bytes.Slice(RootLayer.Length), discoveryLayer.Length);
            discoveryLayer.Write(bytes.Slice(RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length));

            var packet = SacnPacket.Parse(bytes);

            Assert.NotNull(packet);
            Assert.IsType <UniverseDiscoveryPacket>(packet);
        }
        public void When_WriteIsCalled_Then_TheDataIsCorrect()
        {
            var universes = Enumerable.Range(byte.MaxValue, byte.MaxValue + 1023)
                            .Select(x => (UInt16)x)
                            .ToArray();
            byte page          = 36;
            byte lastPage      = 230;
            var  expectedBytes = GetUniverseDiscoveryLayer(universes, page, lastPage);

            var universeDiscoveryLayer = new UniverseDiscoveryLayer()
            {
                Universes = universes,
                Page      = page,
                LastPage  = lastPage
            };

            using var owner = MemoryPool <byte> .Shared.Rent(UniverseDiscoveryLayer.MinLength + (universes.Length << 1));

            var actualBytes = owner.Memory.Span.Slice(0, UniverseDiscoveryLayer.MinLength + (universes.Length << 1));

            universeDiscoveryLayer.Write(actualBytes);
            Assert.Equal(expectedBytes, actualBytes.ToArray());
        }