**********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

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

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

While the operator stack is not empty, pop the operator from the operator stack, create an operand object from the popped operator, and push it to the operand stack. While the operand stack has more than one operand, pop two operands from the operand stack and one operator from the operator stack, and apply the operator to the operands. Push the result back to the operand stack. The result of the expression is the single operand left on the operand stack. You are required to implement the missing parts of this algorithm in the eval method of the Evaluator class.

Please help, thank you