[json_schema] Implement several keyword validations

- minimum
- maximum
- const
- contains
- minContains
- maxContains

Also fix bug in dynamic_schema's allocateJson

Author: suluke

json_schema/include/json_schema/2019-09/schema_validator.h

@@ -37,12 +37,19 @@ class SchemaValidator {
 
   template <typename JSON>
   constexpr ValidationResult validate(const JSON &theJson) const {
+    return validate(theJson, itsSchema);
+  }
+
+  template <typename JSON>
+  constexpr ValidationResult validate(const JSON &theJson,
+                                      const SchemaRef theSchema) const {
     using json_type = decltype(theJson.getType());
-    SchemaObjectAccessor aSchema{itsContext, itsSchema};
+    SchemaObjectAccessor aSchema{itsContext, theSchema};
     if (aSchema.isTrueSchema())
       return std::nullopt;
     if (aSchema.isFalseSchema())
       return makeError("Schema to validate against is `false`");
+    const auto &aApplicator = aSchema.template getSection<SchemaApplicator>();
     const auto &aValidation = aSchema.template getSection<SchemaValidation>();
     // minProperties
     if (const auto &aMinProps = aValidation.getMinProperties();
@@ -80,6 +87,55 @@ class SchemaValidator {
       if (!aIsAllowed)
         return makeError("Type is not allowed");
     }
+    if (theJson.getType() == json_type::NUMBER) {
+      // maximum
+      if (const auto &aMaximum = aValidation.getMaximum()) {
+        if (aMaximum < theJson.toNumber()) {
+          return makeError("Value above maximum");
+        }
+      }
+
+      // minimum
+      if (const auto &aMinimum = aValidation.getMinimum()) {
+        if (aMinimum > theJson.toNumber()) {
+          return makeError("Value below minimum exceeded");
+        }
+      }
+    }
+    // const
+    if (const auto &aConst = aValidation.getConst()) {
+      if (*aConst != theJson) {
+        return makeError(
+            "Element does not match the expected constant (const)");
+      }
+    }
+
+    if (theJson.getType() == json_type::ARRAY) {
+      if (aValidation.getMaxContains() < aValidation.getMinContains()) {
+        return makeError(
+            "Impossible for array to satisfy maxContains<minContains "
+            "expectation (probably schema error)");
+      }
+      // contains
+      if (const auto &aContains = aApplicator.getContains()) {
+        size_t aNumMatching{0};
+        for (const auto &aElm : theJson.toArray()) {
+          ValidationResult aSubVal =
+              validate(aElm, aContains->getRefInternal());
+          if (!aSubVal)
+            ++aNumMatching;
+        }
+        if (aNumMatching == 0u && aValidation.getMinContains() > 0) {
+          return makeError("Expected element not found in array (contains)");
+        }
+        if (aNumMatching < aValidation.getMinContains()) {
+          return makeError("Fewer array elements than expected match");
+        }
+        if (aNumMatching > aValidation.getMaxContains()) {
+          return makeError("More array elements than expected match");
+        }
+      }
+    }
     return std::nullopt;
   }
 

json_schema/include/json_schema/dynamic_schema.h

@@ -136,7 +136,7 @@ template <typename Standard_> struct DynamicSchemaContext {
       cjson::DocumentInfo aDocInfo = cjson::DocumentInfo::read(theJson);
       auto aJson = std::make_shared<JsonStorage>(aDocInfo);
       cjson::DocumentAllocator<JsonStorage, cjson::ErrorWillThrow> aAlloc;
-      aAlloc.allocateJson(*aJson, theJson);
+      aJson->itsEntities[0] = aAlloc.allocateJson(*aJson, theJson);
       JsonRef aJsonRef = *aJson;
       theContext.itsAllocations.emplace_back(std::move(aJson));
       return aJsonRef;

json_schema/test/JSON-Schema-Test-Suite/driver.cc

@@ -41,7 +41,7 @@ static cl::list<fs::path>
     gInputs(cl::meta("files"), cl::desc("File(s) to be validated"),
             cl::init({JSON_SCHEMA_TESTSUITE_BUILTIN_TESTDIRS}));
 
-using Standard = json_schema::Standard_2019_09</*Lenient=*/false>;
+using Standard = json_schema::Standard_2019_09</*Lenient=*/true>;
 using Context = json_schema::DynamicSchemaContext<Standard>;
 using Reader = Standard::template SchemaReader<Context, cjson::ErrorWillThrow>;
 using ReadResult = typename Reader::template ReadResult<1>;
@@ -104,27 +104,6 @@ static std::pair<std::string_view, std::string_view> gDisabledList[] = {
     {"byint", "intbyintfail"},
     {"bynumber", "35isnotmultipleof1.5"},
     {"bysmallnumber", "0.00751isnotmultipleof0.0001"},
-    {"constvalidation", "anothertypeisinvalid"},
-    {"constvalidation", "anothervalueisinvalid"},
-    {"constwith[false]doesnotmatch[0]", "[0.0]isinvalid"},
-    {"constwith[false]doesnotmatch[0]", "[0]isinvalid"},
-    {"constwith[true]doesnotmatch[1]", "[1.0]isinvalid"},
-    {"constwith[true]doesnotmatch[1]", "[1]isinvalid"},
-    {"constwith1doesnotmatchtrue", "trueisinvalid"},
-    {"constwitharray", "anotherarrayitemisinvalid"},
-    {"constwitharray", "arraywithadditionalitemsisinvalid"},
-    {"constwithfalsedoesnotmatch0", "floatzeroisinvalid"},
-    {"constwithfalsedoesnotmatch0", "integerzeroisinvalid"},
-    {"constwithnull", "notnullisinvalid"},
-    {"constwithobject", "anotherobjectisinvalid"},
-    {"constwithobject", "anothertypeisinvalid"},
-    {"constwithtruedoesnotmatch1", "floatoneisinvalid"},
-    {"constwithtruedoesnotmatch1", "integeroneisinvalid"},
-    {"containskeywordvalidation", "arraywithoutitemsmatchingschemaisinvalid"},
-    {"containskeywordvalidation", "emptyarrayisinvalid"},
-    {"containskeywordwithbooleanschemafalse", "emptyarrayisinvalid"},
-    {"containskeywordwithbooleanschematrue", "emptyarrayisinvalid"},
-    {"containskeywordwithconstkeyword", "arraywithoutitem5isinvalid"},
     {"cousinunevaluatedProperties,trueandfalse,falsewithproperties",
      "withnestedunevaluatedproperties"},
     {"cousinunevaluatedProperties,trueandfalse,truewithproperties",
@@ -152,9 +131,8 @@ static std::pair<std::string_view, std::string_view> gDisabledList[] = {
     {"escapedpointerref", "percentinvalid"},
     {"escapedpointerref", "slashinvalid"},
     {"escapedpointerref", "tildeinvalid"},
-    {"evaluatingthesameschemalocationagainstthesamedatalocationtwiceisnotasigno"
-     "fa"
-     "ninfiniteloop",
+    {"evaluatingthesameschemalocationagainstthesamedatalocationtwiceisnotasign"
+     "ofaninfiniteloop",
      "failingcase"},
     {"exclusiveMaximumvalidation", "abovetheexclusiveMaximumisinvalid"},
     {"exclusiveMaximumvalidation", "boundarypointisinvalid"},
@@ -187,30 +165,8 @@ static std::pair<std::string_view, std::string_view> gDisabledList[] = {
     {"itemsvalidationadjuststhestartingindexforadditionalItems",
      "wrongtypeofseconditem"},
     {"itemswithbooleanschemas", "arraywithtwoitemsisinvalid"},
-    {"maxContains<minContains", "emptydata"},
-    {"maxContains<minContains", "invalidmaxContains"},
-    {"maxContains<minContains", "invalidmaxContainsandminContains"},
-    {"maxContains<minContains", "invalidminContains"},
-    {"maxContains=minContains", "allelementsmatch,invalidmaxContains"},
-    {"maxContains=minContains", "allelementsmatch,invalidminContains"},
-    {"maxContains=minContains", "emptydata"},
-    {"maxContainswithcontains", "allelementsmatch,invalidmaxContains"},
-    {"maxContainswithcontains", "emptydata"},
-    {"maxContainswithcontains", "someelementsmatch,invalidmaxContains"},
-    {"maximumvalidation", "abovethemaximumisinvalid"},
-    {"maximumvalidationwithunsignedinteger", "abovethemaximumisinvalid"},
     {"maxItemsvalidation", "toolongisinvalid"},
     {"maxLengthvalidation", "toolongisinvalid"},
-    {"minContains<maxContains", "actual<minContains<maxContains"},
-    {"minContains<maxContains", "minContains<maxContains<actual"},
-    {"minContains=1withcontains", "emptydata"},
-    {"minContains=1withcontains", "noelementsmatch"},
-    {"minContains=2withcontains", "allelementsmatch,invalidminContains"},
-    {"minContains=2withcontains", "emptydata"},
-    {"minContains=2withcontains", "someelementsmatch,invalidminContains"},
-    {"minimumvalidation", "belowtheminimumisinvalid"},
-    {"minimumvalidationwithsignedinteger", "floatbelowtheminimumisinvalid"},
-    {"minimumvalidationwithsignedinteger", "intbelowtheminimumisinvalid"},
     {"minItemsvalidation", "tooshortisinvalid"},
     {"minLengthvalidation", "onesupplementaryUnicodecodepointisnotlongenough"},
     {"minLengthvalidation", "tooshortisinvalid"},