public void ParseCanGetOperand()
 {
     Parse parse = new Parse("3 + 4");
     char actual = parse.operand;
     char expected = '+';
     Assert.AreEqual(expected, actual);
 }

 public void EvalCanRetrieveConstantAssignmentThroughLists()
 {
     Parse input = new Parse("x = 3");
     Evaluate eval = new Evaluate(input);
     int expected = eval.ListOfConstantAssignmentsUsed[0];
     Assert.AreEqual(expected, 3);
 }

 public void ParseEnsureICanGetTheOperatorType()
 {
     Parse value = new Parse();
     char actualChar = value.OperatorType("2/2");
     char expectedChar = '/';
     Assert.AreEqual(expectedChar, actualChar);
 }

 public void EvaluateCanExecuteBasicOperation()
 {
     Parse parse = new Parse("1 + 5");
     Evaluate eval = new Evaluate(parse);
     eval.Execute();
     Assert.AreEqual("6", eval.Answer);
 }

 public void EvalCanAddTwoNumbers()
 {
     Parse input = new Parse("3 + 4");
     Evaluate eval = new Evaluate(input);
     int expected = eval.result;
     Assert.AreEqual(expected, 7);
 }

        static void Main(string[] args)
        {
            Console.WriteLine("What is your name?");
            string userName = Console.ReadLine();
            Parse p = new Parse();
            Evaluate e = new Evaluate();
            bool run = true;

            while (run)
            {
                Console.WriteLine(userName + " Define your mathematical operation");
                string input = Console.ReadLine();
                if (input.ToUpper() == "LASTQ")
                {
                    Console.WriteLine(e.lastExpression());
                    run = false;
                    break;
                }
                string oper = p.getOperator(input);
                int num1 = p.getNumberOne(input);
                int num2 = p.getNumberTwo(input);
                int answer = e.ExecuteMethod(num1, num2, oper);
                Console.WriteLine("The answer to your operation is: " + answer);
            }
            Console.WriteLine("Press any key to exit");
            Console.ReadLine();
        }

        public int CalculateMath(Parse parse)
        {
            int first_term = parse.terms[0];
            int second_term = parse.terms[1];
            math_expression = parse.mathOperator;

            if (math_expression == "+")
            {
                DoAddition(first_term, second_term);
            }
            else if (math_expression == "-")
            {
                DoSubtraction(first_term, second_term);
            }
            else if (math_expression == "/")
            {
                DoDivision(first_term, second_term);
            }
            else if (math_expression == "*")
            {
                DoMultiplication(first_term, second_term);
            }
            else if (math_expression == "%")
            {
                DoModulus(first_term, second_term);
            }
            else
            {
                throw new InvalidOperationException();
            }
            return last;
        }

 public void ParseCanPullOutTwoArgumentNumbers()
 {
     Parse parse = new Parse("1 + -2");
     parse.PullOutArguments();
     Assert.AreEqual(1, parse.FirstNumArg);
     Assert.AreEqual(-2, parse.SecondNumArg);
 }

 public void ParseCanFindSecondNum()
 {
     Parse twoPlusThree = new Parse("2 + 3");
     twoPlusThree.setOperatorIndex();
     twoPlusThree.firstNum();
     Assert.AreEqual(3, twoPlusThree.secondNum());
 }

 public void ParseCanFindCommands()
 {
     Parse parse = new Parse("last");
     parse.CheckForCommand();
     Assert.AreEqual("last", parse.Command);
     Assert.IsTrue(parse.IsCommand);
 }

 public void ParseCanPullOutnumberAndConstant()
 {
     Parse parse = new Parse("c + -2");
     parse.PullOutArguments();
     Assert.AreEqual("c", parse.FirstConstArg);
     Assert.AreEqual(-2, parse.SecondNumArg);
 }

 public static int Calculation(string input)
 {
     Parse val = new Parse();
     string[] inputParsed = val.Equation(input);
     char operation = val.OperatorType(input);
     int[] inputToInt = val.ValuesToInt(inputParsed);
     if (operation == '+')
     {
         return Add(inputToInt);
     }
     else if (operation == '-')
     {
         return Subtract(inputToInt);
     }
     else if (operation == '*')
     {
         return Multi(inputToInt);
     }
     else if (operation == '/')
     {
         return Divide(inputToInt);
     }
     else if (operation == '%')
     {
         return Modulo(inputToInt);
     }
     else
     {
         throw new InvalidOperationException("Error: Calculations must only use +, -, *, /, or %");
     }
 }

 public void ParseCanParseWithNegativeLast()
 {
     Parse parse = new Parse("3 + -4");
     char actual = parse.operand;
     char expected = '+';
     Assert.AreEqual(expected, actual);
 }

 public void ParseCanGetOperandWithNegativeFirst()
 {
     Parse parse = new Parse("-3 + 4");
     char actual = parse.operand;
     char expected = '+';
     Assert.AreEqual(expected, actual);
 }

        static void Main(string[] args)
        {
            int count = 0;
            Constant currentConstant = new Constant();
            Evaluate expression;

            while (true)
            {
                Console.Write("[{0}]> ", count);
                string input = Console.ReadLine();
                expression = new Evaluate(input, currentConstant);
                if (input.ToLower() == "exit" || input.ToLower() == "quit")
                {
                    break;
                }
                else if (input.IndexOf("=")> -1)
                {
                    //set variable

                    Parse addConstant = new Parse(input, currentConstant);
                    addConstant.setOperatorIndex();
                    currentConstant.addConst(addConstant.StringFirst(), addConstant.secondNum());
                    // = saved 'x' as '3'
                    Console.WriteLine("= saved '" + addConstant.StringFirst() + "' as '" + addConstant.secondNum() + "'");

                }
                else
                {
                    int answer = expression.doMath();
                    Console.WriteLine("   = {0}", answer);
                    count++;

                }
            }
        }

 public void ParseOnlyAllowsNumbersSecond()
 {
     Parse twoPlusThree = new Parse("2 + b");
     twoPlusThree.setOperatorIndex();
     twoPlusThree.firstNum();
     twoPlusThree.secondNum();
 }

 public int EvaluateInput(string input, Constant constant)
 {
     Parse parse = new Parse();
     Add add_input = new Add();
     Subtract subtract_input = new Subtract();
     Multiply multiply_input = new Multiply();
     Divide divide_input = new Divide();
     Modulo modulo_input = new Modulo();
     if (parse.OperatorInput(input) == '+')
     {
         return add_input.AddConstants(input, constant);
     }
     if (parse.OperatorInput(input) == '-')
     {
         return subtract_input.SubtractConstants(input, constant);
     }
     if (parse.OperatorInput(input) == '*')
     {
         return multiply_input.MultiplyConstants(input, constant);
     }
     if (parse.OperatorInput(input) == '/')
     {
         return divide_input.DivideConstants(input, constant);
     }
     if (parse.OperatorInput(input) == '%')
     {
         return modulo_input.ModuloConstants(input, constant);
     }
     throw new FormatException();
 }

 public void ParseOnlyAllowsSimpleExpressions()
 {
     Parse twoPlusThree = new Parse("2 - 5 + 3");
     twoPlusThree.setOperatorIndex();
     twoPlusThree.firstNum();
     twoPlusThree.secondNum();
 }

 public void TestParsedExpression()
 {
     Parse parser = new Parse("225125+31256125");
     Assert.AreEqual(225125, parser.Number1);
     Assert.AreEqual("+", parser.Operator);
     Assert.AreEqual(31256125, parser.Number2);
 }

 public void EvalAssignUsedConstantThrowsException()
 {
     Parse input = new Parse("x = 3");
     Parse input2 = new Parse("x = 10");
     Evaluate eval = new Evaluate(input);
     eval.EvaluateExpression(input2);
 }