Update unit tests

Author: malczuuu

src/test/java/io/github/malczuuu/problem4j/core/MapUtils.java

@@ -0,0 +1,26 @@
+package io.github.malczuuu.problem4j.core;
+
+import java.util.HashMap;
+
+final class MapUtils {
+
+  /**
+   * Creates a map from the given arguments in similar style to Java 9's Map.of().
+   *
+   * @param args an even number of arguments representing key-value pairs
+   * @return a HashMap containing the provided key-value pairs
+   */
+  static HashMap<String, Object> mapOf(Object... args) {
+    if (args.length % 2 != 0) {
+      throw new IllegalArgumentException("args length must be even");
+    }
+
+    HashMap<String, Object> map = new HashMap<>();
+    for (int i = 0; i < args.length; i += 2) {
+      map.put((String) args[i], args[i + 1]);
+    }
+    return map;
+  }
+
+  private MapUtils() {}
+}

src/test/java/io/github/malczuuu/problem4j/core/ProblemBuilderImplTests.java

@@ -1,15 +1,23 @@
 package io.github.malczuuu.problem4j.core;
 
+import static io.github.malczuuu.problem4j.core.MapUtils.mapOf;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import java.net.URI;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 
+/**
+ * Some of the tests in this class may appear trivial or unnecessary. They are intentionally
+ * included to explore and validate the behavior of various code coverage analysis tools. These
+ * tests help ensure that the coverage reports correctly reflect different execution paths, edge
+ * cases, and instrumentation scenarios.
+ */
 class ProblemBuilderImplTests {
 
   @Test
@@ -100,6 +108,16 @@ void givenNullNameExtension_shouldIgnoreIt() {
     assertThat(problem.getExtensions()).isEmpty();
   }
 
+  @Test
+  void givenNullValueExtension_shouldNotIncludeIt() {
+    Problem problem = Problem.builder().extension("key", null).build();
+
+    assertThat(problem.getExtensions()).isEmpty();
+    assertThat(problem.hasExtension("key")).isFalse();
+    assertThat(problem.getExtensionValue("key")).isNull();
+    assertThat(problem.getExtensionMembers()).isEqualTo(mapOf());
+  }
+
   @Test
   void givenNullMapExtension_shouldIgnoreIt() {
     Problem problem = Problem.builder().extension((Map<String, Object>) null).build();
@@ -116,7 +134,9 @@ void givenMapExtensionWithNullKey_shouldIgnoreNullKey() {
     Problem problem = Problem.builder().extension(map).build();
 
     assertThat(problem.getExtensions()).containsExactly("a");
+    assertThat(problem.hasExtension("a")).isTrue();
     assertThat(problem.getExtensionValue("a")).isEqualTo("b");
+    assertThat(problem.getExtensionMembers()).isEqualTo(mapOf("a", "b"));
   }
 
   @Test
@@ -134,6 +154,9 @@ void givenVarargWithNullElement_shouldIgnoreNullElement() {
             .build();
 
     assertThat(problem.getExtensions()).containsExactlyInAnyOrder("a", "b");
+    assertThat(problem.hasExtension("a")).isTrue();
+    assertThat(problem.hasExtension("b")).isTrue();
+    assertThat(problem.getExtensionMembers()).isEqualTo(mapOf("a", 1, "b", 2));
   }
 
   @Test
@@ -152,26 +175,29 @@ void givenCollectionWithNullElement_shouldIgnoreNullElement() {
             .build();
 
     assertThat(problem.getExtensions()).containsExactlyInAnyOrder("x", "y");
+    assertThat(problem.hasExtension("x")).isTrue();
+    assertThat(problem.hasExtension("y")).isTrue();
+    assertThat(problem.getExtensionMembers()).isEqualTo(mapOf("x", "1", "y", "2"));
   }
 
   @Test
-  void numericStatus_shouldDeriveTitleWhenKnown() {
+  void givenNumericStatus_shouldDeriveTitleWhenKnown() {
     Problem problem = Problem.builder().status(ProblemStatus.MULTI_STATUS.getStatus()).build();
 
     assertThat(problem.getStatus()).isEqualTo(ProblemStatus.MULTI_STATUS.getStatus());
     assertThat(problem.getTitle()).isEqualTo(ProblemStatus.MULTI_STATUS.getTitle());
   }
 
   @Test
-  void unknownNumericStatus_shouldNotDeriveTitle() {
+  void givenUnknownNumericStatus_shouldNotDeriveTitle() {
     Problem problem = Problem.builder().status(999).build();
 
     assertThat(problem.getStatus()).isEqualTo(999);
     assertThat(problem.getTitle()).isNull();
   }
 
   @Test
-  void typeAndInstance_stringOverloads_shouldAcceptValidUris() {
+  void givenTypeAndInstance_stringOverloads_shouldAcceptValidUris() {
     String t = "http://example.org/type";
     String i = "http://example.org/instance";
 
@@ -182,29 +208,21 @@ void typeAndInstance_stringOverloads_shouldAcceptValidUris() {
   }
 
   @Test
-  void emptyMapExtension_shouldBeIgnored() {
+  void givenEmptyMapExtension_shouldBeIgnored() {
     Map<String, Object> m = new HashMap<>();
     Problem problem = Problem.builder().extension(m).build();
 
     assertThat(problem.getExtensions()).isEmpty();
+    assertThat(problem.getExtensionMembers()).isEqualTo(Collections.emptyMap());
   }
 
   @Test
-  void nullValuedExtension_isPresentButOmittedFromToString() {
-    Problem problem = Problem.builder().extension("ext", null).build();
-
-    assertThat(problem.getExtensions()).containsExactly("ext");
-    assertThat(problem.getExtensionValue("ext")).isNull();
-
-    String s = problem.toString();
-    assertThat(s).doesNotContain("\"ext\"");
-  }
-
-  @Test
-  void laterExtensions_shouldOverwriteEarlierValues() {
+  void givenAssigningTheSameExtensionLater_shouldOverwriteEarlierValues() {
     Problem problem =
         Problem.builder().extension("k", "v1").extension(Problem.extension("k", "v2")).build();
 
     assertThat(problem.getExtensionValue("k")).isEqualTo("v2");
+    assertThat(problem.getExtensions()).containsExactly("k");
+    assertThat(problem.getExtensionMembers()).isEqualTo(mapOf("k", "v2"));
   }
 }

src/test/java/io/github/malczuuu/problem4j/core/ProblemExceptionTests.java

@@ -6,6 +6,12 @@
 
 import org.junit.jupiter.api.Test;
 
+/**
+ * Some of the tests in this class may appear trivial or unnecessary. They are intentionally
+ * included to explore and validate the behavior of various code coverage analysis tools. These
+ * tests help ensure that the coverage reports correctly reflect different execution paths, edge
+ * cases, and instrumentation scenarios.
+ */
 class ProblemExceptionTests {
 
   @Test

src/test/java/io/github/malczuuu/problem4j/core/ProblemImplTests.java

@@ -1,12 +1,19 @@
 package io.github.malczuuu.problem4j.core;
 
+import static io.github.malczuuu.problem4j.core.MapUtils.mapOf;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.net.URI;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 
+/**
+ * Some of the tests in this class may appear trivial or unnecessary. They are intentionally
+ * included to explore and validate the behavior of various code coverage analysis tools. These
+ * tests help ensure that the coverage reports correctly reflect different execution paths, edge
+ * cases, and instrumentation scenarios.
+ */
 class ProblemImplTests {
 
   @Test
@@ -114,6 +121,114 @@ void givenStringWithSpecialCharacters_whenToString_thenProperlyEscapes() {
     assertThat(result).contains("\"ext\" : \"" + JsonEscape.escape("a\"b\\c\nd") + "\"");
   }
 
+  @Test
+  void givenTwoEqualProblems_shouldBeEqual() {
+    ProblemImpl problem1 =
+        new ProblemImpl(null, "title", 404, "detail", null, mapOf("key", "value"));
+    ProblemImpl problem2 =
+        new ProblemImpl(null, "title", 404, "detail", null, mapOf("key", "value"));
+
+    assertThat(problem1).isEqualTo(problem2);
+  }
+
+  @Test
+  void givenSameProblems_shouldBeEqual() {
+    Object problem;
+    Object other;
+
+    problem = other = new ProblemImpl(null, "title", 404, "detail", null, mapOf("key", "value"));
+
+    assertThat(problem).isEqualTo(other);
+  }
+
+  @Test
+  void givenTwoDifferentProblems_shouldNotBeEqual() {
+    ProblemImpl problem1 =
+        new ProblemImpl(null, "title1", 404, "detail1", null, mapOf("key", "value1"));
+    ProblemImpl problem2 =
+        new ProblemImpl(null, "title2", 500, "detail2", null, mapOf("key", "value2"));
+
+    assertThat(problem1).isNotEqualTo(problem2);
+  }
+
+  @Test
+  void givenProblemAndDifferentObject_shouldNotBeEqual() {
+    Object problem = new ProblemImpl(null, "title1", 404, "detail1", null, mapOf("key", "value"));
+    Object differentObject = "always wanted to be a problem";
+
+    assertThat(problem).isNotEqualTo(differentObject);
+  }
+
+  @Test
+  void givenTwoEqualProblems_shouldHaveSameHashCode() {
+    ProblemImpl problem1 =
+        new ProblemImpl(null, "title", 404, "detail", null, mapOf("key", "value"));
+    ProblemImpl problem2 =
+        new ProblemImpl(null, "title", 404, "detail", null, mapOf("key", "value"));
+
+    assertThat(problem1.hashCode()).isEqualTo(problem2.hashCode());
+  }
+
+  @Test
+  void givenTwoDifferentProblems_shouldHaveDifferentHashCodes() {
+    ProblemImpl problem1 =
+        new ProblemImpl(null, "title1", 404, "detail1", null, mapOf("key", "value1"));
+    ProblemImpl problem2 =
+        new ProblemImpl(null, "title2", 500, "detail2", null, mapOf("key", "value2"));
+
+    assertThat(problem1.hashCode()).isNotEqualTo(problem2.hashCode());
+  }
+
+  @Test
+  void givenTwoEqualExtensions_shouldBeEqual() {
+    ProblemImpl.ExtensionImpl ext1 = new ProblemImpl.ExtensionImpl("key", "value");
+    ProblemImpl.ExtensionImpl ext2 = new ProblemImpl.ExtensionImpl("key", "value");
+
+    assertThat(ext1).isEqualTo(ext2);
+  }
+
+  @Test
+  void givenSameExtensions_shouldBeEqual() {
+    Object ext;
+    Object other;
+
+    ext = other = new ProblemImpl.ExtensionImpl("key", "value");
+
+    assertThat(ext).isEqualTo(other);
+  }
+
+  @Test
+  void givenTwoDifferentExtensions_shouldNotBeEqual() {
+    ProblemImpl.ExtensionImpl ext1 = new ProblemImpl.ExtensionImpl("key1", "value1");
+    ProblemImpl.ExtensionImpl ext2 = new ProblemImpl.ExtensionImpl("key2", "value2");
+
+    assertThat(ext1).isNotEqualTo(ext2);
+  }
+
+  @Test
+  void givenExtensionAndDifferentObject_shouldNotBeEqual() {
+    Object ext = new ProblemImpl.ExtensionImpl("key", "value");
+    Object differentObject = "always wanted to be a problem";
+
+    assertThat(ext).isNotEqualTo(differentObject);
+  }
+
+  @Test
+  void givenTwoEqualExtensions_shouldHaveSameHashCode() {
+    ProblemImpl.ExtensionImpl ext1 = new ProblemImpl.ExtensionImpl("key", "value");
+    ProblemImpl.ExtensionImpl ext2 = new ProblemImpl.ExtensionImpl("key", "value");
+
+    assertThat(ext1.hashCode()).isEqualTo(ext2.hashCode());
+  }
+
+  @Test
+  void givenTwoDifferentExtensions_shouldHaveDifferentHashCodes() {
+    ProblemImpl.ExtensionImpl ext1 = new ProblemImpl.ExtensionImpl("key1", "value1");
+    ProblemImpl.ExtensionImpl ext2 = new ProblemImpl.ExtensionImpl("key2", "value2");
+
+    assertThat(ext1.hashCode()).isNotEqualTo(ext2.hashCode());
+  }
+
   private static class DummyObject {
     private final String value;