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");
}
