コード例 #1
0
        public void Average(int[] numbers, double expectedAverage)
        {
            // Arrange
            ArraySolver arraySolver = new ArraySolver();

            // Act
            double actualAverage = arraySolver.Average(numbers);

            // Assert
            Assert.Equal(Math.Round(expectedAverage, 8), Math.Round(actualAverage, 8));
        }
コード例 #2
0
        public void ContainsTrue(bool[] values, bool expectedResult)
        {
            // Arrange
            ArraySolver arraySolver = new ArraySolver();

            // Act
            bool actualResult = arraySolver.ContainsTrue(values);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }
コード例 #3
0
        public void MakeElementsUppercase(string[] values, string[] expectedResult)
        {
            // Arrange
            ArraySolver arraySolver = new ArraySolver();

            // Act
            string[] actualResult = arraySolver.MakeElementsUppercase(values);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }
コード例 #4
0
        public void SumNegativeNumbers(int[] numbers, int expectedSum)
        {
            // Arrange
            ArraySolver arraySolver = new ArraySolver();

            // Act
            int actualSum = arraySolver.SumNegativeNumbers(numbers);

            // Assert
            Assert.Equal(expectedSum, actualSum);
        }
コード例 #5
0
        public void ContainsEven(int[] numbers, bool expectedResult)
        {
            // Arrange
            ArraySolver arraySolver = new ArraySolver();

            // Act
            bool actualResult = arraySolver.ContainsEven(numbers);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }
コード例 #6
0
        public void GetPositiveEvenNumbers(int maxNumber, int[] expectedResult)
        {
            // Arrange
            ArraySolver arraySolver = new ArraySolver();

            // Act
            int[] actualResult = arraySolver.GetPositiveEvenNumbers(maxNumber);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }
コード例 #7
0
        //[InlineData(new int[] { }, 0)]
        //[InlineData(null, 0)]
        public void AverageEvens(int[] numbers, double expected)
        {
            // Arrange
            var arraySolver = new ArraySolver();

            // Act
            double actual = arraySolver.AverageEvens(numbers);

            // Assert
            Assert.Equal(Math.Round(expected, 5), Math.Round(actual, 5));
        }
コード例 #8
0
        //[InlineData(new int[] { }, 0)]
        //[InlineData(null, 0)]
        public void SumEvens(int[] numbers, int expected)
        {
            // Arrange
            var arraySolver = new ArraySolver();

            // Act
            int actual = arraySolver.SumEvens(numbers);

            // Assert
            Assert.Equal(expected, actual);
        }
コード例 #9
0
        //[InlineData(new int[] { }, false)]
        //[InlineData(null, false)]
        public void IsSumOdd(int[] numbers, bool expected)
        {
            // Arrange
            var arraySolver = new ArraySolver();
            var numbersList = numbers == null ? null : new List <int>(numbers);

            // Act
            bool actual = arraySolver.IsSumOdd(numbersList);

            // Assert
            Assert.Equal(expected, actual);
        }
コード例 #10
0
        public void Solve_WhenGivenArrayIsNotWinnable_ReturnFalse(int[] input)
        {
            // Arrange
            int[]      numbers = input;
            bool       result;
            List <int> path = new List <int>();

            // Act
            result = ArraySolver.Solve(numbers, out path);

            // Assert
            Assert.AreEqual(result, false);
        }
コード例 #11
0
        public void Solve_WhenGivenArrayIsEmpty_ReturnFalse()
        {
            // Arrange
            int[]      numbers = new int[] { };
            bool       result;
            List <int> path = new List <int>();

            // Act
            result = ArraySolver.Solve(numbers, out path);

            // Assert
            Assert.AreEqual(result, false);
        }