Began adding Unit Tests

Author: lbenedetto

pom.xml

@@ -57,12 +57,6 @@
     </build>
 
     <dependencies>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit-dep</artifactId>
-            <version>4.10</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>
@@ -79,5 +73,11 @@
             <artifactId>forms_rt</artifactId>
             <version>7.0.3</version>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>RELEASE</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

src/main/java/jterm/command/Pause.java

@@ -30,7 +30,7 @@ public void execute(List<String> options) {
                 JTerm.out.println("Command syntax:\n\tpause [-h] [input]");
                 return;
             } else {
-                JTerm.out.print(Util.getRest(options, 0));
+                JTerm.out.print(Util.getAsString(options));
             }
         }
 

src/main/java/jterm/io/InputHandler.java

@@ -124,7 +124,7 @@ static void tabEvent() {
 
     static void newLineEvent() {
         lastArrowPress = Keys.NONE;
-        boolean empty = Util.containsOnlySpaces(command);
+        boolean empty = command.trim().isEmpty();
 
         ArrayList<String> prevCommands = getPrevCommands();
 
@@ -184,7 +184,7 @@ static void backspaceEvent() {
     private static void parse() {
         String[] commands = command.split("&&");
         for (String command : commands) {
-            command = Util.removeSpaces(command);
+            command = command.trim();
             JTerm.executeCommand(command);
         }
     }
@@ -287,7 +287,7 @@ private static String[] disassembleCommand(String command) {
         }
 
         // Remove spaces so that autocomplete can work properly
-        splitCommand[1] = Util.removeSpaces(splitCommand[1]);
+        splitCommand[1] = splitCommand[1].trim();
 
         return splitCommand;
     }

src/main/java/jterm/util/Util.java

@@ -4,6 +4,7 @@
 import jterm.io.InputHandler;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Scanner;
 
@@ -62,13 +63,7 @@ public static void clearLine(String line, int cursorPos, boolean clearPrompt) {
     }
 
     public static ArrayList<String> getAsArray(String options) {
-        try (Scanner tokenizer = new Scanner(options)) {
-            ArrayList<String> optionsArray = new ArrayList<>();
-            while (tokenizer.hasNext()) {
-                optionsArray.add(tokenizer.next());
-            }
-            return optionsArray;
-        }
+        return new ArrayList<>(Arrays.asList(options.split(" ")));
     }
 
     public static String getAsString(List<String> options) {
@@ -94,44 +89,6 @@ public static String getRest(List<String> options, int index) {
         return outputBuilder.toString();
     }
 
-    /**
-     * Removes blank space before and after command if any exists.
-     *
-     * @param command Command to parse
-     * @return Command without white space
-     */
-    public static String removeSpaces(String command) {
-        int fpos = 0;
-        for (int i = 0; i < command.length(); i++) {
-            if (command.charAt(i) == ' ')
-                fpos++;
-            else
-                break;
-        }
-
-        int bpos = command.length() > 0 ? command.length() : 0;
-        for (int i = command.length() - 1; i > 0; i--) {
-            if (command.charAt(i) == ' ')
-                bpos--;
-            else
-                break;
-        }
-
-        return command.substring(fpos, bpos);
-    }
-
-    /**
-     * Determines if a string is composed only of spaces.
-     *
-     * @param s string to check
-     * @return true if s is composed of only spaces, false if there is a character in it
-     */
-    public static boolean containsOnlySpaces(String s) {
-        return s.trim().isEmpty();
-    }
-    public static int shrinkToBounds(int i, int min, int max){
-        return  Math.min(Math.max(i, min), max);
-    }
     public static String getFullPath(String fileName) {
         if (!fileName.startsWith("/")) {
             fileName = JTerm.currentDirectory + "/" + fileName;

src/test/java/jterm/util/UtilTest.java

@@ -0,0 +1,72 @@
+package jterm.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UtilTest {
+    @Test
+    void getRunTime() {
+        assertEquals(Util.getRunTime(172799999), "1 days, 23 hours, 59 minutes, 59 seconds, 999 millis");
+    }
+
+    @Test
+    void clearLine() {
+    }
+
+    @Test
+    void getAsArray() {
+        assertEquals(Util.getAsArray("This function is just splitting on spaces"),
+                Arrays.asList("This", "function", "is", "just", "splitting", "on", "spaces"));
+    }
+
+    @Test
+    void getAsString() {
+        assertEquals("This function is just concatenating an array",
+                Util.getAsString(Arrays.asList("This", "function", "is", "just", "concatenating", "an", "array")));
+    }
+
+    @Test
+    void getRest() {
+        assertEquals("is just concatenating an array",
+                Util.getRest(Arrays.asList("This", "function", "is", "just", "concatenating", "an", "array"), 2));
+    }
+
+    @Test
+    void getFullPath() {
+    }
+
+    private void compareTimes(Runnable r1, Runnable r2) {
+        averageTimeOfExecution(r1);
+        long r1time = averageTimeOfExecution(r1);
+        randomBranches();
+        averageTimeOfExecution(r2);
+        long r2time = averageTimeOfExecution(r2);
+        System.out.println(String.format("R1: %d, R2: %d", r1time, r2time));
+    }
+
+    private void randomBranches(){
+        int rand = 0;
+        for(int i = 0; i < 10000; i++){
+            if(i+(Math.random() * 100) < i+(Math.random() * 100)){
+                rand++;
+            }else{
+                rand--;
+            }
+        }
+    }
+
+    private long averageTimeOfExecution(Runnable r) {
+        long before, after;
+        long total = 0;
+        for (int i = 0; i < 1000; i++) {
+            before = System.nanoTime();
+            r.run();
+            after = System.nanoTime();
+            total += after - before;
+        }
+        return total / 1000;
+    }
+}