static void Main(string[] args)
{
SetOptions(args);
try
{
var operation = GetOperation();
var delimiters = GetDelimiters();
var input = GetInput();
var calculator = CalculatorBuilder
.With(input)
.And(delimiters)
.ValidNumbers()
.FilterNegative(allowNegatives)
.FilterGreaterThan(upperBound)
.For(operation);
var result = calculator.Calculate();
var formula = calculator.Formula();
Console.WriteLine(string.Format("Result : {0}", result));
Console.WriteLine(string.Format("Formula : {0}", formula));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.Read();
}
public void CalculationListTest()
{
double _a = 4;
double _b = 2;
Func <double, double, double> _action = Operations.Sum;
var _calculatorBuilder = new CalculatorBuilder();
Calculator _calculator = new Calculator(_calculatorBuilder);
_calculator.CreateCalculation(_a, _b, _action);
_action = Operations.Difference;
_calculator.CreateCalculation(_a, _b, _action);
_action = Operations.Division;
_calculator.CreateCalculation(_a, _b, _action);
_action = Operations.Multiplication;
_calculator.CreateCalculation(_a, _b, _action);
_calculatorBuilder.GetList().ForEach(action : delegate(ICalculation calculations)
{
Console.WriteLine(calculations.GetResult());
});
}
protected virtual void OnCalculator(CalculatorBuilder calculator)
{
if (UsingCalculator != null)
{
UsingCalculator(this, new CalculatorEventArgs()
{
Calculator = calculator
});
}
}
public void ShouldThrowExceptionWhenInputHasNegativeNumbers(string input)
{
Assert.Throws <ArgumentException>(() =>
CalculatorBuilder
.With(input)
.And(delimiter)
.ValidNumbers()
.FilterNegative(false)
.FilterGreaterThan(1000)
.For('+')
.Calculate());
}
public void ShouldIgnoreTextOrEmptyValueAndReturnCorrectSumAndFormula(string input, int expectedSum, string expectedFormula)
{
var actualResult = CalculatorBuilder
.With(input)
.And(delimiter)
.ValidNumbers()
.FilterNegative(false)
.FilterGreaterThan(1000)
.For('+');
Assert.AreEqual(expectedSum, actualResult.Calculate());
Assert.AreEqual(expectedFormula, actualResult.Formula());
}
public void CanExtendWithAnyPower()
{
var calculator = new CalculatorBuilder()
.AddDefaultOperations()
.AddOperation("^", (prev, arg) => Math.Pow(prev, arg))
.Build();
calculator.Perform("+", 3)
.Perform("^", 3)
.Result
.Should()
.Be(27);
}
public void CanExtendWithSquareRoot()
{
var calculator = new CalculatorBuilder()
.AddDefaultOperations()
.AddOperation("root", (prev, arg) => Math.Pow(prev, 1 / arg))
.Build();
calculator.Perform("+", 4)
.Perform("root", 2)
.Result
.Should()
.Be(2);
}
public void ShouldReturnNegativeNumbersWithExceptionWhenInputHasNegativeNumbers(string input)
{
Assert.That(() =>
CalculatorBuilder
.With(input)
.And(delimiter)
.ValidNumbers()
.FilterNegative(false)
.FilterGreaterThan(1000)
.For('+')
.Calculate(),
Throws.TypeOf <ArgumentException>().With.Message
.EqualTo("Negatives not allowed. -3,-1"));
}
public void ShouldReturnCorrectSumAndFormulaForCommaSeparatedNumbers
(string input,
bool allowNegative,
int upperBound,
int expectedSum,
string expectedFormula)
{
var actualResult = CalculatorBuilder
.With(input)
.And(delimiter)
.ValidNumbers()
.FilterNegative(allowNegative)
.FilterGreaterThan(upperBound)
.For('+');
Assert.AreEqual(expectedSum, actualResult.Calculate());
Assert.AreEqual(expectedFormula, actualResult.Formula());
}
static async Task Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
var toExit = false;
var calculator = CalculatorBuilder.Create(TariffProviderType.InMemory);
foreach (var input in args)
{
toExit = await Calculate(calculator, input);
if (toExit)
{
break;
}
}
while (!toExit)
{
Console.WriteLine("For exit please type 'exit'.");
Console.WriteLine("Please provide consumption:");
var inputStr = Console.ReadLine();
foreach (var input in inputStr.Split(' '))
{
toExit = await Calculate(calculator, input);
if (toExit)
{
break;
}
}
}
;
Console.WriteLine("Thanks for using this product!");
}
//struct runprogram
//which will run cli class
//which will translate input into request to system.
// option
// Q - in string quites app
//
// system:
//ui
// parser
// lexer
static void Main(string[] args)
{
var basicMath = new BasicMath();
var calculatorBuilder = new CalculatorBuilder(basicMath);
var inputParser = new InputParser();
var calculatorControler = new CalculatorControler(calculatorBuilder, inputParser);
while (true)
{
Console.WriteLine("Hello World! Give input the click Enter");
Console.WriteLine("App will give you result of your math query");
Console.WriteLine("If Querry has Q in it will close the app.");
var input = Console.ReadLine();
if (input.ToLower().Contains("q"))
{
Console.WriteLine("closing app press any key");
Console.ReadKey();
return;
}
var result = calculatorControler.Calculate(input);
Console.WriteLine($"operation result is: {result}");
}
}
public AnnualFeeCalculatorTests()
{
this.calculator = CalculatorBuilder.Create(CalculatorBuilder.TariffProviderType.InMemory);
}
public void CalculatorNotNull()
{
var calculator = CalculatorBuilder.Create(CalculatorBuilder.TariffProviderType.InMemory);
Assert.IsNotNull(calculator);
}
public void UseCalculator(CalculatorBuilder calculator)
{
Console.WriteLine("Using Calculator...");
OnCalculator(calculator);
}
