**********Evaluator.java****************

package evaluator;

import java.util.*;

import operand.Operand;

import operator.Operator;

public class Evaluator {

private Stack operandStack;

private Stack operatorStack;

private StringTokenizer tokenizer;

private static final String DELIMITERS = "+-*^/() ";

public Evaluator() {

operandStack = new Stack();

operatorStack = new Stack();

}

public int eval(String expression) {

int result = 0;

String token;

Operator hashOpr = Operator.operators.get("#");

oprStack.push(hashOpr);

String delimiters = "+-*/#!";

// The 3rd argument is true to indicate that the delimiters should be used

// as tokens, too. But, we'll need to remember to filter out spaces.

this.tokenizer = new StringTokenizer(expression, DELIMITERS, true);

while (this.tokenizer.hasMoreTokens()) {

// filter out spaces

if (!(token = this.tokenizer.nextToken()).equals(" ")) {

// check if token is an operand

if (Operand.check(token)) {

operandStack.push(new Operand(token));

} else {

if (!Operator.check(token)) {

System.out.println("*****invalid token******");

System.exit(1);

}

// TODO Operator is abstract - this line will need to be fixed:

// ( The Operator class should contain an instance of a HashMap,

// and values will be instances of the Operators. See Operator class

// skeleton for an example. )

Operator newOperator = null; // new Operator( token );

while (operatorStack.peek().priority() >= newOperator.priority()) {

// note that when we eval the expression 1 - 2 we will

// push the 1 then the 2 and then do the subtraction operation

// This means that the first number to be popped is the

// second operand, not the first operand - see the following code

Operator oldOpr = operatorStack.pop();

Operand op2 = operandStack.pop();

Operand op1 = operandStack.pop();

operandStack.push(oldOpr.execute(op1, op2));

}

operatorStack.push(newOperator);

}

}

}

// Control gets here when we've picked up all of the tokens; you must add

// code to complete the evaluation - consider how the code given here

// will evaluate the expression 1+2*3

// When we have no more tokens to scan, the operand stack will contain 1 2

// and the operator stack will have + * with 2 and * on the top;

// In order to complete the evaluation we must empty the stacks (except

// the init operator on the operator stack); that is, we should keep

// evaluating the operator stack until empty

// Suggestion: create a method that takes an operator as argument and

// then executes the while loop; also, move the stacks out of the main

// method

return 0;

}

/**

* Class to help test your Evaluator:

* javac EvaluatorTester

* java EvaluatorTester "1+2" "3*5"

*/

public static void main(String[] args) {

Evaluator evaluator = new Evaluator();

for (String arg : args) {

System.out.format("%s = %d ", arg, evaluator.eval(arg));

}

}

}

************************************Operand.Java**************************************************

package operand;

public class Operand {

public Operand( String token ) {

}

public Operand( int value ) {

}

public int getValue() {

return 0;

}

public static boolean check( String token ) {

return false;

}

}

*******************************************************EvaluatorTest.java***********************************************

package tests;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

import evaluator.Evaluator;

public class EvaluatorTest {

@Test

void testSimpleAddition() {

Evaluator evaluator = new Evaluator();

assertEquals(3, evaluator.eval("1 +2"));

}

@Test

void testSimpleDivision() {

Evaluator evaluator = new Evaluator();

assertEquals(0, evaluator.eval("1/2"));

}

@Test

void testSimpleExpression() {

Evaluator evaluator = new Evaluator();

assertEquals(7, evaluator.eval("1+2*3"));

}

@Test

void testSimpleParenthesizedExpression() {

Evaluator evaluator = new Evaluator();

assertEquals(9, evaluator.eval("(1+2)*3"));

}

@Test

void testComplexExpressionWithNegativeResult() {

Evaluator evaluator = new Evaluator();

assertEquals(7, evaluator.eval("2-(3/10)+2-5"));

}

@Test

void testAnotherComplexExpressionWithNegativeResult() {

Evaluator evaluator = new Evaluator();

assertEquals(-6, evaluator.eval("(6-12*2)/3"));

}

@Test

void testSimpleExponentiation() {

Evaluator evaluator = new Evaluator();

assertEquals(9, evaluator.eval("3^2"));

}

@Test

void testSlightlyMoreComplexExponentiation() {

Evaluator evaluator = new Evaluator();

assertEquals(4, evaluator.eval("3^2/2"));

}

@Test

void testHardMode() {

Evaluator evaluator = new Evaluator();

assertEquals(1176, evaluator.eval("2+3-5*((2-3)*2-5*2+3*(2-3-5-5*6)+4/2)*2-9"));

}

@Test

void testProperStackUsage() {

Evaluator evaluator = new Evaluator();

// Stacks should be emptied and in a valid state after the first evaluation occurs,

// so the second evaluation should run without exception and provide

assertEquals(6, evaluator.eval("1+2+3"));

assertEquals(1, evaluator.eval("10-8-1"));

}

}

******************************************************OperandTest.java*******************************************************************

package tests;

import static org.junit.Assert.assertEquals;

import static org.junit.jupiter.api.Assertions.assertFalse;

import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.ArrayList;

import java.util.Arrays;

import org.junit.jupiter.api.Test;

import operand.Operand;

public class OperandTest {

@Test

void testCheck() {

ArrayList validOperands =

new ArrayList(Arrays.asList( "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ));

validOperands.forEach(operand -> assertTrue(Operand.check(operand)));

assertFalse(Operand.check("a"));

}

@Test

void testGetValueFromOriginalString() {

Operand operandOne = new Operand("3");

assertEquals(3, operandOne.getValue());

}

@Test

void testGetValueFromOriginalInt() {

Operand operandTwo = new Operand(7);

assertEquals(7, operandTwo.getValue());

}

}

*******************************************************OperatorTest.java*****************************************************

package tests;

import org.junit.jupiter.api.Test;

import static org.junit.Assert.assertTrue;

import static org.junit.jupiter.api.Assertions.assertFalse;

import java.util.ArrayList;

import java.util.Arrays;

import operator.Operator;

public class OperatorTest {

@Test

void testCheck() {

ArrayList validOperators =

new ArrayList(Arrays.asList( "+", "-", "*", "/", "^" ));

validOperators.forEach(operator -> assertTrue(Operator.check(operator)));

assertFalse(Operator.check("1"));

}

}

**********************************************************************************************

This is the readme

[](https://classroom.github.com/online_ide?assignment_repo_id=10049933&assignment_repo_type=AssignmentRepo)

# Assignment 1 Documentation

Author: Eduardo Ruiz (please keep the Author: heading for my grading script)

## Overview of code skeleton

The folders `.devcontainer`, `.vscode`, and `lib` contain configuration information that must not be deleted or modified. The remaining folders will be discussed in class.

## Scope of Work

| Requirement | Completed? | Comments from student |

| ------------------------- | ---------- | --------------------- |

| 1 - Implement algorithm | [] | |

| 2 - Tests | [] | |

| 3 - Class implementations | [] | |

## Class diagrams

REPLACE THIS TEXT: Include a diagram of all of the classes you worked with in this assignment, indicating their relationships. For each class, include a one line description of its responsibility. If you are looking for a tool to use to create the class diagram, check out [Mermaid](https://mermaid.js.org/syntax/classDiagram.html) - this allows you to write markdown in this file that will be rendered as class diagrams.

## Results and Conclusions

### What I Learned

REPLACE THIS TEXT: Describe what you learned by completing this assignment

### Challenged I Encountered

REPLACE THIS TEXT: Describe challenges you encountered completing this assignment, and how you overcame those challenges

********************************************************

********************************************************

Please help, thank you

Computer Science Department San Francisco State University CSC413 Assignment 1 - Expression Evaluator Due Date: Sunday, February 19, at midnight. Note that the due date applies to the last commit timestamp into the main branch of your repository. Note that no late assignments will be accepted. Overview The purpose of this assignment is to practice object oriented design to create an object that evaluates mathematical expressions. You are provided with a project skeleton, which will be automatically cloned into your github repository when you begin the assignment via this link: https:/I classroom.github.com/a/xpMT29ot. Submission Your assignment will be submitted using github. Only the main branch of your repository will be graded. Late submission is determined by the last commit time on the main branch. You are required to answer the questions in the README . ad file in your repository. Your program will be tested with a script, which will use some of the following commands. You are encouraged to run these commands at a command prompt to ensure your project compiles without error! 1. git clone your-repository-name 2. cd your-repository-name 3. find . -name "* .class" -type f-delete 4. find. -name "*.jar" -type f-delete 5. rm-rf tests 6. copy testing dependencies, current tests, and some additional tests added to further exercise your code, then execute tests from the command line The grading rubric is available in Canvas. Requirements You will be provided with a code skeleton for the Evaluator class (Evaluator. java). You should program the utility classes it uses - Operand and operator - and then follow the algorithm described below to complete the implementation of the Evaluator class. The Evaluator implements a single public method, eval, that takes a single string parameter that represents an infix mathematical expression, parses and evaluates the expression, and returns the integer result. An example expression is " 2+3 * 4 ", which would be evaluated to 14. The expressions are composed of integer operands and operators drawn from the set +, ,,/,,(, and ). These operators have the following precedence: The algorithm that is partially implemented in eval processes the tokens in the expression string using two stacks; one for operators and one for operands (algorithm reproduced here from http://csis.pace.edu/ murthy/ProgrammingProblems/ 16 Evaluation of infix expressions): - If an operand token is scanned, an operand object is created from the token, and pushed to the operand Stack - If an operator token is scanned, and the operator Stack is empty, then an operator object is created from the token, and pushed to the operator Stack - If an operator token is scanned, and the operator stack is not empty, and the operator's precedence is greater than the precedence of the Operator at the top of the Stack, then an operator object is created from the token, and pushed to the operator stack - If the token is (, an operator object is created from the token, and pushed to the operator Stack - If the token is ), then process Operators until the corresponding ( is encountered. Pop the (Operator. - If none of the above cases apply, process an Operator. The operand class allows for the generalization of operands in our calculations. Note that two constructors are required: the constructor with the string parameter will be used to create new operands as we retrieve tokens from the string expression, and the constructor with the int parameter will be used to create new operands in the execute method of operator subclasses. You must also consider how to maintain the state of the operand - how should the token or vaiue be stored in the operand instance? Do we need both a string and int. field in the class? In addition to the constructors, the following methods must be implemented: - boolean check ( String token ) This method should return true if the token passed as a parameter is a valid operand token - inl gelvalue() This method returns the integer value of this operand