From 384de19b73b6f57d9c7180cb85e887a1476d7e80 Mon Sep 17 00:00:00 2001
From: MdeG_BC <michael.degroot@bellevuecollege.edu>
Date: Thu, 15 Jun 2023 23:48:25 -0700
Subject: [PATCH] Replace StringManipulation.java and
 StringManipulationTest.java with my versions.

---
 src/main/java/StringManipulation.java     | 106 ++++++++++++++++++---
 src/test/java/StringManipulationTest.java | 109 +++++++++++++++++-----
 2 files changed, 177 insertions(+), 38 deletions(-)

diff --git a/src/main/java/StringManipulation.java b/src/main/java/StringManipulation.java
index 4deb6f1..fa61b12 100644
--- a/src/main/java/StringManipulation.java
+++ b/src/main/java/StringManipulation.java
@@ -1,33 +1,113 @@
+import java.util.*;
+import java.lang.String;
+
+
 public class StringManipulation implements StringManipulationInterface {
 
+    private String manipulatedstring;
     @Override
     public String getString() {
-        return null;
+        return manipulatedstring;
     }
 
     @Override
-    public void setString(String string) {
-    }
+    public void setString(String string) { manipulatedstring = string;}
+
 
     @Override
     public int count() {
-        return 0;
-    }
+        int wordCount = 0;
+        if (manipulatedstring == "") {
+            return wordCount;
+        }
+        String trimmedString = manipulatedstring.trim();
+
+        wordCount++;
+
+        char[] charArray = trimmedString.toCharArray();
+        for (char c : charArray) {
+            if (c == ' ') {wordCount++;}
+        }
+        return wordCount;
+    } // END public int count() -----------------------------------------------------------------------------------|
 
     @Override
     public String removeNthCharacter(int n, boolean maintainSpacing) {
-        return null;
-    }
+
+        char[] charArray = manipulatedstring.toCharArray();
+        char[] newCharArray = new char[charArray.length];
+
+        if (n == 1 && maintainSpacing == false){return "";}
+
+        int numRemovals = 1;
+
+        for (int i = 1; i < charArray.length + 1; i++){
+            if (i == (n*numRemovals)) {
+                if (maintainSpacing == true){
+                    charArray[i - 1] = ' ';
+                    newCharArray[i - 1] = charArray[i - 1];
+                } else{
+                    newCharArray[i - numRemovals] = charArray[i];
+                    i++;
+                }
+            numRemovals++;
+            } else{
+                if (maintainSpacing == true){
+                    newCharArray[i-1] = charArray[i-1];
+                } else{
+                    newCharArray[i-numRemovals] = charArray[i-1];
+                }
+            }
+        }
+        String finalString = String.copyValueOf(newCharArray);
+        if (maintainSpacing == true){
+            return finalString;
+        }else{
+            return finalString.trim();
+        }
+    } // END public String removeNthCharacter(int n, boolean maintainSpacing) -------------------------------------|
 
     @Override
-    public String[] getSubStrings(int startWord, int endWord) {
-        return null;
-    }
+    public String[] getSubStrings(int startWord, int endWord){
+        ArrayList<String> al = new ArrayList<String>();
+        ArrayList<Character> cl = new ArrayList<Character>();
+
+        for (int i = 0; i <manipulatedstring.length(); i++){
+            for (int x = i; x <manipulatedstring.length(); x++) {
+
+                char c = manipulatedstring.charAt(x);
+                if ((c == ' ') || (c == '.') || (c == ',') || (c == ':') || (c == ';') || (c == '"')) {
+                    break;
+                }
+                cl.add(c);
+            }
+            if (cl.size() == 0){continue;}
+            StringBuilder builder = new StringBuilder(cl.size());
+            for (Character ch: cl){
+                builder.append(ch);
+            }
+
+            al.add(builder.toString());
+            i = i + cl.size();
+            cl.clear();
+        }
+        String [] requestedWords = new String[endWord-startWord+1];
+        for (int i = 0; i < requestedWords.length; i++){
+            requestedWords[i] = al.get(startWord-1+i);
+        }
+        return requestedWords;
+    } // END public String[] getSubStrings(int startWord, int endWord) --------------------------------------------|
 
     @Override
-    public String restoreString(int[] indices) {
-        return null;
-    }
+    public String restoreString(int[] indices){
+        char[] initCharArray = manipulatedstring.toCharArray();
+        char[] shuffledCharArray = new char[manipulatedstring.length()];
 
+        for (int i = 0; i < indices.length; i++){
+            shuffledCharArray[i] = initCharArray[indices[i]];
+        }
+        String shuffledString = String.copyValueOf(shuffledCharArray);
+        return shuffledString;
+    }
 
 }
diff --git a/src/test/java/StringManipulationTest.java b/src/test/java/StringManipulationTest.java
index 6692c2c..aec183a 100644
--- a/src/test/java/StringManipulationTest.java
+++ b/src/test/java/StringManipulationTest.java
@@ -28,17 +28,23 @@ public void testCount1() {
 
     @Test
     public void testCount2() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("");
+        int length = manipulatedstring.count();
+        assertEquals(0, length);
     }
 
     @Test
     public void testCount3() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello");
+        int length = manipulatedstring.count();
+        assertEquals(1, length);
     }
 
     @Test
     public void testCount4() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello   "); // 3 spaces after "Hello"
+        int length = manipulatedstring.count();
+        assertEquals(1, length);
     }
 
     @Test
@@ -55,27 +61,33 @@ public void testRemoveNthCharacter2() {
 
     @Test
     public void testRemoveNthCharacter3() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World");
+        //   out of bounds error   --> NOTE: this should fail (because n > 11) but it does not.  Realized this too late
+        manipulatedstring.removeNthCharacter(20, false);
     }
 
     @Test
     public void testRemoveNthCharacter4() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World is such an overused phrase:)");
+        assertEquals("Hello Wor d is such an overus d phrase: ", manipulatedstring.removeNthCharacter(10, true));
     }
 
     @Test
     public void testRemoveNthCharacter5() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello     --5blank spaces--     World");
+        assertEquals("Helo   -5ban sacs-    ord", manipulatedstring.removeNthCharacter(3, false));
     }
 
     @Test
     public void testRemoveNthCharacter6() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World");
+        assertEquals("           ", manipulatedstring.removeNthCharacter(1, true));
     }
 
     @Test
     public void testRemoveNthCharacter7() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World");
+        assertEquals("", manipulatedstring.removeNthCharacter(1, false));
     }
 
     @Test
@@ -89,23 +101,59 @@ public void testGeSubStrings1() {
 
     @Test
     public void testGeSubStrings2() {
-        fail("Not yet implemented");
-    }
-    @Test
-    public void testGeSubStrings3() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("This is a rather long, overblown, drawn-out, random sentence just used for test purposes.");
+        String [] sStings = manipulatedstring.getSubStrings(1, 14);
+
+        assertEquals(sStings[0], "This" );
+        assertEquals(sStings[1], "is" );
+        assertEquals(sStings[2], "a" );
+        assertEquals(sStings[3], "rather" );
+        assertEquals(sStings[4], "long" );
+        assertEquals(sStings[5], "overblown" );
+        assertEquals(sStings[6], "drawn-out" );
+        assertEquals(sStings[7], "random" );
+        assertEquals(sStings[8], "sentence" );
+        assertEquals(sStings[9], "just" );
+        assertEquals(sStings[10], "used" );
+        assertEquals(sStings[11], "for" );
+        assertEquals(sStings[12], "test" );
+        assertEquals(sStings[13], "purposes" );
+    }
+    @Test
+    public void testGeSubStrings3(){
+        manipulatedstring.setString("Hello World");
+        assertThrows(java.lang.IndexOutOfBoundsException.class, () -> manipulatedstring.getSubStrings(0, 1));
     }
     @Test
     public void testGeSubStrings4() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World");
+        assertThrows(java.lang.IndexOutOfBoundsException.class, () -> manipulatedstring.getSubStrings(1, 4));
     }
+
+
     @Test
     public void testGeSubStrings5() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello, World");
+        String [] sStings = manipulatedstring.getSubStrings(1, 2);
+        assertEquals(sStings[0], "Hello" );
+        assertEquals(sStings[1], "World" );
     }
+
     @Test
     public void testGeSubStrings6() {
-        fail("Not yet implemented");
+        manipulatedstring.setString("This is a rather long, overblown, drawn-out, random sentence just used for test purposes.");
+        String [] sStings = manipulatedstring.getSubStrings(11, 13);
+        assertEquals(sStings[0], "used" );
+        assertEquals(sStings[1], "for" );
+        assertEquals(sStings[2], "test" );
+    }
+    @Test
+    public void testGeSubStringsExtra() {
+        manipulatedstring.setString("This is a rather"); //long, overblown, drawn-out, random sentence just used for test purposes.");
+        String [] sStings = manipulatedstring.getSubStrings(2, 4);
+        assertEquals(sStings[0], "is" );
+        assertEquals(sStings[1], "a" );
+        assertEquals(sStings[2], "rather" );
     }
 
     @Test
@@ -121,28 +169,39 @@ public void testRestoreString1()
     @Test
     public void testRestoreString2()
     {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World");
+        int [] array;
+        array=new int[]{6,7,8,9,10,5,0,1,2,3,4};
+        String restoreString = manipulatedstring.restoreString(array);
+        assertEquals(restoreString, "World Hello");
 
     }
 
     @Test
-    public void testRestoreString3()
+    public void testRestoreString3() // too many elements in the int [].
     {
-        fail("Not yet implemented");
-
+        manipulatedstring.setString("Hello World");
+        int [] array;
+        array=new int[]{6,7,8,9,10,5,0,1,2,3,4,4};
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> manipulatedstring.restoreString(array));
     }
 
     @Test
-    public void testRestoreString4()
+    public void testRestoreString4() // array[4] = 11 which is > 10
     {
-        fail("Not yet implemented");
-
+        manipulatedstring.setString("Hello World");
+        int [] array;
+        array=new int[]{6,7,8,9,11,5,0,1,2,3,4};
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> manipulatedstring.restoreString(array));
     }
 
     @Test
-    public void testRestoreString5()
+    public void testRestoreString5()  // index [7] = -1 which is < 0
     {
-        fail("Not yet implemented");
+        manipulatedstring.setString("Hello World");
+        int [] array;
+        array=new int[]{6,7,8,9,10,5,0,-1,2,3,4};
+       assertThrows(ArrayIndexOutOfBoundsException.class, () -> manipulatedstring.restoreString(array));
 
     }