public void EnqueueAndDequeue()
            {
                var         q = BankersQueue.Empty <int>();
                Maybe <int> m;

                q = q.Enqueue(1);
                q = q.Enqueue(2);
                q = q.Enqueue(3);
                Expect.IsSome(1, q.Current);
                (q, m) = q.Dequeue();
                Expect.IsSome(1, m);
                Expect.IsSome(2, q.Current);
                (q, m) = q.Dequeue();
                Expect.IsSome(2, m);
                Expect.IsSome(3, q.Current);
                (q, m) = q.Dequeue();
                Expect.IsSome(3, m);
                Expect.IsNone(q.Current);
                q = q.Enqueue(4);
                q = q.Enqueue(5);
                Expect.IsSome(4, q.Current);
                (q, m) = q.Dequeue();
                Expect.IsSome(4, m);
                Expect.IsSome(5, q.Current);
                (q, m) = q.Dequeue();
                Expect.IsSome(5, m);
                Expect.IsNone(q.Current);
            }
        public void EmptyHeadTest()
        {
            var queue = BankersQueue <string> .Empty;
            var ex    = AssertThrows <ArgumentNullException>(() => BankersQueue <string> .Head(queue));

            Assert.AreEqual("Value cannot be null.\r\n" + "Parameter name: queue", ex.Message);
        }
        public void HeadTest()
        {
            const string data  = "One Two Three One Three";
            var          queue = data.Split().Aggregate(BankersQueue <string> .Empty, BankersQueue <string> .Snoc);
            var          item  = BankersQueue <string> .Head(queue);

            Assert.AreEqual("One", item);
        }
        public void SnocTest()
        {
            var queue = BankersQueue <string> .Snoc(BankersQueue <string> .Empty, "one");

            queue = BankersQueue <string> .Snoc(queue, "two");

            Assert.AreEqual("[1, {$one}, 1, {$two}]", DumpQueue(queue, true));
        }
        public void TailTest()
        {
            const string data  = "One Two Three One Three";
            var          queue = data.Split().Aggregate(BankersQueue <string> .Empty, BankersQueue <string> .Snoc);
            var          tail  = BankersQueue <string> .Tail(queue);

            Assert.AreEqual("[2, {$Two, $Three}, 2, {$Three, $One}]", DumpQueue(tail, true));
        }
        public void EmptyTest()
        {
            var queue = BankersQueue <string> .Empty;

            Assert.IsTrue(BankersQueue <string> .IsEmpty(queue));

            queue = BankersQueue <string> .Snoc(queue, "Item");

            Assert.IsFalse(BankersQueue <string> .IsEmpty(queue));

            queue = BankersQueue <string> .Tail(queue);

            Assert.IsTrue(BankersQueue <string> .IsEmpty(queue));
        }
        public void PushPopTest()
        {
            const string data  = "One Two Three One Three";
            var          queue = data.Split().Aggregate(BankersQueue <string> .Empty, BankersQueue <string> .Snoc);

            foreach (var expected in data.Split())
            {
                var actual = BankersQueue <string> .Head(queue);

                Assert.AreEqual(expected, actual);
                queue = BankersQueue <string> .Tail(queue);
            }

            Assert.IsTrue(BankersQueue <string> .IsEmpty(queue));
        }
        public void NullHeadTest()
        {
            var ex = AssertThrows <NullReferenceException>(() => BankersQueue <string> .Head(null));

            Assert.AreEqual("Object reference not set to an instance of an object.", ex.Message);
        }
 public void NullTest()
 {
     AssertThrows <NullReferenceException>(() => BankersQueue <string> .IsEmpty(null));
 }
 private static string DumpQueue <T>(BankersQueue <T> .Queue queue, bool expandUnCreated)
 {
     return($"[{queue.LenF}, {{{DumpStream(queue.F, expandUnCreated)}}}, {queue.LenR}, {{{DumpStream(queue.R, expandUnCreated)}}}]");
 }