Exemple #1
0
        public void CannotPeekEmpty_Peek_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            //  Assert
            Assert.Throws <NutmegException>(() => stack.Peek());
        }
Exemple #2
0
        public void StartsEmpty_IsEmpty_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();
            //  Act
            var isEmpty = stack.IsEmpty();

            //  Assert
            Assert.True(isEmpty);
        }
Exemple #3
0
        public void CannotPopEmptyLocked_Pop_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            stack.Push("p");
            stack.Push("q");
            stack.Lock();            //  Assert
            Assert.Throws <NutmegException>(() => stack.Pop());
        }
Exemple #4
0
        //public void Lock( int n ) {
        //    this.EnsureRoom( n );
        //    this.dump.Push( this.layer );
        //    this.layer = this.top;
        //    Array.Fill( this.items, default( T ), this.top, n );
        //    this.top += n;
        //}

        public int RawLock(int nlocals, CheckedLayeredStack <T> src)
        {
            this.EnsureRoom(nlocals);
            this.Lock();
            var nargs = src.RawSend(this);

            Array.Fill(this.items, default(T), this.top + nargs, nlocals - nargs);
            this.top += nlocals;
            return(nargs);
        }
Exemple #5
0
        public void CanPeekOrElseEmpty_PeekOrElse_Test()
        {
            //  Arrange
            var stack     = new CheckedLayeredStack <string>();
            var arbitrary = "foobar";
            //  Act
            var x = stack.PeekOrElse(orElse: arbitrary);
            var y = stack.PeekItemOrElse(0, orElse: arbitrary);

            //  Assert
            Assert.Equal(arbitrary, x);
            Assert.Equal(arbitrary, y);
        }
Exemple #6
0
        public void CanUnlock_Unlock_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            stack.Push("p");
            stack.Push("q");
            stack.Lock();
            //  Act
            stack.Unlock();
            //  Assert
            Assert.Equal(0, stack.LockCount());
            Assert.Equal(2, stack.Size());
        }
Exemple #7
0
        public void Simple_PeekAndPeekItem_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            //  Act
            stack.Push("a");
            stack.Push("b");
            var b = stack.Peek();
            var a = stack.PeekItem(1);

            //  Assert
            Assert.Equal("b", b);
            Assert.Equal("a", a);
        }
Exemple #8
0
        public void StartsEmptyLocked_IsEmpty_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            stack.Push("p");
            stack.Push("q");
            stack.Lock();
            //  Act
            var isEmpty = stack.IsEmpty();
            var k       = stack.LockCount();

            //  Assert
            Assert.True(isEmpty);
            Assert.Equal(1, k);
        }
Exemple #9
0
        public void SimplePop_Pop_Test()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            stack.Push("a");
            stack.Push("b");
            //  Act
            var b = stack.Pop();
            var a = stack.Pop();

            //  Assert
            Assert.True(stack.IsEmpty());
            Assert.Equal(0, stack.Size());
            Assert.Equal("b", b);
            Assert.Equal("a", a);
        }
Exemple #10
0
        public void UncheckedLayeredStack()
        {
            //  Arrange
            var stack = new CheckedLayeredStack <string>();

            //  Act
            stack.Lock();
            //  Assert
            Assert.True(stack.IsEmpty());
            Assert.Equal(1, stack.LockCount());
            //  Act
            stack.Unlock();
            //  Assert
            Assert.True(stack.IsEmpty());
            Assert.Equal(0, stack.LockCount());
            //  Assert
            Assert.Throws <NutmegException>(() => stack.Unlock());
        }
Exemple #11
0
        public void Simple_RawLock_Test()
        {
            //  Arrange
            var vstack = new CheckedLayeredStack <string>();

            vstack.Lock();
            vstack.Push("a");
            vstack.Push("b");
            var cstack = new UncheckedLayeredStack <string>();

            //  Act
            cstack.RawLock(4, vstack);
            //  Assert
            Assert.Equal(1, vstack.LockCount());
            Assert.Equal(0, vstack.Size());
            Assert.Equal(1, cstack.LockCount());
            Assert.Equal(4, cstack.Size());
            Assert.Equal("a", cstack[0]);
            Assert.Equal("b", cstack[1]);
            Assert.Null(cstack[2]);
            Assert.Null(cstack[3]);
        }