FILL IN COMMENTED CODE MUST BE DONE IN JAVA

kage cis1968.stringPracticeAssignment; blic class StringPractice { returns true if c is one of the characters typically used to represent a "face card" in a * standard deck of playing cards. * These include: jack 'J' or 'j' queen 'Q' or 'q' king 'K' or 'k' ace 'A' or 'a */ public static boolean isFace(char c) { * placeholder just so that the function compiles. fill in your implementation here there is a similar placeholder for each of the remaining functions return true; returns the index of the first face-card letter in s or -1 if s contains no face-card letters public static int indexOfFirstFace (Strings) { return -1;) returns the index of the first occurrence of a face-card letter in s starting from index start Position or -1 if there are none at index startPosition or later. Notice that this method has the same name as the previous one, but that it takes a different number of arguments. This is perfectly legal in Java. It's called "method overloading" public static int indexOfFirstFace(String s, int startPosition) { return -1;) public static int indexOfFirstFace(String s) { return -1; returns the index of the first occurrence of a face-card letter in s starting from index startPosition or -1 if there are none at index startPosition or later. Notice that this method has the same name as the previous one, but that it takes a different number of arguments. This is perfectly legal in Java. It's called "method overloading" */ public static int indexOfFirstFace(String s, int startPosition) { return -1; ) * returns the index of the last occurrence of a face-card letter in s or -1 if s contains none * public static int indexOfLastFace(String s) { return -1; ) returns s in reverse. For example, if s is "Apple", the method returns the String "elppA" public static String reversed(String s) { return ;) returns the number of times that n occurs in h. For example, if h is "Mississippi" and n is * "ss" the method returns 2. public static int numOccurrences (String h, String n) { return 0; } * returns true if s is the same backwards and forwards and false otherwise public static boolean sameInReverse(Strings) { return true;) String Practice > indexOfLastFace USTU667 String PracticeAssignment) - String Practice, je indexOfLastFace UCLIS dvd package cis1068.stringPracticeAssignment import public class StringPracticeTest extends StringPractice { @Test public void testIsFace() { assert True(StringPractice.isface'a')); assert True(StringPractice.isFace('A')); assert True(String Practice.isFace('k')); assert True(StringPractice.isFace('K')); assert True(StringPractice.isFace(',')); assert True(StringPractice.isFace('A')); assertTrue(StringPractice.isFace('j')); assert True(StringPractice.isFace('J')); assertFalse(StringPractice.isFace('f')); assert False(StringPractice.isFace('G')); assertFalse(String Practice.isFace('@')); @Test public void testIndexOfFirst FaceString() { assertEquals(-1, String Practice.indexOfFirst Face("")); assertEquals(@, String Practice.indexOfFirstFace("abalone")); assertEquals(6, String Practice.indexOfFirstFace("trepidation")); assertEquals(3, StringPractice.indexOfFirstFace("workbook")); @Test public void testIndexOfFirst FaceStringInt() { String Practice Test testisFace MyCULETEL dva X public void testIndexOfFirstFaceStringInt() assertEquals(1, StringPractice.indexOfFirstFace("squidward")); assertEquals(1, StringPractice.indexOfFirstFace("SQUIDWARD")); assertEquals(2, StringPractice.indexOfFirstFace("vikinglike")); assertEquals(2, StringPractice.indexOfFirstFace("VIKINGLIKE")); assertEquals(e, StringPractice.indexOfFirstFace("kafkaesque")); assertEquals(@, String Practice.indexOfFirstFace("KAFKAESQUE")); assertEquals(-1, StringPractice.indexOfFirstFace("homer")); @Test public void testIndexOfLastFace() { assertEquals(6, String Practice.indexOfLast Face("squidward")); assertEquals(6, StringPractice.indexOfLastFace("SQUIDWARD")); assertEquals(8, StringPractice.indexOfLast Face("vikinglike")); assertEquals(8, StringPractice.indexOfLastFace("VIKINGLIKE")); assertEquals(7, String Practice.indexOfLastFace("kafkaesque")); assertEquals(7, StringPractice.indexOfLastFace("KAFKAESQUE")); assertEquals(-1, String Practice.indexOfLastFace("homer")); @Test public void testReversed() { assertEquals("cba", StringPractice.reversed("abc")); assertEquals("a", String Practice.reversed(""); assertEquals("dcba", String Practice.reversed("abcd"); } @Test public void testNumOccurrences() { assertEquals(2, String Practice. numOccurrences ("banana", "na")); String Practice Test testisface public void testNumoccurrences() { assertEquals(2, StringPractice.numOccurrences ("banana", "na")); assertEquals(2, StringPractice.numoccurrences ("mississippi", "ss")); assertEquals(@, StringPractice.numoccurrences("undertow", "sushi")); @Test public void testSameInReverse() { assert True(StringPractice. sameInReverse("peep")); assert True(String Practice. same InReverse("madam")); assert True(StringPractice. same InReverse("rotator")); assertFalse(StringPractice. same InReverse("blue")); assertFalse(StringPractice. Same InReverse("aspirin")); assertFalse(StringPractice.sameInReverse("ab")); assertTrue(StringPractice. Same In Reverse("a")); } @Test public void testWithout Faces() assertEquals("suidwrd", StringPractice.withoutFaces ("squidward")); assertEquals("SUIDWRD", StringPractice without Faces("SQUIDWARD")); assertEquals("viinglie", StringPractice withoutFaces ("vikinglike")); assertEquals("VIINGLIE", StringPractice.without Faces ("VIKINGLIKE")); assertEquals("fesue", StringPractice without Faces ("kafkaesque") assertEquals("FESUE", StringPractice without Faces("KAFKAESQUE")); assertEquals("homer", StringPractice without Faces ("homer")); @Test public void test ContainsOnlyFaces() { assertTrue(StringPractice.containsOnlyFaces ("kQij")); String Practice Test test WithoutFaces Test public void test ContainsOnlyFaces() { assertTrue(String Practice.containsOnlyFaces ("kQjj")); assertTrue(StringPractice.containsOnlyFaces ("JAK")); assertFalse(String Practice.containsOnlyFaces ("spring break")); assertFalse(StringPractice.containsOnlyFaces("temple")); @Test public void testContains NoFaces() { assert True(String Practice.contains NoFaces ("beguile")); assert True(String Practice.contains NoFaces("chess")); assert True(StringPractice.containsNoFaces ("cider"); assert True(StringPractice.contains NoFaces ("unsupported")); assert True(String Practice.contains NoFaces ("visitor")); assert False(StringPractice.contains NoFaces("viking")); assertFalse(String Practice.contains NoFaces("ajax")); @Test public void testLastFirst() { assertEquals("Sqigmann, Andrew", String Practice.lastFirst("Andrew Sqigmann")); assertEquals("Squarepants, Spongebob", String Practice.lastFirst("Spongebob Squarepants" assertEquals("Pines, Stanley", StringPractice.last First("Stanley Pines"))