public void CalculateExpression_UncorrectAmountOfBrackets_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(IX+(XVII*IV))-(VII*IX)((("; romanCalculator.CalculateExpression(inputArithmeticExpression); }
public void RomanCalculator_SimpleExpressions_ShouldPass(string expression, string expectedRoman, int expectedArabic) { var actual = RomanCalculator.CalculateExpression(expression); Assert.Equal(expectedRoman, actual.Roman); Assert.Equal(expectedArabic, actual.Arabic); }
public void CalculateExpression_UncorrectRomanNumber_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(IX+F)"; romanCalculator.CalculateExpression(inputArithmeticExpression); }
public void CalculateExpression_IncorrectArgumentsCount_ArgumentExceptionThrown(string expression) { Assert.Throws(typeof(ArgumentException), () => { RomanCalculator.CalculateExpression(expression); }); }
public void RomanCalculator_FromExpression_NotNaturalResult_ShouldThrowInvalidOperation(string expression) { Assert.Throws(typeof(InvalidOperationException), () => { RomanCalculator.CalculateExpression(expression); }); }
public void RomanCalculator_IncorrectExpression_ShouldThrowInvalidData(string expression) { Assert.Throws(typeof(InvalidDataException), () => { RomanCalculator.CalculateExpression(expression); }); }
public void ToArabic_NullOrEmptyRomanNumber_ArgumentNullExceptionThrown(string romanNumber) { Assert.Throws(typeof(ArgumentNullException), () => { RomanCalculator.ToArabic(romanNumber); }); }
public void CalculateExpression_UncorrectArithmeticExpressionWithTerminalSign_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(V$2)"; romanCalculator.CalculateExpression(inputArithmeticExpression); }
public void Should_Return_3_For_III() { var expression = "III"; var calculator = new RomanCalculator(expression); Assert.AreEqual(3, calculator.Result()); }
public void CalculateExpression_IncorrectOperation_InvalidOperationExceptionThrown() { Assert.Throws(typeof(InvalidOperationException), () => { RomanCalculator.CalculateExpression("I / V"); }); }
public void Should_Return_5_For_V() { var expression = "V"; var calculator = new RomanCalculator(expression); Assert.AreEqual(5, calculator.Result()); }
public void Should_Return_10_For_X() { var expression = "X"; var calculator = new RomanCalculator(expression); Assert.AreEqual(10, calculator.Result()); }
public void CalculateExpression_ResultOfDivisionIsNotInteger_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(IX/IV)"; romanCalculator.CalculateExpression(inputArithmeticExpression); }
public void CalculateExpression_NotPositiveResultOfCalculation_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(IX-L)"; romanCalculator.CalculateExpression(inputArithmeticExpression); }
public void RomanCalculator_IncorrectOperation_InvalidOperationExceptionThrown(string expression) { Assert.Throws(typeof(InvalidOperationException), () => { RomanCalculator.CalculateExpression(expression); }); }
public void CalculateExpression_UncorrectArithmeticExpression_ExceptionThrown2() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(V++2)"; //Why do we need this variable (it seems that I write this kind of comments again and again, may be it is just your style) var actualResultOfCalculationInRomanFormat = romanCalculator.CalculateExpression(inputArithmeticExpression); }
public void Should_Subtract_Two_Roman_Numbers() { var expression = "I - II"; var calculator = new RomanCalculator(expression); Assert.AreEqual(-1, calculator.Result()); }
public void Should_Multiply_Three_Roman_Numbers() { var expression = "I * II * III"; var calculator = new RomanCalculator(expression); Assert.AreEqual(6, calculator.Result()); }
public void Should_Divide_Three_Roman_Numbers() { var expression = "I / II / III"; var calculator = new RomanCalculator(expression); Assert.AreEqual(0.166, calculator.Result()); }
public void Should_Add_Two_Roman_Numbers() { var expression = "I + II"; var calculator = new RomanCalculator(expression); Assert.AreEqual(3, calculator.Result()); }
public void CalculateExpression_NotPositiveResultOfCalculation_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(IX-L)"; var expectedResultOfCalculationInRomanFormat = "-41"; //Should be constant var actualResultOfCalculationInRomanFormat = romanCalculator.CalculateExpression(inputArithmeticExpression); Assert.AreEqual(expectedResultOfCalculationInRomanFormat, actualResultOfCalculationInRomanFormat); }
public void CalculateExpression_CorrectValueOfCalculation2() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(LXII*III)-(IV+(III*(XIV/VII)+III*II))"; var actualResultOfCalculationInRomanFormat = romanCalculator.CalculateExpression(inputArithmeticExpression); const string expectedResultInRomanFormat = "CLXX"; Assert.AreEqual(expectedResultInRomanFormat, actualResultOfCalculationInRomanFormat); }
public void Should_Convert_Roman_Expression_To_Integer_Expression() { var expression = "I + II + III * ( V - I )"; var expected = "1 + 2 + 3 * ( 5 - 1 )"; var calculator = new RomanCalculator(expression); Assert.AreEqual(expected, calculator.ConvertToIntegerExpression()); }
public void CalculateExpression_UncorrectArithmeticExpression_ExceptionThrown() { var romanCalculator = new RomanCalculator(); const string inputArithmeticExpression = "(IX+(XVII**IV))-(VII*IX)"; var actualResultOfCalculationInRomanFormat = romanCalculator.CalculateExpression(inputArithmeticExpression); const string expectedResultInRomanFormat = "XIV"; Assert.AreEqual(expectedResultInRomanFormat, actualResultOfCalculationInRomanFormat); }
public void CalculateFailed() { Assert.That(() => { var calculator = new RomanCalculator(); calculator.Add(RomanNumber.I); calculator.Add(RomanNumber.M); var value = calculator.Value; }, Throws.Exception.With.Message.EqualTo($"{RomanNumber.I.Symbol} can be only subtracted from {SymbolEnum.V} {SymbolEnum.X}.")); }
public void CalculateValue() { var calculator = new RomanCalculator(); calculator.Add(RomanNumber.I); calculator.Add(RomanNumber.X); var value = calculator.Value; Assert.That(value, Is.EqualTo(9)); }
public void Should_Perform_Multiplication_Before_Addition() { var multiplicationIsSecondInExpression = "I + II * III"; var calculator = new RomanCalculator(multiplicationIsSecondInExpression); Assert.AreEqual(7, calculator.Result()); var multiplicationIsFirstInExpression = "I * II + III"; calculator = new RomanCalculator(multiplicationIsFirstInExpression); Assert.AreEqual(5, calculator.Result()); }
public void CalculateExpression_InpuExpressionIsProperlyCalculated() { var romanCalculator = new RomanCalculator(); var inputArithmeticExpression = "(IX+(XVII*IV))-(VII*IX)"; var actualResultOfCalculationInRomanFormat = romanCalculator.CalculateExpression(inputArithmeticExpression); var expectedResultInRomanFormat = "XIV"; Assert.AreEqual(expectedResultInRomanFormat, actualResultOfCalculationInRomanFormat); inputArithmeticExpression = "(LXII*III)-(IV+(III*(XIV/VII)+III*II))"; actualResultOfCalculationInRomanFormat = romanCalculator.CalculateExpression(inputArithmeticExpression); expectedResultInRomanFormat = "CLXX"; Assert.AreEqual(expectedResultInRomanFormat, actualResultOfCalculationInRomanFormat); }
public void Should_Process_Parenthesis_Before_Anything_Else() { var parensFirstInExpression = "( I + II ) * III"; var calculator = new RomanCalculator(parensFirstInExpression); Assert.AreEqual(9, calculator.Result()); var parensLastInExpression = "I * ( II + III )"; calculator = new RomanCalculator(parensLastInExpression); Assert.AreEqual(5, calculator.Result()); }
public void TestCalculate() { ICalculator calculator = new RomanCalculator(); Assert.AreEqual(calculator.Calculate(commands[0], romanSymbolDefinition), 5331); Assert.AreEqual( Assert.ThrowsException <Exception>( () => calculator.Calculate(commands[1], romanSymbolDefinition)).Message, "V can not be subtracted"); Assert.AreEqual( Assert.ThrowsException <Exception>( () => calculator.Calculate(commands[2], romanSymbolDefinition)).Message, "I can not be subtracted from L"); Assert.AreEqual( Assert.ThrowsException <Exception>( () => calculator.Calculate(commands[3], romanSymbolDefinition)).Message, "D can not be repeated"); Assert.AreEqual( Assert.ThrowsException <Exception>( () => calculator.Calculate(commands[4], romanSymbolDefinition)).Message, "Symbols must be placed in order of value, starting with the largest values"); Assert.AreEqual( Assert.ThrowsException <Exception>( () => calculator.Calculate(commands[5], romanSymbolDefinition)).Message, "The symbols can be repeated three times in succession, but no more"); Assert.AreEqual( Assert.ThrowsException <Exception>( () => calculator.Calculate(commands[6], romanSymbolDefinition)).Message, "Invalid Symbol"); }