Ejemplo n.º 1
0
        public void Equals_DiffrentValuesMustReturnFalse_Test()
        {
            //Arrange
            var equality = IntEqualityByLiteral.Build();
            //Act
            bool actual = equality.Equals(3, 4);

            //Assert
            Assert.IsFalse(actual);
        }
Ejemplo n.º 2
0
        public void Equals_SameValueMustReturnTrue_Test()
        {
            //Arrange
            var equality = IntEqualityByLiteral.Build();
            //Act
            bool actual = equality.Equals(4, 4);

            //Assert
            Assert.IsTrue(actual);
        }
Ejemplo n.º 3
0
        public void Equals_NumberIsEqualToItself_Test()
        {
            //Arrange
            var    equality            = IntEqualityByLiteral.Build();
            Random random              = new Random();
            int    numberEqualToItself = random.Next(int.MinValue, int.MaxValue);
            //Act
            bool actual = equality.Equals(numberEqualToItself, numberEqualToItself);

            //Assert
            Assert.IsTrue(actual);
        }
Ejemplo n.º 4
0
        public void SameDice_DiffrentIdMustReturnFalse_Test()
        {
            //Arrange
            var someDice = Dice <int> .Build(0, 6, 5, false);

            var equalityOperation = IntEqualityByLiteral.Build();
            //Act
            bool actual = someDice.SameDice(1, equalityOperation);

            //Assert
            Assert.IsFalse(actual);
        }
Ejemplo n.º 5
0
        public void SameDice_SameIdMustReturnTrue_Test()
        {
            //Arrange
            var someDice = Dice <int> .Build(0, 6, 5, false);

            var  equalityOperation = IntEqualityByLiteral.Build();
            bool actual            = true;

            //Act
            actual = someDice.SameDice(0, equalityOperation);
            //Assert
            Assert.IsTrue(actual);
        }
        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);
        }
Ejemplo n.º 7
0
        public void Equals_PostiveIsNotZero_Test()
        {
            //Arrange
            var    equality     = IntEqualityByLiteral.Build();
            Random random       = new Random();
            int    firstNumber  = 0;
            int    secondNumber = random.Next(firstNumber, 100000);

            //Act
            bool actual = equality.Equals(firstNumber, secondNumber);

            //Assert
            Assert.IsFalse(actual);
        }
Ejemplo n.º 8
0
        public void Equals_ZeroIsNotNegative_Test()
        {
            //Arrange
            var    equality    = IntEqualityByLiteral.Build();
            Random random      = new Random();
            int    firstNumber = 0;

            int secondNumber = random.Next(int.MinValue, -1);
            //Act
            bool actual = equality.Equals(firstNumber, secondNumber);

            //Assert
            Assert.IsFalse(actual);
        }
        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);
        }