public void TestProcessor_Bad(string inputValue, int numItems)
{
var input = new CalculateInfixRequest()
{
Input = inputValue,
Operators = new OperatorList().Operators,
};
BResult <CalculateInfixResponse> result = new InfixToPostfixProcessor().InfixToPostfix(input);
Assert.True(numItems == result.Result.CalculateStack.Count);
Assert.NotEmpty(result.Error);
}
/// <summary>
/// Convert from infix to postfix notation
/// </summary>
/// <param name="request"></param>
/// <returns>stack object for postfix calculator</returns>
public BResult <CalculateInfixResponse> InfixToPostfix(CalculateInfixRequest request)
{
BResult <CalculateInfixResponse> result = new BResult <CalculateInfixResponse>()
{
Result = new CalculateInfixResponse()
};
if (request == null || string.IsNullOrWhiteSpace(request.Input) || request.Operators == null || request.Operators.Count == 0)
{
result.Error.Add(new HError("InfixToPostfix", "Invalid request"));
return(result);
}
var rpnResult = new ShuntingYard().CreateReversePolishNotation(request.Input, request.Operators);
result.Error.AddRange(rpnResult.Error);
result.Result.CalculateStack = rpnResult.Result;
return(result);
}
public async Task <BResult <CalculatorResponse> > ExecuteAsync(CalculatorRequest request)
{
BResult <CalculatorResponse> result = new BResult <CalculatorResponse> {
Result = new CalculatorResponse()
};
try
{
if (string.IsNullOrWhiteSpace(request.Input))
{
result.Error.Add(new HError("Calculator", "Invalid request - null input"));
}
if (request.Input.Any(c => char.IsLetter(c)))
{
result.Error.Add(new HError("Calculator", "Invalid input - contains letters"));
}
if (!request.Input.EndsWith("="))
{
result.Error.Add(new HError("Calculator", "Invalid input - Expression must end with '='"));
}
if (_operators == null || _operators.Count == 0)
{
result.Error.Add(new HError("Calculator", "Invalid operator creation"));
return(result);
}
// Check input string against valid list of valid operators / digits
List <char> goodChar = _operators.Keys.SelectMany(s => s.ToCharArray()).ToList();
goodChar.AddRange(new List <char> {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '=', '(', ')'
});
if (request.Input.Except(goodChar).Any())
{
string validChar = string.Join(", ", goodChar.Select(c => c.ToString()).ToArray());
result.Error.Add(new HError("Calculator", $"Invalid input - Valid inputs are: {validChar}"));
}
if (result.Error.Count > 0)
{
return(result);
}
var calculateInputRequest = new CalculateInfixRequest()
{
Input = request.Input, Operators = _operators
};
BResult <CalculateInfixResponse> bResultInput = new InfixToPostfixProcessor().InfixToPostfix(calculateInputRequest);
result.Error.AddRange(bResultInput.Error);
//if (result.Error.Any())
// return result;
var calulateOutputRequest = new CalculatePostfixRequest()
{
CalculateStack = bResultInput.Result.CalculateStack, Operators = _operators
};
BResult <CalculatePostfixResponse> bResultOutput = new CalculatePostfixProcessor().Calculate(calulateOutputRequest);
result.Error.AddRange(bResultOutput.Error);
result.Result.Output = bResultOutput.Result.CalculatedValue;
}
catch (Exception ex)
{
result.Error.Add(new HException(_herrorRepository, "Calculator", "Exception will executing Calculator", ex));
}
await Task.Delay(0);
return(result);
}
