Java 2

Week 4

Software Development Life Cycle, Steps 4-5

Fraction Project

5. Testing

Inside the FractionCalculator class, create a method that takes in a String input and returns a String[] array output.
The purpose of this method is to split the user input string into three parts: first fraction, operator, and second fraction.
The method will throw an IllegalArgumentException if the input format or operator is invalid.
To distinguish a division symbol / from a fraction, we will require that mathematical operators are surrounded by spaces.

/**
 * Splits the user input string into three parts: first fraction, operator, and second fraction.
 *
 * @param input the raw input string from the user.
 * @return a String array of size 3.
 * @throws IllegalArgumentException if the input format or operator is invalid.
 */
private static String[] splitCalculation(String input) {
    return new String[]{};
}

5. Testing

Create a FractionCalculatorTest class.
This class does not need an @BeforeEach setup() method, because we will only be testing static methods.
Write tests for the splitCalculation method.
Start by testing addition.
I will discuss Arrange, Act, and Assert on the next slide.

@Test
@DisplayName("Test splitCalculation with addition operator")
void splitCalculationWithAddition() {
    // Arrange
    String input = "1/2 + 3/4";
    String[] expected = {"1/2", "+", "3/4"};

    // Act
    String[] actual = FractionCalculator.splitCalculation(input);

    // Assert
    assertArrayEquals(expected, actual);
}

5. Testing

The Arrange, Act, Assert (AAA) pattern is a widely adopted structure for writing clear and effective unit tests. It divides a unit test into three distinct phases:
Arrange: In this phase, the necessary preconditions and inputs for the test are set up. This includes creating and configuring objects, initializing data, and establishing the expected values to be returned.
Act: This phase involves executing the specific method being tested. The result is the actual value returned from the method.
Assert: This phase involves using assertion methods to confirm whether the code under test behaved as intended.
By following the AAA pattern, unit tests become more readable, maintainable, and focused.

5. Testing

Next, test subtraction.
Test a mixed number as the first fraction.

@Test
@DisplayName("Test splitCalculation with subtraction operator and mixed numbers")
void splitCalculationWithSubtractionAndMixedNumbers() {
    // Arrange
    String input = "3 1/4 - 1/2";
    String[] expected = {"3 1/4", "-", "1/2"};

    // Act
    String[] actual = FractionCalculator.splitCalculation(input);

    // Assert
    assertArrayEquals(expected, actual);
}

5. Testing

Next, test multiplication.
Test a mixed number as the second fraction.
Test negative fractions

@Test
@DisplayName("Test splitCalculation with multiplication and negative numbers")
void splitCalculationWithMultiplicationAndNegatives() {
    // Arrange
    String input = "-5 * -2 1/3";
    String[] expected = {"-5", "*", "-2 1/3"};

    // Act
    String[] actual = FractionCalculator.splitCalculation(input);

    // Assert
    assertArrayEquals(expected, actual);
}

5. Testing

Next, test division.

@Test
@DisplayName("Test splitCalculation with division operator")
void splitCalculationWithDivision() {
    // Arrange
    String input = "10/3 / 5";
    String[] expected = {"10/3", "/", "5"};

    // Act
    String[] actual = FractionCalculator.splitCalculation(input);

    // Assert
    assertArrayEquals(expected, actual);
}

5. Testing

Next, test for extra spaces that need to be trimmed.

@Test
@DisplayName("Test splitCalculation with extra spaces in input")
void splitCalculationWithExtraSpaces() {
    // Arrange
    String input = "  1/2   +   3/4  ";
    String[] expected = {"1/2", "+", "3/4"};

    // Act
    String[] actual = FractionCalculator.splitCalculation(input);

    // Assert
    assertArrayEquals(expected, actual);
}

5. Testing

Next, test for invalid input due to a lack of space around the operator.
If the method throws multiple exceptions for various reasons, you may want to use the Exception returned from the assertThrows method to verify that the correct error message was thrown.

@Test
@DisplayName("Test splitCalculation with no spaces around operator should throw exception")
void splitCalculationWithNoSpacesAroundOperator() {
    // Arrange
    String input = "1/2+3/4";

    // Act & Assert
    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
        FractionCalculator.splitCalculation(input);
    });

    String expectedMessage = "Invalid format. Ensure operator (+, -, *, /) has a space on both sides.";
    String actualMessage = exception.getMessage();
    assertTrue(actualMessage.contains(expectedMessage));
}

5. Testing

Next, test for invalid input due to a lack of space around the operator.
If the method throws multiple exceptions for various reasons, you may want to use the Exception returned from the assertThrows method to verify that the correct error message was thrown.

@Test
@DisplayName("Test splitCalculation with no spaces around operator should throw exception")
void splitCalculationWithNoSpacesAroundOperator() {
    // Arrange
    String input = "1/2+3/4";

    // Act & Assert
    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
        FractionCalculator.splitCalculation(input);
    });

    String expectedMessage = "Invalid format.";
    String actualMessage = exception.getMessage();
    assertTrue(actualMessage.contains(expectedMessage));
}

5. Testing

Next, test for an invalid operator.

@Test
@DisplayName("Test splitCalculation with unknown operator should throw exception")
void splitCalculationWithUnknownOperator() {
    // Arrange
    String input = "1/2 ^ 3/4";

    // Act & Assert
    assertThrows(IllegalArgumentException.class, () -> {
        FractionCalculator.splitCalculation(input);
    });
}

5. Testing

Next, test for a missing fraction.

@Test
@DisplayName("Test splitCalculation with missing first fraction should throw exception")
void splitCalculationWithMissingFirstFraction() {
    // Arrange
    String input = " + 3/4";

    // Act & Assert
    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
        FractionCalculator.splitCalculation(input);
    });

    String expectedMessage = "Missing the first fraction";
    String actualMessage = exception.getMessage();
    assertTrue(actualMessage.contains(expectedMessage));
}

@Test
@DisplayName("Test splitCalculation with missing second fraction should throw exception")
void splitCalculationWithMissingSecondFraction() {
    // Arrange
    String input = "1/2 + ";

    // Act & Assert
    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
        FractionCalculator.splitCalculation(input);
    });

    String expectedMessage = "Missing the second fraction";
    String actualMessage = exception.getMessage();
    assertTrue(actualMessage.contains(expectedMessage));
}

Final Code Mon-Wed

@Test
void splitCalculationWithAddition() {
    // Arrange - define input and expected outputs
    String input = "1/2 + 3/4";
    String[] expected = {"1/2", "+", "3/4"};
    // Act - call the method to be tested
    String[] actual = FractionCalculator.splitCalculation(input);
    // Assert - call one of the assert methods
    assertArrayEquals(expected, actual);
}

@Test
void splitCalculationWithSubtraction() {
    // Arrange - define input and expected outputs
    String input = "3 1/4 - 1/2";
    String[] expected = {"3 1/4", "-", "1/2"};
    // Act - call the method to be tested
    String[] actual = FractionCalculator.splitCalculation(input);
    // Assert - call one of the assert methods
    assertArrayEquals(expected, actual);
}

@Test
void splitCalculationWithMultiplication() {
    // Arrange - define input and expected outputs
    String input = "-5 * -2 1/3";
    String[] expected = {"-5", "*", "-2 1/3"};
    // Act - call the method to be tested
    String[] actual = FractionCalculator.splitCalculation(input);
    // Assert - call one of the assert methods
    assertArrayEquals(expected, actual);
}

@Test
void splitCalculationWithDivision() {
    // Arrange - define input and expected outputs
    String input = "10/3 / 5";
    String[] expected = {"10/3", "/", "5"};
    // Act - call the method to be tested
    String[] actual = FractionCalculator.splitCalculation(input);
    // Assert - call one of the assert methods
    assertArrayEquals(expected, actual);
}


@Test
void splitCalculationTooManySpaces() {
    // Arrange - define input and expected outputs
    String input = "     10/3     /    5     ";
    String[] expected = {"10/3", "/", "5"};
    // Act - call the method to be tested
    String[] actual = FractionCalculator.splitCalculation(input);
    // Assert - call one of the assert methods
    assertArrayEquals(expected, actual);
}

@Test
void splitCalculationNoSpacesAroundOperator() {
    // Arrange - define input and expected outputs
    String input = "10/3/5";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> FractionCalculator.splitCalculation(input));

    // Arrange
    String expectedError = "Invalid format";
    // Act
    String actualError = e.getMessage();
    // Assert
    assertTrue(actualError.contains(expectedError));
}

@Test
void splitCalculationInvalidOperator1() {
    // Arrange - define input and expected outputs
    String input = "10/3 ! 5";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> FractionCalculator.splitCalculation(input));

    // Arrange
    String expectedError = "Invalid format";
    // Act
    String actualError = e.getMessage();
    // Assert
    assertTrue(actualError.contains(expectedError));
}

@Test
void splitCalculationInvalidOperator2() {
    // Arrange - define input and expected outputs
    String input = "10/3 x 5";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> FractionCalculator.splitCalculation(input));

    // Arrange
    String expectedError = "Invalid format";
    // Act
    String actualError = e.getMessage();
    // Assert
    assertTrue(actualError.contains(expectedError));
}

@Test
void splitCalculationFirstFractionMissing() {
    // Arrange - define input and expected outputs
    String input = " / 5";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> FractionCalculator.splitCalculation(input));

    // Arrange
    String expectedError = "Missing fraction";
    // Act
    String actualError = e.getMessage();
    // Assert
    assertTrue(actualError.contains(expectedError));
}

@Test
void splitCalculationSecondFractionMissing() {
    // Arrange - define input and expected outputs
    String input = "5 / ";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> FractionCalculator.splitCalculation(input));

    // Arrange
    String expectedError = "Missing fraction";
    // Act
    String actualError = e.getMessage();
    // Assert
    assertTrue(actualError.contains(expectedError));
}

Final Code Tue-Thr

@Test
void splitInputWithAddition() {
    // Arrange
    String input = "1/2 + 3/4";
    String[] expected = {"1/2", "+", "3/4"};
    // Act
    String[] actual = MarcsFractionCalculator.splitInput(input);
    // Assert
    assertArrayEquals(expected, actual);
}

@Test
@DisplayName("Test splitCalculation with subtraction operator and mixed numbers")
void splitCalculationWithSubtractionAndMixedNumbers() {
    // Arrange
    String input = "3 1/4 - 1/2";
    String[] expected = {"3 1/4", "-", "1/2"};
    // Act
    String[] actual = MarcsFractionCalculator.splitInput(input);
    // Assert
    assertArrayEquals(expected, actual);
}

@Test
@DisplayName("Test splitCalculation with multiplication and negative numbers")
void splitCalculationWithMultiplicationAndNegatives() {
    // Arrange
    String input = "-5 * -2 1/3";
    String[] expected = {"-5", "*", "-2 1/3"};
    // Act
    String[] actual = MarcsFractionCalculator.splitInput(input);
    // Assert
    assertArrayEquals(expected, actual);
}

@Test
@DisplayName("Test splitCalculation with division operator")
void splitCalculationWithDivision() {
    // Arrange
    String input = "10/3 / 5";
    String[] expected = {"10/3", "/", "5"};
    // Act
    String[] actual = MarcsFractionCalculator.splitInput(input);
    // Assert
    assertArrayEquals(expected, actual);
}

@Test
@DisplayName("Test splitCalculation with extra spaces in input")
void splitCalculationWithExtraSpaces() {
    // Arrange
    String input = "  1/2   +   3/4  ";
    String[] expected = {"1/2", "+", "3/4"};

    // Act
    String[] actual = MarcsFractionCalculator.splitInput(input);

    // Assert
    assertArrayEquals(expected, actual);
}

@Test
void splitInputWithNoSpacesAroundOperator() {
    //Arrange
    String input = "1/2+3/4";
    // Act and Assert
    Executable actual = () -> MarcsFractionCalculator.splitInput(input);
    // Assert
    Exception e = assertThrows(IllegalArgumentException.class, actual);

    // Arrange
    String expectedErrorMsg = "Invalid format";
    //Act
    String actualErrorMsg = e.getMessage();
    assertTrue(actualErrorMsg.contains(expectedErrorMsg));
}

@Test
void splitInputWithInvalidOperator() {
    //Arrange
    String input = "1/2 ! 3/4";
    // Act and Assert
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.splitInput(input));
}

@Test
void splitInputWithInvalidFraction1() {
    //Arrange
    String input = " + 3/4";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.splitInput(input));

    //Arrage
    String expectedErrorMsg = "First fraction is required";
    //Act
    String actualErrorMsg = e.getMessage();
    //Assert
    assertEquals(expectedErrorMsg, actualErrorMsg);
}

@Test
void splitInputWithInvalidFraction2() {
    //Arrange
    String input = "1/2 + ";
    // Act and Assert
    Exception e = assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.splitInput(input));

    //Arrage
    String expectedErrorMsg = "Second fraction is required";
    //Act
    String actualErrorMsg = e.getMessage();
    //Assert
    assertEquals(expectedErrorMsg, actualErrorMsg);
}

4. Coding

Implement code to pass the tests.
This code checks if the input contains a +, -, *, or / surrounded by spaces.
If not, it throws an IllegalArgumentException.
If yes, it sets the operator string and determines the string index of the operator.

/**
 * Splits the user input string into three parts: first fraction, operator, and second fraction.
 *
 * @param input the raw input string from the user.
 * @return a String array of size 3.
 * @throws IllegalArgumentException if the input format or operator is invalid.
 */
private static String[] splitCalculation(String input) {
	String operator = null;
    int operatorIndex = -1;
    
    // Find the operator with spaces around it to correctly handle negative numbers
    if (input.contains(" + ")) {
        operator = "+";
        operatorIndex = input.indexOf(" + ");
    } else if (input.contains(" - ")) {
        operator = "-";
        operatorIndex = input.indexOf(" - ");
    } else if (input.contains(" * ")) {
        operator = "*";
        operatorIndex = input.indexOf(" * ");
    } else if (input.contains(" / ")) {
        operator = "/";
        operatorIndex = input.indexOf(" / ");
    }
    
    if (operator == null) {
        throw new IllegalArgumentException("Invalid format. Ensure operator (+, -, *, /) has a space on both sides.");
    }
    
    return new String[]{};
}

4. Coding

Use the String class substring method to obtain the two fraction strings using the index of the operator.
Call the String class trim method to remove any extra white space.
If either String is an empty string, throw an exception.
All nine unit tests should pass.

/**
 * Splits the user input string into three parts: first fraction, operator, and second fraction.
 *
 * @param input the raw input string from the user.
 * @return a String array of size 3.
 * @throws IllegalArgumentException if the input format or operator is invalid.
 */
private static String[] splitCalculation(String input) {
	String operator = null;
    int operatorIndex = -1;
    
    // Find the operator with spaces around it to correctly handle negative numbers
    if (input.contains(" + ")) {
        operator = "+";
        operatorIndex = input.indexOf(" + ");
    } else if (input.contains(" - ")) {
        operator = "-";
        operatorIndex = input.indexOf(" - ");
    } else if (input.contains(" * ")) {
        operator = "*";
        operatorIndex = input.indexOf(" * ");
    } else if (input.contains(" / ")) {
        operator = "/";
        operatorIndex = input.indexOf(" / ");
    }
    
    if (operator == null) {
        throw new IllegalArgumentException("Invalid format. Ensure operator (+, -, *, /) has a space on both sides.");
    }
    
    String fractionStr1 = input.substring(0, operatorIndex).trim();
    String fractionStr2 = input.substring(operatorIndex + 3).trim(); // +3 to skip operator and spaces

    if (fractionStr1.isEmpty()) {
        throw new IllegalArgumentException("Missing the first fraction in the calculation.");
    }

    if (fractionStr2.isEmpty()) {
        throw new IllegalArgumentException("Missing the second fraction in the calculation.");
    }

    return new String[]{fractionStr1, operator, fractionStr2};
}

Final Code Mon-Wed

/**
 * Splits the user input string into three parts: fraction 1, operator, fraction 2
 * @param input the raw input string from the user
 * @return a String[] array of size 3
 * @throws IllegalArgumentException if the input format or operator is invalid
 */
public static String[] splitCalculation(String input) {
    String operator = "";
    int operatorIndex = -1;

    if(input.contains(" + ")) {
        operator = "+";
        operatorIndex = input.indexOf(" + ");
    } else if(input.contains(" - ")) {
        operator = "-";
        operatorIndex = input.indexOf(" - ");
    } else if(input.contains(" * ")) {
        operator = "*";
        operatorIndex = input.indexOf(" * ");
    } else if(input.contains(" / ")) {
        operator = "/";
        operatorIndex = input.indexOf(" / ");
    }

    if(operatorIndex == -1) {
        throw new IllegalArgumentException("Invalid format. Ensure operator (+, -, *, /) has a space on both sides.");
    }

    String fraction1 = input.substring(0, operatorIndex).trim();
    String fraction2 = input.substring(operatorIndex + 3).trim();
    
    if(fraction1.isEmpty()) {
        throw new IllegalArgumentException("Missing fraction 1.");
    }

    if(fraction2.isEmpty()) {
        throw new IllegalArgumentException("Missing fraction 2.");
    }
    
    return new String[]{fraction1, operator, fraction2};
}

Final Code Tue-Thr

/**
 * Split the user input into three parts: fraction 1, operator, fraction 2
 *
 * @param input the raw input string from the user
 * @return String[] array with three Strings
 * @throws IllegalArgumentException if input or operator are invalid
 */
public static String[] splitInput(String input) {
    String operator = "";
    int operatorIndex = -1;
    if(input.contains(" + ")) {
        operator = "+";
        operatorIndex = input.indexOf(" + ");
    } else if(input.contains(" - ")) {
        operator = "-";
        operatorIndex = input.indexOf(" - ");
    } else if(input.contains(" * ")) {
        operator = "*";
        operatorIndex = input.indexOf(" * ");
    } else if(input.contains(" / ")) {
        operator = "/";
        operatorIndex = input.indexOf(" / ");
    }

    if(operatorIndex == -1) {
        throw new IllegalArgumentException("Invalid format. Ensure operator (+, -, *, /) has space on both sides.");
    }

    String fraction1 = input.substring(0, operatorIndex).trim();
    String fraction2 = input.substring(operatorIndex + 3).trim();

    if(fraction1.isEmpty()) {
        throw new IllegalArgumentException("First fraction is required");
    }
    if(fraction2.isEmpty()) {
        throw new IllegalArgumentException("Second fraction is required");
    }

    return new String[]{fraction1, operator, fraction2};
}

5. Testing

Inside the FractionCalculator class, create a method that takes in a String input and returns a Fraction object.
The purpose of this method is to convert (parse) a String into a Fraction.
The method must handle whole numbers, fractions, and mixed numbers.
The method must throw exceptions for invalid input.
- Non-numbers will throw a NumberFormatException
- Invalid fraction format will throw an IllegalArgumentException

/**
 * Parses a string into a Fraction object.
 * Handles whole numbers, fractions, and mixed numbers.
 *
 * @param str the string to parse.
 * @return a Fraction object representing the parsed string.
 * @throws NumberFormatException if the number parts are not valid integers.
 * @throws IllegalArgumentException if the fraction format is invalid.
 */
public static Fraction parseFraction(String str) {
    return null;
}

5. Testing

Write tests for the parseFraction method.
Start by testing whole numbers, both positive and negative.
These examples are simple enough that I feel the Arrange, Act, and Assert structure is not necessary.

@Test
@DisplayName("Test parseFraction with a positive whole number")
void parseFractionWithPositiveWholeNumber() {
    Fraction f = FractionCalculator.parseFraction("5");
    assertEquals(5, f.getNumerator());
    assertEquals(1, f.getDenominator());
}

@Test
@DisplayName("Test parseFraction with a negative whole number")
void parseFractionWithNegativeWholeNumber() {
    Fraction f = FractionCalculator.parseFraction("-10");
    assertEquals(-10, f.getNumerator());
    assertEquals(1, f.getDenominator());
}

5. Testing

Next, test simple fractions, both positive and negative.

@Test
@DisplayName("Test parseFraction with a simple fraction")
void parseFractionWithSimpleFraction() {
    Fraction f = FractionCalculator.parseFraction("3/4");
    assertEquals(3, f.getNumerator());
    assertEquals(4, f.getDenominator());
}

@Test
@DisplayName("Test parseFraction with a negative improper fraction")
void parseFractionWithNegativeImproperFraction() {
    Fraction f = FractionCalculator.parseFraction("-7/2");
    assertEquals(-7, f.getNumerator());
    assertEquals(2, f.getDenominator());
}

5. Testing

Next, test mixed number fractions, both positive and negative.

@Test
@DisplayName("Test parseFraction with a positive mixed number")
void parseFractionWithPositiveMixedNumber() {
    Fraction f = FractionCalculator.parseFraction("2 1/3"); // 2*3+1 = 7
    assertEquals(7, f.getNumerator());
    assertEquals(3, f.getDenominator());
}

@Test
@DisplayName("Test parseFraction with a negative mixed number")
void parseFractionWithNegativeMixedNumber() {
    Fraction f = FractionCalculator.parseFraction("-3 1/4"); // -3*4-1 = -13
    assertEquals(-13, f.getNumerator());
    assertEquals(4, f.getDenominator());
}

5. Testing

Next, test for invalid input.

@Test
@DisplayName("Test parseFraction with text should throw exception")
void parseFractionWithText_ThrowsException() {
    assertThrows(NumberFormatException.class, () -> FractionCalculator.parseFraction("hello"));
}

@Test
@DisplayName("Test parseFraction with invalid mixed number format should throw exception")
void parseFractionWithInvalidMixedNumber_ThrowsException() {
    Exception e = assertThrows(IllegalArgumentException.class, () -> FractionCalculator.parseFraction("1 2 3"));
    assertTrue(e.getMessage().contains("Invalid mixed number format"));
}

@Test
@DisplayName("Test parseFraction with zero denominator should throw exception")
void parseFractionWithZeroDenominator_ThrowsException() {
    Exception e = assertThrows(ArithmeticException.class, () -> FractionCalculator.parseFraction("5/0"));
    assertTrue(e.getMessage().contains("Denominator cannot be zero"));
}

Final Code Mon-Wed

@Test
void parseFractionPositiveWholeNumber() {
    // Arrange
    String input = "5";
    Fraction expected = new Fraction(5, 1);
    // Act
    Fraction actual = FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionNegativeWholeNumber() {
    Fraction actual =  FractionCalculator.parseFraction("-5");
    assertEquals(-5, actual.getNumerator());
    assertEquals(1, actual.getDenominator());
}

@Test
void parseFractionSimpleFraction() {
    // Arrange
    String input = "5/7";
    Fraction expected = new Fraction(5, 7);
    // Act
    Fraction actual = FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionNegativeImproperFraction() {
    // Arrange
    String input = "-5/3";
    Fraction expected = new Fraction(-5, 3);
    // Act
    Fraction actual = FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionMixedFraction() {
    // Arrange
    String input = "2 1/3";
    Fraction expected = new Fraction(7, 3);
    // Act
    Fraction actual = FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionNegativeMixedFraction() {
    // Arrange
    String input = "-3 1/4";
    Fraction expected = new Fraction(-13, 4);
    // Act
    Fraction actual = FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionWithText() {
    // One-liner
    assertThrows(IllegalArgumentException.class, () -> FractionCalculator.parseFraction("X"));

    // Arrange
    String input = "X";
    Class expected = IllegalArgumentException.class;
    // Act
    Executable actual = () -> FractionCalculator.parseFraction(input);
    // Assert
    assertThrows(expected, actual);
}

@Test
void parseFractionInvalidSlash() {
    // one-liner
    assertThrows(IllegalArgumentException.class, () -> FractionCalculator.parseFraction("1 2"));

    // Arrange
    String input = "1 2";
    Class expected = IllegalArgumentException.class;
    // Act
    Executable actual = () -> FractionCalculator.parseFraction(input);
    // Assert
    assertThrows(expected, actual);
}

@Test
void parseFractionDivideByZero() {
    // one-liner
    assertThrows(IllegalArgumentException.class, () -> FractionCalculator.parseFraction("1/0"));

    // Arrange
    String input = "1/0";
    Class expected = IllegalArgumentException.class;
    // Act
    Executable actual = () -> FractionCalculator.parseFraction(input);
    // Assert
    assertThrows(expected, actual);
}

@Test
void parseFractionInvalidNumerator() {
    // one-liner
    assertThrows(IllegalArgumentException.class, () -> FractionCalculator.parseFraction("N/1"));

    // Arrange
    String input = "N/1";
    Class expected = IllegalArgumentException.class;
    // Act
    Executable actual = () -> FractionCalculator.parseFraction(input);
    // Assert
    assertThrows(expected, actual);
}


@Test
void parseFractionInvalidDenominator() {
    // one-liner
    assertThrows(IllegalArgumentException.class, () -> FractionCalculator.parseFraction("1/N"));

    // Arrange
    String input = "1/N";
    Class expected = IllegalArgumentException.class;
    // Act
    Executable actual = () -> FractionCalculator.parseFraction(input);
    // Assert
    assertThrows(expected, actual);
}

@Test
void parseFractionNegativeDenominator() {
    // Arrange
    String input = "1/-3";
    Fraction expected = new Fraction(-1, 3);
    // Act
    Fraction actual = FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}


@Test
void parseFractionNegativeNumeratorMixedNumber() {
    // Arrange
    String input = "1 -1/3";
    Fraction expected = new Fraction(-4, 3);
    // Act
    Fraction actual =  FractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

Final Code Tue-Thr

@Test
void parseFractionWithPositiveWholeNumber() {
    // Arrange
    String input = "5";
    Fraction expected = new Fraction(5,1);
    // Act
    Fraction actual = MarcsFractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionWithNegativeWholeNumber() {
    Fraction f = MarcsFractionCalculator.parseFraction("-1");
    assertEquals(-1, f.getNumerator());
    assertEquals(1, f.getDenominator());
}

@Test
void parseFractionWithProperPositive() {
    // Arrange
    String input = "3/4";
    Fraction expected = new Fraction(3,4);
    // Act
    Fraction actual = MarcsFractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionWithProperNegative() {
    // Arrange
    String input = "-3/4";
    Fraction expected = new Fraction(-3,4);
    // Act
    Fraction actual = MarcsFractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);

    // Arrange
    input = "3/-4";
    expected = new Fraction(-3,4);
    // Act
    actual = MarcsFractionCalculator.parseFraction(input);
    // Assert
    assertEquals(expected, actual);
}

@Test
void parseFractionWithPositiveMixedNumber() {
    Fraction f = MarcsFractionCalculator.parseFraction("2 1/3");
    assertEquals(7, f.getNumerator());
    assertEquals(3, f.getDenominator());
}

@Test
void parseFractionWithNegativeMixedNumber() {
    Fraction f = MarcsFractionCalculator.parseFraction("-2 1/3");
    assertEquals(-7, f.getNumerator());
    assertEquals(3, f.getDenominator());
}

@Test
void parseFractionWithNegativeMixedNumber2() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("2 -1/3"));
}

@Test
void parseFractionWithNegativeMixedNumber3() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("2 1/-3"));
}

@Test
void parseFractionInvalidNumber() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("X"), "X is not a valid fraction");
}

@Test
void parseFractionInvalidNumerator() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("X/1"), "X is not a valid fraction");
}

@Test
void parseFractionInvalidDenominator() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("1/X"), "X is not a valid fraction");
}

@Test
void parseFractionInvalidSlash() {
    // Arrange
    String input = "1 3!4";
    Class expected = IllegalArgumentException.class;
    // Act
    Executable actual = () -> MarcsFractionCalculator.parseFraction(input);
    // Assert
    assertThrows(expected, actual);
}

@Test
void parseFractionZeroDenominator() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("1/0"));
}

@Test
void parseFractionNonFractionCharacters() {
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("=1/2"));
    assertThrows(IllegalArgumentException.class, () -> MarcsFractionCalculator.parseFraction("1/=2"));
}

4. Coding

Implement code to pass the tests.
If the input string contains a space, that indicates the input String is most likely a mixed number fraction.
If the input string doesn't contain a space, but contains a forward slash, that indicates the string is most likely a proper or improper fraction.
If neither of the first options are true, that indicates the input String is most likely a whole number.

public static Fraction parseFraction(String str) {
    if (str.contains(" ")) { // --- Mixed Number (e.g., "1 2/3" or "-2 1/4") ---
		Fraction result = null;
        return result;
    } else if (str.contains("/")) { // --- Proper/Improper Fraction (e.g., "3/4" or "-5/2") ---
        Fraction result = null;
        return result;
    } else { // --- Whole Number (e.g., "5" or "-10") ---
        return new Fraction();
    }
}

4. Coding

The code for the whole number is the easiest.
Use the Integer class static parseInt method to convert the string into a number.
If an error occurs, that means the String input is not a valid number.
If no error occurs, instantiate a fraction with the whole number as the numerator and 1 as the denominator.

public static Fraction parseFraction(String str) {
    if (str.contains(" ")) { // --- Mixed Number (e.g., "1 2/3" or "-2 1/4") ---
		Fraction result = null;
        return result;
    } else if (str.contains("/")) { // --- Proper/Improper Fraction (e.g., "3/4" or "-5/2") ---
		Fraction result = null;
        return result;
    } else { // --- Whole Number (e.g., "5" or "-10") ---
        int whole = 0;
        try {
            whole = Integer.parseInt(str);
        } catch (NumberFormatException e) {
            // This will be thrown if the whole number is not a number
            throw new NumberFormatException("Invalid whole number: '" + str + "'");
        }
        return new Fraction(whole, 1);
    }
}

4. Coding

The code for the proper/improper fraction is the next easiest.
Call the String class split() method passing a forward slash as the input. This will return a String[] array with the numerator at index 0 and denominator at index 1.
If the first value in the array is not a valid integer, throw an exception for an invalid numerator.
If the second value in the array is not a valid integer, throw an exception for an invalid denominator.

public static Fraction parseFraction(String str) {
    if (str.contains(" ")) { // --- Mixed Number (e.g., "1 2/3" or "-2 1/4") ---
		Fraction result = null;
        return result;
    } else if (str.contains("/")) { // --- Proper/Improper Fraction (e.g., "3/4" or "-5/2") ---
        String[] parts = str.split("/");
        int num = 0;
        int den = 0;
        try {
            num = Integer.parseInt(parts[0]);
        } catch (NumberFormatException e) {
            // This will be thrown if the numerator is not a number
            throw new ArithmeticException("Invalid numerator: '" + parts[0] + "'");
        }

        try {
            den = Integer.parseInt(parts[1]);
        } catch (NumberFormatException e) {
            // This will be thrown if the denominator is not a number
            throw new ArithmeticException("Invalid denominator: '" + parts[1] + "'");
        }

        Fraction result = null;
        try {
            result = new Fraction(num, den);
        } catch (ArithmeticException e) {
            // This will be thrown if the denominator is zero
            throw new ArithmeticException(e.getMessage() + ": '" + str + "'");
        }
        return result;
    } else { // --- Whole Number (e.g., "5" or "-10") ---
        int whole = 0;
        try {
            whole = Integer.parseInt(str);
        } catch (NumberFormatException e) {
            // This will be thrown if the whole number is not a number
            throw new NumberFormatException("Invalid whole number: '" + str + "'");
        }
        return new Fraction(whole, 1);
    }
}

4. Coding

Be careful when instantiating the Fraction object, because a denominator of 0 will throw an ArithmeticException.
The new Exception thrown will produce an error message like "Error: Denominator cannot be zero: '1/0'"

public static Fraction parseFraction(String str) {
    if (str.contains(" ")) { // --- Mixed Number (e.g., "1 2/3" or "-2 1/4") ---
		Fraction result = null;
        return result;
    } else if (str.contains("/")) { // --- Proper/Improper Fraction (e.g., "3/4" or "-5/2") ---
        String[] parts = str.split("/");
        int num = 0;
        int den = 0;
        try {
            num = Integer.parseInt(parts[0]);
        } catch (NumberFormatException e) {
            // This will be thrown if the numerator is not a number
            throw new ArithmeticException("Invalid numerator: '" + str + "'");
        }

        try {
            den = Integer.parseInt(parts[1]);
        } catch (NumberFormatException e) {
            // This will be thrown if the denominator is not a number
            throw new ArithmeticException("Invalid denominator: '" + str + "'");
        }

        Fraction result = null;
        try {
            result = new Fraction(num, den);
        } catch (ArithmeticException e) {
            // This will be thrown if the denominator is zero
            throw new ArithmeticException(e.getMessage() + ": '" + str + "'");
        }
        return result;
    } else { // --- Whole Number (e.g., "5" or "-10") ---
        int whole = 0;
        try {
            whole = Integer.parseInt(str);
        } catch (NumberFormatException e) {
            // This will be thrown if the whole number is not a number
            throw new NumberFormatException("Invalid whole number: '" + str + "'");
        }
        return new Fraction(whole, 1);
    }
}

4. Coding

Lastly, we will write code to handle mixed numbers.
When an optional second argument is passed to the String class split() method, it defines a limit that controls the number of times the pattern is applied and therefore affects the length of the resulting array.
- If the limit is a positive value, then the pattern will be applied at most limit - 1 times. 2 means apply it once.

public static Fraction parseFraction(String str) {
    if (str.contains(" ")) { // --- Mixed Number (e.g., "1 2/3" or "-2 1/4") ---
        String[] parts = str.split(" ", 2);
        int whole = 0;
        try {
            whole = Integer.parseInt(parts[0]);
        } catch (NumberFormatException e) {
            // This will be thrown if the first part of the parts array is not a number
            // e.g. When entering "- 2 1/4" with a space after the -, the array will be ["-", "2 1/4"]
            throw new NumberFormatException("Invalid mixed number format: '" + str + "' (the correct format is '1 2/3' or '-2 1/4')");
        }

        Fraction result = null;
        return result;
    } else if (str.contains("/")) { // --- Proper/Improper Fraction (e.g., "3/4" or "-5/2") ---
        String[] parts = str.split("/");
        int num = Integer.parseInt(parts[0]);
        int den = Integer.parseInt(parts[1]);
        Fraction result = null;
        try {
            result = new Fraction(num, den);
        } catch (ArithmeticException e) {
            // This will be thrown if the denominator is zero
            throw new ArithmeticException(e.getMessage() + ": '" + str + "'");
        }
        return result;
    } else { // --- Whole Number (e.g., "5" or "-10") ---
        int whole = 0;
        try {
            whole = Integer.parseInt(str);
        } catch (NumberFormatException e) {
            // This will be thrown if the whole number is not a number
            throw new NumberFormatException("Invalid whole number: '" + str + "'");
        }
        return new Fraction(whole, 1);
    }
}

Bug

When a user enters something like "1 1/ + 1" or "1/ + 1" when prompted for an equation, an ArrayIndexOutOfBoundsException occurs.
Write code to ensure the length of the array is 2 before calling the parseInt functions.

String[] fractionParts = parts[1].split("/", -1);
if (fractionParts.length != 2 || fractionParts[0].isEmpty() || fractionParts[1].isEmpty()) {
    throw new IllegalArgumentException("Invalid mixed number format: '" + str + "' (the correct format is '1 2/3' or '-1/3'");
}


String[] parts = str.split("/", -1);
if(parts.length != 2 || parts[0].isEmpty() || parts[1].isEmpty()) {
    throw new IllegalArgumentException("Invalid fraction format: '" + str + "'. Fraction format is a/b or whole number");
}

Final Code Mon-Wed

/**
 * Convert a String into a Fraction object. Handles whole numbers, proper and improper fractions, and mixed number fractions
 * @param str is the String to parse
 * @return a Fraction object representing the parsed String
 * @throws IllegalArgumentException if the String is not a valid fraction
 */
public static Fraction parseFraction(String str) {
    Fraction result = null;
    if(str.contains(" ")) { // Mixed number fraction like "1 1/2"
        String[] parts = str.split(" ");
        int whole = 0;
        try {
            whole = Integer.parseInt(parts[0]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid whole number. '" + parts[0] + "' (the correct format is '1 2/3')");
        }

        String[] fractionParts = parts[1].split("/");

        int num = 0;
        try {
            num = Integer.parseInt(fractionParts[0]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid numerator. '" + fractionParts[0] + "' (the correct format is '1 2/3')");
        }

        int den = 1;
        if(fractionParts.length > 1) {
            try {
                den = Integer.parseInt(fractionParts[1]);
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("Invalid denominator. '" + fractionParts[1] + "' (the correct format is '1 2/3')");
            }
        } else {
            throw new IllegalArgumentException("Invalid denominator (the correct format is '1 2/3')");
        }

        if(den == 0) {
            throw new IllegalArgumentException("Invalid denominator. '" + fractionParts[1] + "' (the correct format is '1 2/3')");
        }

        // If the fraction part is negative, flip negativity as needed
        if(num < 0 && den < 0) {
            num *= -1;
            den *= -1;
        } else if (num < 0 && den > 0) {
            num *= -1;
            whole *= -1;
        } else if (num > 0 && den < 0) {
            den *= -1;
            whole *= -1;
        }

        int newNumerator = 0;
        if(whole > 0) {
            newNumerator = whole * den + num;
        } else {
            newNumerator = whole * den - num;
        }
        result = new Fraction(newNumerator, den);

    } else if(str.contains("/")) { // Proper or improper fraction like "1/2" or "3/2"
        String[] parts = str.split("/");

        int num = 0;
        try {
            num = Integer.parseInt(parts[0]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid numerator. '" + parts[0] + "'");
        }

        int den = 0;
        try {
            den = Integer.parseInt(parts[1]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid denominator. '" + parts[1] + "'");
        }

        if(den == 0) {
            throw new IllegalArgumentException("Invalid denominator. '" + parts[1] + "'");
        }

        result = new Fraction(num, den);

    } else { // Whole numbers
        int whole = 0;
        try {
            whole = Integer.parseInt(str);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid whole number. '" + str + "'");
        }
        result = new Fraction(whole, 1);
    }
    return result;
}

Final Code Tue-Thr

/**
 * Converts a String into a Fraction object. Handles whole numbers, improper and proper fractions, and mixed numbers
 * @param str The String representing a fraction to be parsed
 * @return a Fraction object representing the parsed String
 * @throws IllegalArgumentException if the String's fraction format is not valid.
 */
public static Fraction parseFraction(String str) {
    Fraction result = null;
    if(str.contains(" ")) { // Handle Mixed numbers (1 2/3 or -2 1/4)
        String[] parts = str.split(" ", 2);
        int whole = 0;
        // Validate the whole number part
        try {
            whole = Integer.parseInt(parts[0]);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid whole number: '" + str + "' (the correct format is '1 2/3' or '-1 2/3'");
        }
        // Validate if the fraction part is missing the forward slash
        if(!parts[1].contains("/")) {
            throw new IllegalArgumentException("Invalid mixed number format: '" + str + "' (the correct format is '1 2/3' or '-1 2/3'");
        }

        String[] fractionParts = parts[1].split("/");
        int num = 0;
        int den = 0;
        // Validate if the numerator or denominator are not numbers
        try {
            num = Integer.parseInt(fractionParts[0]);
        } catch(NumberFormatException e) {
            throw new IllegalArgumentException("Invalid numerator: '" + str + "'");
        }
        try {
            den = Integer.parseInt(fractionParts[1]);
        } catch(NumberFormatException e) {
            throw new IllegalArgumentException("Invalid denominator: '" + str + "'");
        }

        // Convert the results to an improper fraction
        if(whole >= 0) {
            // Invalid example "2 -1/3 or 2 1/-3)
            if(num < 0 || den < 0) {
                throw new IllegalArgumentException("Invalid mixed number format: '" + str + "' (the correct format is '1 2/3' or '-1 2/3'");
            }
            num = whole * den + num;
        } else if(whole < 0) {
            num = whole * den - num;
        }

        try {
            result = new Fraction(num, den);
        } catch(ArithmeticException e) {
            // Will have an error if denominator is 0
            throw new IllegalArgumentException(e.getMessage() + ": '" + str + "'");
        }


    } else if(str.contains("/")) { // Handle proper and improper fraction (3/4 or -5/2)
        String[] parts = str.split("/");
        int num = 0;
        int den = 0;
        try {
            num = Integer.parseInt(parts[0]);
        } catch(NumberFormatException e) {
            throw new IllegalArgumentException("Invalid numerator: '" + str + "'");
        }
        try {
            den = Integer.parseInt(parts[1]);
        } catch(NumberFormatException e) {
            throw new IllegalArgumentException("Invalid denominator: '" + str + "'");
        }

        try {
            result = new Fraction(num, den);
        } catch(ArithmeticException e) {
            // Will have an error if denominator is 0
            throw new IllegalArgumentException(e.getMessage() + ": '" + str + "'");
        }

    } else { // Handle whole numbers (5 or -1)
        int whole = 0;
        try {
            whole = Integer.parseInt(str);
        } catch(NumberFormatException e) {
            throw new IllegalArgumentException("Invalid whole number: '" + str + "'");
        }
        result = new Fraction(whole, 1);
    }
    return result;
}