wip broken test

Author: simbo1905

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaFormatTest.java

@@ -8,7 +8,54 @@
 import static org.assertj.core.api.Assertions.*;
 
 class JsonSchemaFormatTest extends JsonSchemaLoggingConfig {
+  @Test
+  void testCommonFormats_whenAssertionOn_invalidsFail_validsPass() {
+    // Toggle "assert formats" ON (wire however your implementation exposes it).
+    // If you use a system property, ensure it’s read at compile() time.
+    System.setProperty("json.schema.format.assert", "true");
 
+    // Invalids must FAIL when assertion is on
+    final var uuidSchema = JsonSchema.compile(Json.parse("""
+        { "type":"string", "format":"uuid" }
+        """));
+    assertThat(uuidSchema.validate(Json.parse("\"not-a-uuid\"")).valid()).isFalse();
+
+    final var emailSchema = JsonSchema.compile(Json.parse("""
+        { "type":"string", "format":"email" }
+        """));
+    assertThat(emailSchema.validate(Json.parse("\"no-at-sign\"")).valid()).isFalse();
+
+    final var ipv4Schema = JsonSchema.compile(Json.parse("""
+        { "type":"string", "format":"ipv4" }
+        """));
+    assertThat(ipv4Schema.validate(Json.parse("\"999.0.0.1\"")).valid()).isFalse();
+
+    // Valids must PASS
+    assertThat(uuidSchema.validate(Json.parse("\"123e4567-e89b-12d3-a456-426614174000\"")).valid()).isTrue();
+    assertThat(emailSchema.validate(Json.parse("\"user@example.com\"")).valid()).isTrue();
+    assertThat(ipv4Schema.validate(Json.parse("\"192.168.0.1\"")).valid()).isTrue();
+  }
+
+  @Test
+  void testFormats_whenAssertionOff_areAnnotationsOnly() {
+    // Toggle "assert formats" OFF (annotation-only)
+    System.setProperty("json.schema.format.assert", "false");
+
+    final var uuidSchema = JsonSchema.compile(Json.parse("""
+        { "type":"string", "format":"uuid" }
+        """));
+    final var emailSchema = JsonSchema.compile(Json.parse("""
+        { "type":"string", "format":"email" }
+        """));
+    final var ipv4Schema = JsonSchema.compile(Json.parse("""
+        { "type":"string", "format":"ipv4" }
+        """));
+
+    // Invalid instances should PASS schema when assertion is off
+    assertThat(uuidSchema.validate(Json.parse("\"not-a-uuid\"")).valid()).isTrue();
+    assertThat(emailSchema.validate(Json.parse("\"no-at-sign\"")).valid()).isTrue();
+    assertThat(ipv4Schema.validate(Json.parse("\"999.0.0.1\"")).valid()).isTrue();
+  }
     @Test
     void testUuidFormat() {
         /// Test UUID format validation
@@ -336,4 +383,4 @@ void testFormatWithOtherConstraints() {
         // Invalid: matches pattern but not valid email format
         assertThat(schema.validate(Json.parse("\"test@example\"")).valid()).isFalse();
     }
-}
+}

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaNumberKeywordsTest.java

@@ -6,7 +6,50 @@
 import static org.assertj.core.api.Assertions.*;
 
 class JsonSchemaNumberKeywordsTest extends JsonSchemaLoggingConfig {
+  @Test
+  void testExclusiveMinimum_numericForm_strict() {
+    final var schemaJson = """
+        { "type": "number", "exclusiveMinimum": 5 }
+        """;
+    final var schema = JsonSchema.compile(Json.parse(schemaJson));
 
+    // 5 is NOT allowed when exclusiveMinimum is a number
+    assertThat(schema.validate(Json.parse("5")).valid()).isFalse();
+    assertThat(schema.validate(Json.parse("5.0")).valid()).isFalse();
+
+    // Greater-than 5 are allowed
+    assertThat(schema.validate(Json.parse("5.0000001")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("6")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("5.1")).valid()).isTrue();
+  }
+
+  @Test
+  void testExclusiveMaximum_numericForm_strict() {
+    final var schemaJson = """
+        { "type": "number", "exclusiveMaximum": 3 }
+        """;
+    final var schema = JsonSchema.compile(Json.parse(schemaJson));
+
+    // 3 is NOT allowed when exclusiveMaximum is a number
+    assertThat(schema.validate(Json.parse("3")).valid()).isFalse();
+    assertThat(schema.validate(Json.parse("3.0")).valid()).isFalse();
+
+    // Less-than 3 are allowed
+    assertThat(schema.validate(Json.parse("2.9999")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("2")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("2.9")).valid()).isTrue();
+  }
+
+  @Test
+  void testExclusiveMinimum_booleanForm_backCompat() {
+    final var schemaJson = """
+        { "type": "number", "minimum": 5, "exclusiveMinimum": true }
+        """;
+    final var schema = JsonSchema.compile(Json.parse(schemaJson));
+
+    assertThat(schema.validate(Json.parse("5")).valid()).isFalse(); // exclusive
+    assertThat(schema.validate(Json.parse("6")).valid()).isTrue();  // greater is ok
+  }
     @Test
     void exclusiveMinimumAndMaximumAreHonored() {
         String schemaJson = """

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaPatternTest.java

@@ -5,6 +5,30 @@
 import static org.assertj.core.api.Assertions.*;
 
 class JsonSchemaPatternTest extends JsonSchemaLoggingConfig {
+  @Test
+  void testPattern_unanchored_singleChar_findVsMatches() {
+    // Unanchored semantics: pattern "a" must validate any string that CONTAINS 'a',
+    // not just strings that ARE exactly "a".
+    final var schemaJson = """
+        {
+          "type": "string",
+          "pattern": "a"
+        }
+        """;
+
+    final var schema = JsonSchema.compile(Json.parse(schemaJson));
+
+    // ✅ Should PASS — 'a' appears somewhere in the string (proves find() semantics)
+    assertThat(schema.validate(Json.parse("\"a\"")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("\"ba\"")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("\"ab\"")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("\"baa\"")).valid()).isTrue();
+    assertThat(schema.validate(Json.parse("\"xyzaxyz\"")).valid()).isTrue();
+
+    // ❌ Should FAIL — no 'a' present
+    assertThat(schema.validate(Json.parse("\"bbb\"")).valid()).isFalse();
+    assertThat(schema.validate(Json.parse("\"\"")).valid()).isFalse();
+  }
 
     @Test
     void testPattern_unanchored_contains() {
@@ -121,4 +145,4 @@ void testPattern_emptyString() {
         // Invalid - no 'a'
         assertThat(schema.validate(Json.parse("\"bbb\"")).valid()).isFalse();
     }
-}
+}