public void AddMany_ZeroAmountMustNotThrow_Test()
        {
            //Arrange
            List <int>          list          = new List <int>();
            AmountOfItems <int> amountOfItems = ListBackedAmountOfItems <int> .Build(list);

            //Act
            amountOfItems.AddMany(int.MaxValue, 0);
            //Assert
        }
        public void Build_NullListMustThrow_Test()
        {
            //Arrange
            List <bool> nullList = null;

            //Act
            ListBackedAmountOfItems <bool> .Build(nullList);

            //Assert execption thrown
        }
Пример #3
0
        public void PointsFor_MustReturnSumOfAmountOfOnes_Test()
        {
            //Arrange
            var ace  = Aces.Build();
            var list = new List <int> {
                1, 2, 3, 4, 5, 6
            };
            var dice = ListBackedAmountOfItems <int> .Build(list);

            //Act
            //Assert
        }
        public void AddMany_NegativeAmountMustThrow_Test()
        {
            //Arrange
            List <string> list = new List <string> {
                "Apple", "Orange"
            };
            AmountOfItems <string> amountOfItems = ListBackedAmountOfItems <string> .Build(list);

            //Act
            amountOfItems.AddMany("", -1);
            //Assert execption thrown
        }
        public void AddOne_NullValueMustThrow_Test()
        {
            //Arrange
            List <string> list = new List <string> {
                "Apple", "Orange"
            };
            AmountOfItems <string> amountOfItems = ListBackedAmountOfItems <string> .Build(list);

            //Act
            amountOfItems.AddOne(null);
            //Asssert execption thrown
        }
        public void Build_NonNullListMustNotReturnNull_Test()
        {
            //Arrange
            List <string> list = new List <string> {
                "Apple", "Orange"
            };
            AmountOfItems <string> amountOfItems;

            //Act
            amountOfItems = ListBackedAmountOfItems <string> .Build(list);

            //Assert
            Assert.IsNotNull(amountOfItems);
        }
        public void AmountOf_BeforeAddReturns0_Test()
        {
            //Arrange
            List <int>          list          = new List <int>();
            AmountOfItems <int> amountOfItems = ListBackedAmountOfItems <int> .Build(list);

            var equalityOperation = IntEqualityByLiteral.Build();
            int expected          = 0;
            //Act
            int actual = amountOfItems.AmountOf(4, equalityOperation);

            //Assert
            Assert.AreEqual(expected, actual);
        }
Пример #8
0
        public void PointsFor_MustNotReturnNegative_Test()
        {
            //Arrange
            var ace  = Aces.Build();
            var list = new List <int> {
                2, 2, 2, 2, 2, 2, 2
            };
            var dice = ListBackedAmountOfItems <int> .Build(list);

            //Act
            int actual = ace.PointsFor(dice);

            //Assert
            Assert.IsTrue(actual >= 0);
        }
        public void AmountOf_IncreasesByOneWhenAddingOne_Test()
        {
            //Arrange
            int                 literalToAdd  = 0;
            List <int>          list          = new List <int>();
            AmountOfItems <int> amountOfItems = ListBackedAmountOfItems <int> .Build(list);

            var equalityOperation = IntEqualityByLiteral.Build();
            int expected          = 1;

            amountOfItems.AddOne(literalToAdd);
            //Act
            int after = amountOfItems.AmountOf(literalToAdd, equalityOperation);

            //Assert
            Assert.AreEqual(expected, after);
        }
        public void AmountOf_IncreasesByAmountWhenAddingMany_Test()
        {
            //Arrange
            int        literalToAdd  = 9;
            int        amount        = 10;
            List <int> list          = new List <int>();
            var        amountOfItems = ListBackedAmountOfItems <int> .Build(list);

            var equalityOperation = IntEqualityByLiteral.Build();
            int expected          = amount;

            amountOfItems.AddMany(literalToAdd, amount);
            int actual = 0;

            //Act
            actual = amountOfItems.AmountOf(9, equalityOperation);
            //Assert
            Assert.AreEqual(expected, actual);
        }