Esempio n. 1
0
        public void CalculatorAddition_WithMultipleCharacterCustomDelimiter_SumsCorrectly()
        {
            // Arrange
            var inputString = "//[***]\n11***22***33";
            int expected    = 66;

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.NumberOutput);
        }
Esempio n. 2
0
        public void CalculatorAddition_WithMultipleCustomDelimitersInvalidNumber_SumsCorrectly()
        {
            // Arrange
            var inputString = "//[*][!!][rrr]\n11rrr22,tytyt,*33!!44";
            int expected    = 110;

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.NumberOutput);
        }
Esempio n. 3
0
        public void CalculatorAddition_WithSingleCharacterCustomDelimiter_SumsCorrectly()
        {
            // Arrange
            var inputString = "//;\n2;5";
            int expected    = 7;

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.NumberOutput);
        }
Esempio n. 4
0
        public void CalculatorAddition_With3ValidInputsAndNewline_SumsCorrectly()
        {
            // Arrange
            var inputString = "1\n2,3";
            int expected    = 6;

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.NumberOutput);
        }
Esempio n. 5
0
        public void CalculatorAddition_IgnoreGreaterThan1000_SumsCorrectly()
        {
            // Arrange
            var inputString = "2,1001,6 ";
            int expected    = 8;

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.NumberOutput);
        }
Esempio n. 6
0
        public void CalculatorAddition_WithMultipleValidInvalidInputs_SumsCorrectly()
        {
            // Arrange
            var inputString = "1,tytyt,3";
            int expected    = 4;

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.NumberOutput);
        }
Esempio n. 7
0
        public void CalculatorAddition_WithMultipleCustomDelimitersInvalidNumber_FormulaCorrect()
        {
            // Arrange
            var    inputString = "//[*][!!][rrr]\n11rrr22,tytyt,*33!!44";
            string expected    = "11+22+0+33+44 = 110";

            // Act
            CalcDataTransfer calcDataTransfer = calculator.Run(inputString);

            // Assert
            Assert.AreEqual(expected, calcDataTransfer.Formula);
        }
Esempio n. 8
0
        public void SeperateValues_WithMultipleCharacterCustomDelimiter_StoresCorrectly()
        {
            // Arrange
            string     inputValues = "//[*][!!][rrr]\n11rrr22*33!!44";
            List <int> expected    = new List <int> {
                11, 22, 33, 44
            };

            // Act
            CalcDataTransfer calcDataTransfer = inputProcessor.SeperateValues(inputValues);

            // Assert
            CollectionAssert.AreEquivalent(expected, (List <int>)calcDataTransfer.NumbersInput);
        }
Esempio n. 9
0
        public void SeperateValues_With2ValidInputsAndNewline_StoresCorrectly()
        {
            // Arrange
            string     inputValues = "1\n2";
            List <int> expected    = new List <int> {
                1, 2
            };

            // Act
            CalcDataTransfer calcDataTransfer = inputProcessor.SeperateValues(inputValues);

            // Assert
            CollectionAssert.AreEquivalent(expected, (List <int>)calcDataTransfer.NumbersInput);
        }
Esempio n. 10
0
        public void SeperateValues_WithEmptyStringInput_Returns0()
        {
            // Arrange
            string     inputValues = "";
            List <int> expected    = new List <int> {
                0
            };

            // Act
            CalcDataTransfer calcDataTransfer = inputProcessor.SeperateValues(inputValues);

            // Assert
            CollectionAssert.AreEquivalent(expected, (List <int>)calcDataTransfer.NumbersInput);
        }
Esempio n. 11
0
        public void SeperateValues_WithInValidInteger_Stores0()
        {
            // Arrange
            string     inputValues = "tytyt";
            List <int> expected    = new List <int> {
                0
            };

            // Act
            CalcDataTransfer calcDataTransfer = inputProcessor.SeperateValues(inputValues);

            // Assert
            CollectionAssert.AreEquivalent(expected, (List <int>)calcDataTransfer.NumbersInput);
        }
Esempio n. 12
0
        public void Addition_WithMissingInput_Returns0()
        {
            // Arrange
            CalcDataTransfer calcDataTransfer = new CalcDataTransfer();

            calcDataTransfer.NumbersInput = new List <int> {
            };

            int expected = 0;

            // Act
            var result = calculator.MathOperation(calcDataTransfer);

            // Assert
            Assert.AreEqual(expected, result);
        }
Esempio n. 13
0
        public void CreateFormula_WithNoNumbers_OutputsFormula()
        {
            // Arrange
            Calculator       calculator       = new Calculator();
            CalcDataTransfer calcDataTransfer = new CalcDataTransfer();

            calcDataTransfer.NumbersInput = new List <int> {
            };
            calcDataTransfer.NumberOutput = 0;
            string expected = " = 0";

            // Act
            var result = calculator.CreateFormula(calcDataTransfer);

            // Assert
            Assert.AreEqual(expected, result);
        }
Esempio n. 14
0
        public void Addition_With1ValidInput_SumsCorrectly()
        {
            // Arrange
            CalcDataTransfer calcDataTransfer = new CalcDataTransfer();

            calcDataTransfer.NumbersInput = new List <int> {
                20
            };

            int expected = 20;

            // Act
            var result = calculator.MathOperation(calcDataTransfer);

            // Assert
            Assert.AreEqual(expected, result);
        }
Esempio n. 15
0
        public void Addition_WithNumerousValidInputs_SumsCorrectly()
        {
            // Arrange
            CalcDataTransfer calcDataTransfer = new CalcDataTransfer();

            calcDataTransfer.NumbersInput = new List <int> {
                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
            };

            int expected = 78;

            // Act
            var result = calculator.MathOperation(calcDataTransfer);

            // Assert
            Assert.AreEqual(expected, result);
        }
Esempio n. 16
0
        public void FindCustomDelimiter_With2CharacterCustomDelimiter_ReturnsNoDelimiterAndCompleteInputString()
        {
            // Arrange
            CalcDataTransfer calcDataTransfer = new CalcDataTransfer();

            calcDataTransfer.InputString = "//;:\n2;5";

            List <string> expected = new List <string> {
            };
            string searchText      = "//;:\n2;5";

            // Act
            var result = inputProcessor.FindCustomDelimiterSearchText(calcDataTransfer);

            // Assert
            CollectionAssert.AreEquivalent(expected, (List <string>)result.Delimiters);
            Assert.AreEqual(searchText, result.SearchString);
        }
Esempio n. 17
0
        public void FindCustomDelimiter_WithMultipleCustomDelimiters_ReturnsDelimitersAndSearchText()
        {
            // Arrange
            CalcDataTransfer calcDataTransfer = new CalcDataTransfer();

            calcDataTransfer.InputString = "//[*][!!][rrr]\n11rrr22*33!!44";

            List <string> expected = new List <string> {
                "*", "!!", "rrr"
            };
            string searchText = "11rrr22*33!!44";

            // Act
            var result = inputProcessor.FindCustomDelimiterSearchText(calcDataTransfer);

            // Assert
            CollectionAssert.AreEquivalent(expected, (List <string>)result.Delimiters);
            Assert.AreEqual(searchText, result.SearchString);
        }