Improve design of SimpleMath

Introduce PositiveInteger

Author: durimkryeziu

simple-math/src/main/java/com/craftsmanshipinsoftware/math/PositiveInteger.java

@@ -0,0 +1,68 @@
+package com.craftsmanshipinsoftware.math;
+
+import java.io.Serial;
+
+final class PositiveInteger extends Number {
+
+  @Serial
+  private static final long serialVersionUID = -4429661748302289322L;
+
+  private final Integer value;
+
+  private PositiveInteger(Integer value) {
+    this.value = value;
+  }
+
+  static PositiveInteger of(String value) {
+    try {
+      int number = Integer.parseInt(value);
+      if (number < 0) {
+        throw new IllegalArgumentException("Please enter a positive number! Input: %d".formatted(number));
+      }
+      return new PositiveInteger(number);
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException("Please enter a valid number! Input: %s".formatted(value), e);
+    }
+  }
+
+  @Override
+  public int intValue() {
+    return this.value;
+  }
+
+  @Override
+  public long longValue() {
+    return this.value.longValue();
+  }
+
+  @Override
+  public float floatValue() {
+    return this.value.floatValue();
+  }
+
+  @Override
+  public double doubleValue() {
+    return this.value.doubleValue();
+  }
+
+  @Override
+  public int hashCode() {
+    return this.value.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (!(obj instanceof PositiveInteger that)) {
+      return false;
+    }
+    return this.value.equals(that.value);
+  }
+
+  @Override
+  public String toString() {
+    return this.value.toString();
+  }
+}

simple-math/src/main/java/com/craftsmanshipinsoftware/math/SimpleMath.java

@@ -20,52 +20,34 @@ class SimpleMath {
   void printOutput() {
     try (Scanner scanner = new Scanner(inputStream)) {
       String firstInput = promptForInput("What is the first number? ", scanner);
-      int firstNumber = validatedInput(firstInput);
+      PositiveInteger firstNumber = PositiveInteger.of(firstInput);
       String secondInput = promptForInput("What is the second number? ", scanner);
-      int secondNumber = validatedInput(secondInput);
-      if (secondNumber == 0) {
-        throw new IllegalArgumentException("Cannot divide by zero!");
-      }
-      this.printStream.println(output(firstNumber, secondNumber));
+      PositiveInteger secondNumber = PositiveInteger.of(secondInput);
+      this.printStream.println(formattedOutput(firstNumber, secondNumber));
     }
   }
 
   @SuppressWarnings("PMD.SystemPrintln")
   private String promptForInput(String prompt, Scanner scanner) {
     System.out.print(prompt);
-    String input = readInput(scanner);
+    String input = scanner.hasNext() ? scanner.nextLine() : null;
     if (input == null || input.isBlank()) {
       throw new IllegalArgumentException("Input must not be empty!");
     }
     return input;
   }
 
-  private String readInput(Scanner scanner) {
-    return scanner.hasNext() ? scanner.nextLine() : null;
-  }
-
-  private static int validatedInput(String input) {
-    try {
-      int number = Integer.parseInt(input);
-      if (number < 0) {
-        throw new IllegalArgumentException("Please enter a positive number! Input: " + number);
-      }
-      return number;
-    } catch (NumberFormatException e) {
-      throw new IllegalArgumentException("Please enter a valid number! Input: " + input, e);
-    }
-  }
-
-  private static String output(int firstNumber, int secondNumber) {
-    return String.format("""
-            %d + %d = %d
-            %d - %d = %d
-            %d * %d = %d
-            %d / %d = %d""",
-        firstNumber, secondNumber, add(firstNumber, secondNumber),
-        firstNumber, secondNumber, subtract(firstNumber, secondNumber),
-        firstNumber, secondNumber, multiply(firstNumber, secondNumber),
-        firstNumber, secondNumber, divide(firstNumber, secondNumber));
+  private static String formattedOutput(PositiveInteger firstNumber, PositiveInteger secondNumber) {
+    return """
+        %s + %s = %d
+        %s - %s = %d
+        %s * %s = %d
+        %s / %s = %d""".formatted(
+        firstNumber, secondNumber, add(firstNumber.intValue(), secondNumber.intValue()),
+        firstNumber, secondNumber, subtract(firstNumber.intValue(), secondNumber.intValue()),
+        firstNumber, secondNumber, multiply(firstNumber.intValue(), secondNumber.intValue()),
+        firstNumber, secondNumber, divide(firstNumber.intValue(), secondNumber.intValue())
+    );
   }
 
   private static int add(int firstNumber, int secondNumber) {
@@ -81,6 +63,9 @@ private static int multiply(int firstNumber, int secondNumber) {
   }
 
   private static int divide(int firstNumber, int secondNumber) {
+    if (secondNumber == 0) {
+      throw new IllegalArgumentException("Cannot divide by zero!");
+    }
     return firstNumber / secondNumber;
   }
 }

simple-math/src/test/java/com/craftsmanshipinsoftware/math/PositiveIntegerTest.java

@@ -0,0 +1,49 @@
+package com.craftsmanshipinsoftware.math;
+
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+
+import org.assertj.core.api.SoftAssertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+
+class PositiveIntegerTest {
+
+  @Test
+  void valueMustBeANumber() {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> PositiveInteger.of("asdf"))
+        .withMessage("Please enter a valid number! Input: asdf");
+  }
+
+  @Test
+  void valueMustBePositive() {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> PositiveInteger.of("-1"))
+        .withMessage("Please enter a positive number! Input: -1");
+  }
+
+  @ParameterizedTest
+  @NullAndEmptySource
+  void valueMustNotNullOrEmpty(String value) {
+    assertThatIllegalArgumentException()
+        .isThrownBy(() -> PositiveInteger.of(value))
+        .withMessage("Please enter a valid number! Input: " + value);
+  }
+
+  @Test
+  @SuppressWarnings("PMD.JUnitTestsShouldIncludeAssert")
+  void encapsulatesAPositiveNumber() {
+    PositiveInteger positiveInteger = PositiveInteger.of("42");
+
+    SoftAssertions.assertSoftly(softly -> {
+      softly.assertThat(positiveInteger.intValue()).isEqualTo(42);
+      softly.assertThat(positiveInteger.longValue()).isEqualTo(42L);
+      softly.assertThat(positiveInteger.floatValue()).isEqualTo(42.0f);
+      softly.assertThat(positiveInteger.doubleValue()).isEqualTo(42.0);
+      softly.assertThat(positiveInteger.hashCode()).isEqualTo(Integer.hashCode(42));
+      softly.assertThat(positiveInteger).isEqualTo(PositiveInteger.of("42"));
+      softly.assertThat(positiveInteger).hasToString("42");
+    });
+  }
+}