Add final project implementation from Assignment 2

src/main/java/StringManipulation.java

@@ -1,33 +1,82 @@
 public class StringManipulation implements StringManipulationInterface {
+    private String string;
 
     @Override
     public String getString() {
-        return null;
+        return string;
     }
 
     @Override
     public void setString(String string) {
+        this.string = string;
     }
 
     @Override
     public int count() {
-        return 0;
+        if (string == null) {
+            return 0;
+        }
+        String[] words = string.trim().split("\\s+");
+        return words.length;
     }
 
     @Override
     public String removeNthCharacter(int n, boolean maintainSpacing) {
-        return null;
+        if (string == null) {
+            return null;
+        }
+        if (n <= 0) {
+            throw new IllegalArgumentException("n must be greater than zero");
+        }
+        if (n > string.length()) {
+            throw new IndexOutOfBoundsException("n exceeds string length");
+        }
+        StringBuilder result = new StringBuilder();
+        char[] chars = string.toCharArray();
+        int count = 0;
+        for (char c : string.toCharArray()) {
+            count++;
+            if (count % n != 0) {
+                result.append(c);
+            } else if (maintainSpacing) {
+                result.append(' ');
+            }
+        }
+        return result.toString();
     }
 
     @Override
-    public String[] getSubStrings(int startWord, int endWord) {
-        return null;
+    public String[] getSubStrings(int startWord, int endWord){
+        if (string == null) {
+            return null;
+        }
+        String[] words = string.trim().split("\\s+");
+        int numWords = words.length;
+
+        if (startWord <= 0 || endWord <= 0 || startWord > endWord) {
+            throw new IllegalArgumentException("Invalid startWord or endWord values");
+        }
+        if (endWord > numWords) {
+            throw new IndexOutOfBoundsException("The string has fewer than endWord words");
+        }
+        return java.util.Arrays.copyOfRange(words, startWord - 1, endWord);
     }
 
     @Override
     public String restoreString(int[] indices) {
-        return null;
+        if (string == null || indices == null || string.length() != indices.length) {
+            throw new IllegalArgumentException("Invalid arguments: string length must be equal to indices length");
+        }
+        char[] chars = string.toCharArray();
+        char[] restoredChars = new char[chars.length];
+        for (int i = 0; i < indices.length; i++) {
+            int index = indices[i];
+            if (index < 0 || index >= chars.length) {
+                throw new IndexOutOfBoundsException("Invalid index: indices[i] must be within the string length and unique");
+            }
+            restoredChars[i] = chars[index];
+        }
+        return new String(restoredChars);
     }
 
-
 }

src/test/java/StringManipulationTest.java

@@ -7,142 +7,192 @@
 
 public class StringManipulationTest {
 
-    private StringManipulationInterface manipulatedstring;
+    private StringManipulationInterface manipulatedString;
 
     @BeforeEach
     public void setUp() {
-        manipulatedstring = new StringManipulation();
+        manipulatedString = new StringManipulation();
     }
 
     @AfterEach
     public void tearDown() {
-        manipulatedstring = null;
+        manipulatedString = null;
     }
 
     @Test
     public void testCount1() {
-        manipulatedstring.setString("This is my string");
-        int length = manipulatedstring.count();
+        manipulatedString.setString("This is my string");
+        int length = manipulatedString.count();
         assertEquals(4, length);
     }
 
     @Test
     public void testCount2() {
-        fail("Not yet implemented");
+        manipulatedString.setString("I like video games");
+        int length = manipulatedString.count();
+        assertEquals(4, length);
     }
 
     @Test
     public void testCount3() {
-        fail("Not yet implemented");
+        manipulatedString.setString("What");
+        int length = manipulatedString.count();
+        assertEquals(1, length);
     }
 
     @Test
     public void testCount4() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Why there are so many test cases to create");
+        int length = manipulatedString.count();
+        assertEquals(9, length);
     }
 
     @Test
     public void testRemoveNthCharacter1() {
-        manipulatedstring.setString("I'd b3tt3r put s0me d161ts in this 5tr1n6, right?");
-        assertEquals("I' bttr uts0e 16tsinths trn6 rgh?", manipulatedstring.removeNthCharacter(3, false));
+        manipulatedString.setString("I'd b3tt3r put s0me d161ts in this 5tr1n6, right?");
+        assertEquals("I' bttr uts0e 16tsinths trn6 rgh?", manipulatedString.removeNthCharacter(3, false));
     }
 
     @Test
     public void testRemoveNthCharacter2() {
-        manipulatedstring.setString("I'd b3tt3r put s0me d161ts in this 5tr1n6, right?");
-        assertEquals("I'  b tt r  ut s0 e  16 ts in th s  tr n6  r gh ?", manipulatedstring.removeNthCharacter(3, true));
+        manipulatedString.setString("I'd b3tt3r put s0me d161ts in this 5tr1n6, right?");
+        assertEquals("I'  b tt r  ut s0 e  16 ts in th s  tr n6  r gh ?", manipulatedString.removeNthCharacter(3, true));
     }
 
     @Test
     public void testRemoveNthCharacter3() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Holy mama");
+        assertEquals("Hl aa", manipulatedString.removeNthCharacter(2, false));
     }
 
     @Test
     public void testRemoveNthCharacter4() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Holy mama");
+        assertEquals("H l   a a", manipulatedString.removeNthCharacter(2, true));
     }
 
     @Test
     public void testRemoveNthCharacter5() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Holy mama");
+        assertEquals("Hol  ma a", manipulatedString.removeNthCharacter(4, true));
     }
 
     @Test
     public void testRemoveNthCharacter6() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Exception testing1");
+        assertEquals("Don't mind this", manipulatedString.removeNthCharacter(0, true));
     }
 
     @Test
     public void testRemoveNthCharacter7() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Exception testing2");
+        assertEquals("Don't mind this", manipulatedString.removeNthCharacter(19, true));
     }
 
     @Test
     public void testGeSubStrings1() {
-        manipulatedstring.setString("This is my string");
-        String [] sStings = manipulatedstring.getSubStrings(3, 4);
+        manipulatedString.setString("This is my string");
+        String [] sStings = manipulatedString.getSubStrings(3, 4);
 
         assertEquals(sStings[0], "my");
         assertEquals(sStings[1], "string");
     }
 
     @Test
     public void testGeSubStrings2() {
-        fail("Not yet implemented");
+        manipulatedString.setString("This is my string");
+        String [] sStings = manipulatedString.getSubStrings(1, 2);
+
+        assertEquals(sStings[0], "This");
+        assertEquals(sStings[1], "is");
     }
     @Test
     public void testGeSubStrings3() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Why there are so many test cases to create");
+        String [] sStings = manipulatedString.getSubStrings(1, 2);
+
+        assertEquals(sStings[0], "Why");
+        assertEquals(sStings[1], "there");
     }
     @Test
     public void testGeSubStrings4() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Why there are so many test cases to create");
+        String [] sStings = manipulatedString.getSubStrings(1, 3);
+
+        assertEquals(sStings[0], "Why");
+        assertEquals(sStings[1], "there");
+        assertEquals(sStings[2], "are");
     }
     @Test
     public void testGeSubStrings5() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Why there are so many test cases to create");
+        String [] sStings = manipulatedString.getSubStrings(0, 6);
+
+        assertEquals(sStings[0], "many");
+        assertEquals(sStings[1], "test");
+        // Exception1
     }
     @Test
     public void testGeSubStrings6() {
-        fail("Not yet implemented");
+        manipulatedString.setString("Why there are so many test cases to create");
+        String [] sStings = manipulatedString.getSubStrings(5, 11);
+
+        assertEquals(sStings[0], "many");
+        assertEquals(sStings[1], "test");
+        assertEquals(sStings[2], "cases");
+        // Exception2
     }
 
     @Test
     public void testRestoreString1()
     {
-        manipulatedstring.setString("art");
+        manipulatedString.setString("art");
         int [] array;
         array=new int[]{1,0,2};
-        String restoreString = manipulatedstring.restoreString(array);
-        assertEquals(restoreString, "rat");
+        String restoreString = manipulatedString.restoreString(array);
+        assertEquals("rat", restoreString);
     }
 
     @Test
     public void testRestoreString2()
     {
-        fail("Not yet implemented");
-
+        manipulatedString.setString("art");
+        int [] array;
+        array=new int[]{2,0,1};
+        String restoreString = manipulatedString.restoreString(array);
+        assertEquals("tar", restoreString);
     }
 
     @Test
     public void testRestoreString3()
     {
-        fail("Not yet implemented");
+        manipulatedString.setString("art");
+        int [] array;
+        array=new int[]{2,1,0};
+        String restoreString = manipulatedString.restoreString(array);
+        assertEquals("tra", restoreString);
 
     }
 
     @Test
     public void testRestoreString4()
     {
-        fail("Not yet implemented");
+        manipulatedString.setString("art");
+        int [] array;
+        array=new int[]{1,0,2,3};
+        String restoreString = manipulatedString.restoreString(array);
+        assertEquals("Exception1", restoreString);
 
     }
 
     @Test
     public void testRestoreString5()
     {
-        fail("Not yet implemented");
+        manipulatedString.setString("art");
+        int [] array;
+        array=new int[]{1,5,2};
+        String restoreString = manipulatedString.restoreString(array);
+        assertEquals("Exception2", restoreString);
 
     }