How to test for error paths and corner cases in JUnit?

I have code and I have to write JUnit tests for it. I already wrote test for happy path, but I have to write tests for corner cases and error paths. Can you help me with finding solution pls.

public String reverseWords(String input) {
    String oneOrMoreSpaces = "\\s+";
    String[] words = input.split(oneOrMoreSpaces);
    String completeAnagram = "";

    for (int i = 0; i < words.length; i++) {
        char[] symbol = words[i].toCharArray();
        char newSymbolSequence;
        int j = symbol.length - 1, k = 0;

        while (k < j) {
            if (!Character.isAlphabetic(symbol[k]))
                k++;
            else if (!Character.isAlphabetic(symbol[j]))
                j--;
            else {
                newSymbolSequence = symbol[k];
                symbol[k] = symbol[j];
                symbol[j] = newSymbolSequence;
                k++;
                j--;
            }
        }
        completeAnagram = new String(symbol);
    }
    return completeAnagram;
}

This feels like a homework question. The exercise is nice enough, though! The code seems to contain (at leats) one fault, making it interesting to see at which step you can discover this.

Some guidelines for addressing this type of problem:

1. You can only think about testing a method if you know what the functionality is supposed to be. The short answer here seems to be given a sentence, produce the sentence with each word reversed, but this could use some improvement.

2. Once you think you know what the method should do, you can come up with a series of example inputs and outputs. These will eventually be your test cases.

3. By producing examples, you can critically look for complicated ("corner"?) cases. What happens if there are no words? Should letters be treated the same as punctuation? What is the effect of reversing a one-letter word? You don't need any code for this, just an understanding of the application domain. Each of these questions may give rise to more examples.

4. Once you have enough examples, you can create test cases for them. Parameterized tests seem a natural fit.

5. With your requirements-driven test cases up and running, you can then analyze the implementation. Is every line / branch covered? Is there indeed a test case that exercises the else if branch in the middle of the code? If there is code that is not executed, go back to the requirements, and think which example would require this branch. Then add that example, until you have full coverage.

6. Once you have full branch coverage, you may try and deliberately introduce small mistakes in the code. If you replace a < by a <=, will one of your examples reveal this as a bug? If not, add such an example!

If you want to learn more, look for category-partition (step 3), branch coverage (step 5), and mutation coverage (step 6). For this, you can check out our open access online book Software Testing: From Theory to Practice, which includes videos, slides, and exercises. Enjoy!

If you need to verify on exceptions you can use Junit @test(expected=Yor exception)

ex :
obj need to be initialized in the class.

@Test(expected=NullPointerException.class)
public void testNullPonterException(){

String val = obj.reverseWords(null);

}

Otherwise you When you need to verify some other properties of the exception, we can use the ExpectedException rule.

@Rule
public ExpectedException exceptionRule = ExpectedException.none();
 
@Test
public void whentestNullPonterExceptionThrown_thenRuleIsApplied() {
    exceptionRule.expect(NullPointerException.class);
    exceptionRule.expectMessage("Invalid Input");
    String val = obj.reverseWords(null);
}

Common error and edge cases are that the input is null or an empty String.