advanced the project structure & implemented the lexer test class

expressions.txt

 1+(x^2)-(3*x)
-2*x+0.5*(x^2)-1
+2*x+0.5*(x^2+4)-1
\ No newline at end of file

src/Exceptions/LexerException.java

+package Exceptions;
+
+public class LexerException extends Exception {
+    public LexerException(String message) {
+        super(message);
+    }
+}

src/ParserException.java → src/Exceptions/ParserException.java

+package Exceptions;
+
 public class ParserException extends Exception{
     public ParserException(String message) {
         super(message);

src/ASTPrinter.java → src/main/ASTPrinter.java

+package main;
+
 public class ASTPrinter implements  Visitor<String>{
     @Override
     public String visit(final Parser.BinaryOperation binaryOP) {

src/Application.java → src/main/Application.java

+package main;
+
+import Exceptions.LexerException;
+import Exceptions.ParserException;
+
 import java.io.BufferedReader;
+import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.LinkedList;
@@ -6,34 +12,47 @@ import java.util.List;
 
 public class Application {
     public static void main(String[] args) {
+        //A list that will contain a String for each line of the "expressions.txt" file
         List<String> expressions = new LinkedList<>();
-        //Reads the file "expressions.txt" and adds its values to a list
+        //Reads the file "expressions.txt" and adds its values to the list expressions
         BufferedReader reader;
-        String dataPath = "expressions.txt";
+        String datapath = "expressions.txt";
         try {
             System.out.println("Reading the file...\n");
-            reader = new BufferedReader(new FileReader(dataPath));
-            String line = reader.readLine();
-            while(line != null) {
-                expressions.add(line);
-                line = reader.readLine();
+            reader = new BufferedReader(new FileReader(datapath));
+            String currentLine = reader.readLine();
+            while(currentLine !=null) {
+                expressions.add(currentLine);
+                currentLine = reader.readLine();
             }
             reader.close();
         }
-        catch (IOException e ) {
+        catch(IOException e) {
             e.printStackTrace();
         }
 
+        //Iterate through every String
+        for (String expression: expressions) {
+            System.out.println("Expression: " + expression);
+            //Usage of the lexer, parser & evaluator
+            try {
+                //Create a list of tokens with the lexer
+                List<Lexer.Token> tokens = Lexer.lex(expression);
+                System.out.println("Lexer created tokens:");
+                //prints out each token to the console
+                for(Lexer.Token token: tokens) {
+                    System.out.println(token.toString());
+                }
+            }
+            catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
+
+        /*
         //Iterates through every String and parses them into multiple tokens
         for (String value: expressions) {
-            System.out.println(value);
-            //creates a list of tokens out of the String
-            List<Lexer.Token> tokens = Lexer.lex(value);
-
-            //prints each token out (with .toString())
-            for(Lexer.Token singleToken: tokens) {
-                System.out.println(singleToken.toString());
-            }
             Parser parser = new Parser();
             try {
                 Parser.Expression exp = parser.parse(tokens);
@@ -48,6 +67,6 @@ public class Application {
                 System.out.println(e.getMessage());
             }
             System.out.println();
-        }
+        }*/
     }
 }

src/Evaluator.java → src/main/Evaluator.java

+package main;
+
 public class Evaluator implements Visitor<Double>{
 
     @Override
@@ -16,6 +18,7 @@ public class Evaluator implements Visitor<Double>{
                 result -= rOperand;
                 break;
             case '*':
+                rOperand *= rOperand;
                 result *= rOperand;
                 break;
             case '/':

src/Lexer.java → src/main/Lexer.java

+package main;
+
+import Exceptions.LexerException;
+
 import java.util.LinkedList;
 import java.util.List;
 
@@ -9,7 +13,7 @@ public class Lexer {
     }
 
     //tokens with a TokenType that represents their type and a String with the actual data
-    //has for both values a getter method and overrides toString with it's fitting values
+    //has for both values a getter method and overrides toString with its fitting values
     public static class Token {
         protected TokenType type;
         protected String data;
@@ -33,15 +37,19 @@ public class Lexer {
     }
 
     //creates a list of tokens from a given String
-    public static List<Token> lex(String input) {
+    public static List<Token> lex(String input) throws Exception{
+        if(input.isEmpty()) {
+            throw new LexerException("SyntaxError: lexer received empty String");
+        }
+
         //the list that will be returned at the end
         List<Token> result = new LinkedList<Token>();
         //for-loop that iterates through each character of the String
         for(int index=0; index < input.length();) {
 
             char current = input.charAt(index);
-            //checks if a character is a digit, then creates a token with one or multiple numbers
-            //with TokenType=NUMBER
+            //checks if a character is a digit, then creates a token with one or multiple
+            //numbers with TokenType=NUMBER
             if(Character.isDigit(current)) {
                 int endIndex = index;
                 if(endIndex<input.length()) {

src/Parser.java → src/main/Parser.java

+package main;
+
+import Exceptions.ParserException;
+
 import java.util.LinkedList;
 import java.util.List;
 
@@ -21,6 +25,10 @@ public class Parser {
         public <T> T accept(Visitor<T> visitor) {
             return visitor.visit(this);
         }
+
+        public <T> T accept(Visitor<T> vistor, String operator) {
+            return vistor.visit(this);
+        }
     }
 
     public class Variable extends Expression {

src/SwingFunctionPlotter.java → src/main/SwingFunctionPlotter.java

+package main;
+
 import com.mindfusion.charting.FunctionSeries;
 import com.mindfusion.charting.swing.LineChart;
 

src/Visitor.java → src/main/Visitor.java

+package main;
+
 public interface Visitor<T>{
     public T visit(final Parser.BinaryOperation binOp);
     public T visit(final Parser.Variable variable);

src/test/LexerTest.java

+package test;
+
+import org.junit.Test;
+import main.*;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LexerTest {
+
+    @Test
+    void disassembleFirstStringWithLexer() {
+        String s = "3+x*(2^4)";
+        List<Lexer.Token> tokens = new LinkedList<>();
+        tokens.add(new Lexer.Token(Lexer.TokenType.NUMBER,"3"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"+"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.VARIABLE,"x"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"*"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"("));
+        tokens.add(new Lexer.Token(Lexer.TokenType.NUMBER,"2"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"^"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.NUMBER,"4"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,")"));
+        try {
+            assertEquals(Lexer.lex(s),tokens);
+        }
+        catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    void disassembleSecondStringWithLexer() {
+        String s = "1 + (x^2 )- (3*x)";
+        List<Lexer.Token> tokens = new LinkedList<>();
+        tokens.add(new Lexer.Token(Lexer.TokenType.NUMBER,"1"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"+"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"("));
+        tokens.add(new Lexer.Token(Lexer.TokenType.VARIABLE,"x"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"^"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.NUMBER,"2"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,")"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"-"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"("));
+        tokens.add(new Lexer.Token(Lexer.TokenType.NUMBER,"3"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,"*"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.VARIABLE,"x"));
+        tokens.add(new Lexer.Token(Lexer.TokenType.SPECIAL,")"));
+        try {
+            assertEquals(Lexer.lex(s),tokens);
+        }
+        catch(Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file

src/test/ParserTest.java

+package test;
+
+public class ParserTest {
+}