public void CalculatorOperatorsFromString()
{
foreach (var i in CalculatorOperators.List())
{
Assert.AreEqual(i, CalculatorOperators.FromString(i.Symbols));
}
}
/// <summary>
/// Перегрузка конструктора консольного калькулятора.
/// Инициализирует нулями свойства "Результат" и регистр памяти.
/// В поля операндов и оператора записывает переданные значения.
/// </summary>
/// <param name="Значение первого операнда"></param>
/// <param name="Значение второго операнда"></param>
/// <param name="Оператор (действие)"></param>
public ConsoleCalculator(double operand1, double operand2, CalculatorOperators operator1)
{
Memory = 0;
Result = 0;
Operand1 = operand1;
Operand2 = operand2;
Operator = operator1;
}
/// <summary>
/// Перегрузка конструктора консольного калькулятора.
/// Инициализирует все имеющиеся свойства переданными значениями.
/// Специально для тестов.
/// </summary>
/// <param name="Хранимое значение в памяти"></param>
/// <param name="Хранимый результат"></param>
/// <param name="Значение первого операнда"></param>
/// <param name="Значение второго операнда"></param>
/// <param name="Оператор (действие)"></param>
public ConsoleCalculator(double memory, double result, double operand1, double operand2, CalculatorOperators operator1)
{
Memory = memory;
Result = result;
Operand1 = operand1;
Operand2 = operand2;
Operator = operator1;
}
public void OneElementCorrectCommand_Test(string input, ResultStatus expectedResult)
{
var calculator = new ConsoleCalculator();
var resultStatus = calculator.ParseString(input);
var expOperation = CalculatorOperators.FromString(input);
Assert.AreEqual(expectedResult, resultStatus);
Assert.AreEqual(expOperation, calculator.Operator);
}
public void CalculatorOperatorsToString_Test()
{
var id = 20;
var name = "Test Operator";
var str = "test";
var oneElement = true;
var testOperator = new CalculatorOperators(id, name, str, oneElement);
Assert.AreEqual(name, testOperator.ToString());
}
public void CalculatorOperatorsList_Test()
{
int id = 0;
foreach (var i in CalculatorOperators.List())
{
Assert.AreEqual(id, i.Id);
id++;
}
}
public void TwoElementCorrectCommand_Test(string input, double memoryField, double resultField, ResultStatus expectedResult, string expectedOperation, double expectedOp2)
{
var calculator = new ConsoleCalculator(memoryField, resultField, 0, 0, CalculatorOperators.Add);
var resultStatus = calculator.ParseString(input);
var expOperation = CalculatorOperators.FromString(expectedOperation);
Assert.AreEqual(expectedResult, resultStatus);
Assert.AreEqual(expOperation, calculator.Operator);
Assert.AreEqual(resultField, calculator.Operand1);
Assert.AreEqual(expectedOp2, calculator.Operand2);
}
public void CalculatorOperatorsEquals_Test()
{
var id = 20;
var name = "Test Operator";
var str = "test";
var oneElement = true;
var testOperator = new CalculatorOperators(id, name, str, oneElement);
Assert.AreEqual(false, testOperator.Equals(CalculatorOperators.Help));
Assert.AreEqual(true, testOperator.Equals(testOperator));
}
public void CalculatorOperatorsGetHashCode_Test()
{
var id = 0;
foreach (var i in CalculatorOperators.List())
{
var a = id.GetHashCode();
var b = i.GetHashCode();
Assert.AreEqual(id.GetHashCode(), i.GetHashCode());
id++;
}
}
public void CalculatorOperatorsConstructor_Test()
{
var id = 20;
var name = "Test Operator";
var str = "test";
var oneElement = true;
var testOperator = new CalculatorOperators(id, name, str, oneElement);
Assert.AreEqual(id, testOperator.Id);
Assert.AreEqual(name, testOperator.Name);
Assert.AreEqual(str, testOperator.Symbols);
Assert.AreEqual(oneElement, testOperator.OneElementCommand);
}
/// <summary>
/// Парсит строчку в свойства операндов и оператора
/// и возвращает ResultStatus.OK, если парсинг удался,
/// или ResultStatus.InvalidInput, если парсинг неудачен.
/// </summary>
/// <param name="inputStr"></param>
/// <returns></returns>
public ResultStatus ParseString(string str)
{
var parsedStr = SplitString(str);
var result = new bool[parsedStr.Length];
var status = DoubleOrCommandDecider(result, parsedStr);
if (status == ResultStatus.InvalidInput)
{
return(ResultStatus.InvalidInput);
}
var elementsCount = parsedStr.Length;
if (elementsCount == 1 && !result[0] && CalculatorOperators.IsOneElementCommand(parsedStr[0]))
{
Operator = StrToOperator(parsedStr[0]);
return(ResultStatus.OK);
}
for (int i = 0; i < elementsCount; i++)
{
if (CalculatorOperators.IsMR(parsedStr[i]))
{
parsedStr[i] = Memory.ToString();
result[i] = true;
}
}
if (elementsCount == 2 && !result[0] & result[1] && !CalculatorOperators.IsOneElementCommand(parsedStr[0]))
{
Operand1 = Result;
Operand2 = StrToDouble(parsedStr[1]);
Operator = StrToOperator(parsedStr[0]);
return(ResultStatus.OK);
}
if (elementsCount == 3 && result[0] && !result[1] && result[2])
{
if (!CalculatorOperators.IsOneElementCommand(parsedStr[1]))
{
Operand1 = StrToDouble(parsedStr[0]);
Operand2 = StrToDouble(parsedStr[2]);
Operator = StrToOperator(parsedStr[1]);
return(ResultStatus.OK);
}
}
return(ResultStatus.InvalidInput);
}
/// <summary>
/// Метод-решатель, определяет, находится ли на i-ой позиции в массиве распарсеной строки
/// вещественное число (тогда в массиве result записываем true), команда из соответствующего класса
/// (тогда false) или какой-то мусор (возвращается InvalidInput)
/// </summary>
/// <param name="result"></param>
/// <param name="parsedStr"></param>
/// <returns></returns>
public static ResultStatus DoubleOrCommandDecider(bool[] result, string[] parsedStr)
{
double parsedDouble;
for (int i = 0; i < parsedStr.Length; i++)
{
if (double.TryParse(parsedStr[i], System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture, out parsedDouble))
{
result[i] = true;
}
else
{
if (!CalculatorOperators.Contains(parsedStr[i]))
{
return(ResultStatus.InvalidInput);
}
}
}
return(ResultStatus.OK);
}
public void CalculatorOperatorsContains_Test(string symbols, bool contains)
{
Assert.AreEqual(contains, CalculatorOperators.Contains(symbols));
}
/// <summary>
/// Стандартный конструктор консольного калькулятора.
/// Инициализирует нулями свойства "Результат" и регистр памяти.
/// </summary>
public ConsoleCalculator()
{
Memory = 0;
Result = 0;
Operator = CalculatorOperators.Add;
}
/// <summary>
/// Обертка для превращения строки с оператором (командой) в оператор
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static CalculatorOperators StrToOperator(string str)
{
return(CalculatorOperators.FromString(str));
}
public void CalculatorOperatorsIsMR_Test(string symbols, bool isMR)
{
Assert.AreEqual(isMR, CalculatorOperators.IsMR(symbols));
}
public void CalculatorOperatorsIsOneElementCommand_Test(string symbols, bool isMR)
{
Assert.AreEqual(isMR, CalculatorOperators.IsOneElementCommand(symbols));
}