From 8ff43c23e04ccb96ba8e66d1502bd56d99347790 Mon Sep 17 00:00:00 2001 From: Alde Rojas Date: Fri, 4 Sep 2026 16:41:01 -0500 Subject: [PATCH] common : implement common_schema types --- common/CMakeLists.txt | 2 + common/json-schema.cpp | 338 ++++++++++++++++++++ common/json-schema.h | 154 +++++++++ tests/CMakeLists.txt | 1 + tests/test-json-schema.cpp | 624 +++++++++++++++++++++++++++++++++++++ 5 files changed, 1119 insertions(+) create mode 100644 common/json-schema.cpp create mode 100644 common/json-schema.h create mode 100644 tests/test-json-schema.cpp diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 9a43911d35..38dab96ab8 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -84,6 +84,8 @@ add_library(${TARGET} imatrix-loader.cpp imatrix-loader.h json-schema-to-grammar.cpp + json-schema.cpp + json-schema.h json.cpp json.h llguidance.cpp diff --git a/common/json-schema.cpp b/common/json-schema.cpp new file mode 100644 index 0000000000..b0cd7889c3 --- /dev/null +++ b/common/json-schema.cpp @@ -0,0 +1,338 @@ +#include "json-schema.h" +#include "common.h" + +#include +#include +#include +#include +#include + +class common_schema_parser { + const common_json & root_; + common_schema_document doc_; + + // ref nodes get their target once every $ref is parsed, a cycle would otherwise need it too early + std::vector pending_; + + [[noreturn]] static void fail(const std::string & path, const std::string & msg) { + throw std::runtime_error("JSON schema error at " + path + ": " + msg); + } + + static int get_count(const common_json & schema, const std::string & key, const std::string & path, int def) { + if (!schema.contains(key)) { + return def; + } + const common_json & value = schema.at(key); + if (!value.is_number_integer() || value.get() < 0) { + fail(path, key + " must be a non-negative integer"); + } + return value.get(); + } + + // a fractional bound is rounded inwards, towards the integers it still admits + static int64_t get_bound(const common_json & schema, const std::string & key, const std::string & path, bool round_up) { + const common_json & value = schema.at(key); + if (value.is_number_integer()) { + return value.get(); + } + if (!value.is_number()) { + fail(path, key + " must be a number"); + } + double d = value.get(); + return (int64_t) (round_up ? std::ceil(d) : std::floor(d)); + } + + static common_schema_format get_format(const common_json & schema, const std::string & path) { + if (!schema.contains("format")) { + return COMMON_SCHEMA_FORMAT_NONE; + } + const common_json & value = schema.at("format"); + if (!value.is_string()) { + fail(path, "format must be a string"); + } + std::string format = value.get(); + if (format == "date") { + return COMMON_SCHEMA_FORMAT_DATE; + } + if (format == "time") { + return COMMON_SCHEMA_FORMAT_TIME; + } + if (format == "date-time") { + return COMMON_SCHEMA_FORMAT_DATE_TIME; + } + if (format == "uuid" || (format.size() == 5 && format.compare(0, 4, "uuid") == 0 && format[4] >= '1' && format[4] <= '5')) { + return COMMON_SCHEMA_FORMAT_UUID; + } + // any other format is a plain string + return COMMON_SCHEMA_FORMAT_NONE; + } + + const common_json & resolve_ref(const std::string & ref, const std::string & path) { + const common_json * target = &root_; + auto tokens = string_split(ref.substr(1), "/"); + for (size_t i = 1; i < tokens.size(); i++) { + const std::string & sel = tokens[i]; + if (target->is_object() && target->contains(sel)) { + target = &target->at(sel); + } else if (target->is_array()) { + size_t idx; + try { + idx = std::stoull(sel); + } catch (const std::logic_error &) { + idx = target->size(); + } + if (idx >= target->size()) { + fail(path, "cannot resolve $ref " + ref + ", " + sel + " is out of range"); + } + target = &target->at(idx); + } else { + fail(path, "cannot resolve $ref " + ref + ", " + sel + " not found"); + } + } + return *target; + } + + common_schema_ptr parse_ref(const common_json & value, const std::string & path) { + if (!value.is_string()) { + fail(path, "$ref must be a string"); + } + std::string ref = value.get(); + if (ref.compare(0, 2, "#/") != 0) { + fail(path, "unsupported $ref " + ref + ", only references into the same document are supported"); + } + if (doc_.refs.find(ref) == doc_.refs.end()) { + // reserve the key first, so that a cycle back to this $ref stops here + doc_.refs[ref] = nullptr; + doc_.refs[ref] = parse_schema(resolve_ref(ref, path), ref); + } + auto node = std::make_unique(ref); + pending_.push_back(node.get()); + return node; + } + + template + common_schema_ptr parse_alternatives(const common_json & alts, const std::string & path) { + if (!alts.is_array()) { + fail(path, "must be an array of schemas"); + } + if (alts.empty()) { + fail(path, "must not be empty"); + } + auto node = std::make_unique(); + size_t i = 0; + for (const auto & alt : alts) { + node->children.push_back(parse_schema(alt, path + "/" + std::to_string(i++))); + } + return node; + } + + common_schema_ptr parse_object(const common_json & schema, const std::string & path) { + auto node = std::make_unique(); + + std::unordered_set required; + if (schema.contains("required") && schema.at("required").is_array()) { + for (const auto & name : schema.at("required")) { + if (name.is_string()) { + required.insert(name.get()); + } + } + } + + if (schema.contains("properties")) { + const common_json & properties = schema.at("properties"); + if (!properties.is_object()) { + fail(path, "properties must be an object"); + } + for (const auto & [name, prop] : properties.items()) { + node->properties.push_back({name, parse_schema(prop, path + "/properties/" + name), required.count(name) > 0}); + } + } + + if (schema.contains("additionalProperties")) { + const common_json & additional = schema.at("additionalProperties"); + if (additional.is_boolean()) { + if (additional.get()) { + node->additional_properties = std::make_unique(); + } + } else if (additional.is_object()) { + node->additional_properties = parse_schema(additional, path + "/additionalProperties"); + } else { + fail(path, "additionalProperties must be a boolean or a schema"); + } + } else if (!schema.contains("properties")) { + // {"type": "object"} on its own accepts any object + node->additional_properties = std::make_unique(); + } + + return node; + } + + common_schema_ptr parse_array(const common_json & schema, const std::string & path) { + auto node = std::make_unique(); + if (schema.contains("items") || schema.contains("prefixItems")) { + // "items" given as an array is the older spelling of "prefixItems", and wins when both are present + const std::string key = schema.contains("items") ? "items" : "prefixItems"; + const common_json & items = schema.at(key); + if (items.is_array()) { + auto tuple = std::make_unique(); + size_t i = 0; + for (const auto & item : items) { + tuple->items.push_back(parse_schema(item, path + "/" + key + "/" + std::to_string(i++))); + } + return tuple; + } + if (key == "prefixItems") { + fail(path, "prefixItems must be an array"); + } + node->items = parse_schema(items, path + "/" + key); + } else { + node->items = std::make_unique(); + } + node->min_items = get_count(schema, "minItems", path, 0); + node->max_items = get_count(schema, "maxItems", path, -1); + return node; + } + + common_schema_ptr parse_string(const common_json & schema, const std::string & path) { + auto node = std::make_unique(); + if (schema.contains("pattern")) { + const common_json & pattern = schema.at("pattern"); + if (!pattern.is_string()) { + fail(path, "pattern must be a string"); + } + node->pattern = pattern.get(); + } + node->format = get_format(schema, path); + node->min_length = get_count(schema, "minLength", path, 0); + node->max_length = get_count(schema, "maxLength", path, -1); + return node; + } + + common_schema_ptr parse_integer(const common_json & schema, const std::string & path) { + auto node = std::make_unique(); + if (schema.contains("minimum")) { + node->minimum = get_bound(schema, "minimum", path, /* round_up */ true); + } else if (schema.contains("exclusiveMinimum")) { + node->minimum = get_bound(schema, "exclusiveMinimum", path, /* round_up */ false) + 1; + } + if (schema.contains("maximum")) { + node->maximum = get_bound(schema, "maximum", path, /* round_up */ false); + } else if (schema.contains("exclusiveMaximum")) { + node->maximum = get_bound(schema, "exclusiveMaximum", path, /* round_up */ true) - 1; + } + return node; + } + + common_schema_ptr parse_schema(const common_json & schema, const std::string & path) { + if (!schema.is_object()) { + fail(path, "schema must be an object"); + } + if (schema.contains("$ref")) { + return parse_ref(schema.at("$ref"), path); + } + if (schema.contains("oneOf") || schema.contains("anyOf")) { + const std::string key = schema.contains("oneOf") ? "oneOf" : "anyOf"; + return parse_alternatives(schema.at(key), path + "/" + key); + } + + common_json type; + if (schema.contains("type")) { + type = schema.at("type"); + } + if (type.is_array()) { + // {"type": ["a", "b"], ...} is {"anyOf": [{"type": "a", ...}, {"type": "b", ...}]} + if (type.empty()) { + fail(path, "type must not be empty"); + } + auto node = std::make_unique(); + size_t i = 0; + for (const auto & t : type) { + common_json alt = schema; + alt["type"] = t; + node->children.push_back(parse_schema(alt, path + "/type/" + std::to_string(i++))); + } + return node; + } + if (schema.contains("const")) { + return std::make_unique(schema.at("const")); + } + if (schema.contains("enum")) { + const common_json & values = schema.at("enum"); + if (!values.is_array() || values.empty()) { + fail(path, "enum must be a non-empty array"); + } + auto node = std::make_unique(); + for (const auto & value : values) { + node->values.push_back(value); + } + return node; + } + if (!type.is_null() && !type.is_string()) { + fail(path, "type must be a string or an array of strings"); + } + + const std::string type_name = type.is_string() ? type.get() : ""; + const bool has_properties = schema.contains("properties") || + (schema.contains("additionalProperties") && schema.at("additionalProperties") != true); + + if (type_name.empty()) { + // without a type the structural keywords decide, in the same order as the converter + if (has_properties) { + return parse_object(schema, path); + } + if (schema.contains("allOf")) { + return parse_alternatives(schema.at("allOf"), path + "/allOf"); + } + if (schema.contains("items") || schema.contains("prefixItems")) { + return parse_array(schema, path); + } + if (schema.contains("pattern") || get_format(schema, path) != COMMON_SCHEMA_FORMAT_NONE) { + return parse_string(schema, path); + } + return std::make_unique(); + } + if (type_name == "object") { + if (!has_properties && schema.contains("allOf")) { + return parse_alternatives(schema.at("allOf"), path + "/allOf"); + } + return parse_object(schema, path); + } + if (type_name == "string") { + if (schema.contains("allOf")) { + return parse_alternatives(schema.at("allOf"), path + "/allOf"); + } + return parse_string(schema, path); + } + if (type_name == "array") { + return parse_array(schema, path); + } + if (type_name == "integer") { + return parse_integer(schema, path); + } + if (type_name == "number") { + return std::make_unique(); + } + if (type_name == "boolean") { + return std::make_unique(); + } + if (type_name == "null") { + return std::make_unique(); + } + fail(path, "unrecognized type " + type_name); + } + + public: + explicit common_schema_parser(const common_json & root) : root_(root) {} + + common_schema_document parse() { + doc_.root = parse_schema(root_, "#"); + for (auto * node : pending_) { + node->target = doc_.refs.at(node->ref).get(); + } + return std::move(doc_); + } +}; + +common_schema_document common_schema_parse(const common_json & schema) { + return common_schema_parser(schema).parse(); +} diff --git a/common/json-schema.h b/common/json-schema.h new file mode 100644 index 0000000000..247efacda5 --- /dev/null +++ b/common/json-schema.h @@ -0,0 +1,154 @@ +#pragma once + +#include "json.h" + +#include +#include +#include +#include +#include + +// JSON schema IR, covering the subset that json_schema_to_grammar() can convert. +// A $ref becomes a common_schema_ref whose target is owned by the common_schema_document, so a recursive schema stays finite. + +enum common_schema_kind { + COMMON_SCHEMA_KIND_ANY, + COMMON_SCHEMA_KIND_REF, + COMMON_SCHEMA_KIND_ANY_OF, + COMMON_SCHEMA_KIND_ALL_OF, + COMMON_SCHEMA_KIND_CONST, + COMMON_SCHEMA_KIND_ENUM, + COMMON_SCHEMA_KIND_NULL, + COMMON_SCHEMA_KIND_BOOLEAN, + COMMON_SCHEMA_KIND_NUMBER, + COMMON_SCHEMA_KIND_INTEGER, + COMMON_SCHEMA_KIND_STRING, + COMMON_SCHEMA_KIND_ARRAY, + COMMON_SCHEMA_KIND_TUPLE, + COMMON_SCHEMA_KIND_OBJECT, +}; + +enum common_schema_format { + COMMON_SCHEMA_FORMAT_NONE, + COMMON_SCHEMA_FORMAT_UUID, // uuid, uuid1 .. uuid5 + COMMON_SCHEMA_FORMAT_DATE, + COMMON_SCHEMA_FORMAT_TIME, + COMMON_SCHEMA_FORMAT_DATE_TIME, +}; + +// Base class for all nodes, the concrete ones are the common_schema_* structs below +struct common_schema { + virtual ~common_schema() = default; + virtual common_schema_kind kind() const = 0; +}; + +using common_schema_ptr = std::unique_ptr; + +// {} or a schema with no recognized keywords: any JSON value +struct common_schema_any : common_schema { + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_ANY; } +}; + +// {"$ref": "#/..."}, only references into the same document are supported +struct common_schema_ref : common_schema { + std::string ref; + const common_schema * target = nullptr; // owned by common_schema_document::refs + + explicit common_schema_ref(std::string ref) : ref(std::move(ref)) {} + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_REF; } +}; + +// oneOf / anyOf, or a "type" array expanded to one alternative per type +struct common_schema_any_of : common_schema { + std::vector children; + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_ANY_OF; } +}; + +struct common_schema_all_of : common_schema { + std::vector children; + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_ALL_OF; } +}; + +struct common_schema_const : common_schema { + common_json value; + + explicit common_schema_const(common_json value) : value(std::move(value)) {} + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_CONST; } +}; + +struct common_schema_enum : common_schema { + std::vector values; + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_ENUM; } +}; + +struct common_schema_null : common_schema { + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_NULL; } +}; + +struct common_schema_boolean : common_schema { + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_BOOLEAN; } +}; + +struct common_schema_number : common_schema { + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_NUMBER; } +}; + +// bounds are inclusive, exclusiveMinimum / exclusiveMaximum are folded in +struct common_schema_integer : common_schema { + int64_t minimum = INT64_MIN; // INT64_MIN for unbounded + int64_t maximum = INT64_MAX; // INT64_MAX for unbounded + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_INTEGER; } +}; + +struct common_schema_string : common_schema { + std::string pattern; // empty when absent + common_schema_format format = COMMON_SCHEMA_FORMAT_NONE; + int min_length = 0; + int max_length = -1; // -1 for unbounded + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_STRING; } +}; + +struct common_schema_array : common_schema { + common_schema_ptr items; // a common_schema_any when "items" is absent + int min_items = 0; + int max_items = -1; // -1 for unbounded + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_ARRAY; } +}; + +// "prefixItems", or "items" given as an array: one schema per position +struct common_schema_tuple : common_schema { + std::vector items; + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_TUPLE; } +}; + +struct common_schema_property { + std::string name; + common_schema_ptr schema; + bool required = false; +}; + +struct common_schema_object : common_schema { + std::vector properties; // in schema order + common_schema_ptr additional_properties; // null when not allowed + + common_schema_kind kind() const override { return COMMON_SCHEMA_KIND_OBJECT; } +}; + +// A parsed schema: its root, and the target of every $ref it reaches keyed by the $ref string +struct common_schema_document { + common_schema_ptr root; + std::map refs; +}; + +// Parses a JSON schema into a document. +// Throws std::runtime_error when the schema falls outside the supported subset. +common_schema_document common_schema_parse(const common_json & schema); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index b3559a173f..cf7250e73a 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -262,6 +262,7 @@ endif() llama_build_and_test(test-chat-peg-parser.cpp peg-parser/simple-tokenize.cpp) llama_build_and_test(test-jinja.cpp) llama_test(test-jinja NAME test-jinja-py ARGS -py LABEL python) +llama_build_and_test(test-json-schema.cpp) llama_build_and_test(test-chat-auto-parser.cpp WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) llama_build_and_test(test-chat-template.cpp) # debug tool for chat template differential analysis (not registered as a test, run it manually) diff --git a/tests/test-json-schema.cpp b/tests/test-json-schema.cpp new file mode 100644 index 0000000000..a8bcc67295 --- /dev/null +++ b/tests/test-json-schema.cpp @@ -0,0 +1,624 @@ +#include "json-schema.h" +#include "json.h" +#include "testing.h" + +#include +#include +#include +#include +#include + +static common_schema_document parse(const std::string & schema) { + return common_schema_parse(common_json::parse(schema)); +} + +// the node as T, aborting the current test when it is some other kind +template +static const T & as(testing & t, const common_schema * node, const std::string & what) { + const T * typed = dynamic_cast(node); + if (!t.assert_true(what + " has the expected kind", typed != nullptr)) { + throw std::runtime_error(what + " has the wrong kind"); + } + return *typed; +} + +template +static const T & root(testing & t, const common_schema_document & doc) { + return as(t, doc.root.get(), "root"); +} + +static void assert_error(testing & t, const std::string & schema, const std::string & needle) { + try { + parse(schema); + t.assert_true(schema + " is rejected", false); + } catch (const std::runtime_error & e) { + std::string what = e.what(); + t.assert_true(schema + " -> " + what, what.find(needle) != std::string::npos); + } +} + +static void test_any(testing & t) { + t.test("empty schema", [](testing & t) { + auto doc = parse("{}"); + root(t, doc); + t.assert_true("no refs", doc.refs.empty()); + }); + + t.test("unrecognized keywords only", [](testing & t) { + auto doc = parse(R"({"description": "x", "title": "y", "default": 1})"); + root(t, doc); + }); + + t.test("unknown format without a type", [](testing & t) { + auto doc = parse(R"({"format": "email"})"); + root(t, doc); + }); + + t.test("length keywords do not imply a string", [](testing & t) { + auto doc = parse(R"({"minLength": 3, "maxLength": 5})"); + root(t, doc); + }); + + t.test("additionalProperties true alone", [](testing & t) { + auto doc = parse(R"({"additionalProperties": true})"); + root(t, doc); + }); +} + +static void test_primitives(testing & t) { + t.test("null", [](testing & t) { + auto doc = parse(R"({"type": "null"})"); + root(t, doc); + }); + + t.test("boolean", [](testing & t) { + auto doc = parse(R"({"type": "boolean"})"); + root(t, doc); + }); + + t.test("number", [](testing & t) { + auto doc = parse(R"({"type": "number"})"); + root(t, doc); + }); + + t.test("number ignores bounds", [](testing & t) { + auto doc = parse(R"({"type": "number", "minimum": 1, "maximum": 2})"); + root(t, doc); + }); +} + +static void test_integer(testing & t) { + t.test("unbounded", [](testing & t) { + auto doc = parse(R"({"type": "integer"})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", INT64_MIN, i.minimum); + t.assert_equal("maximum", INT64_MAX, i.maximum); + }); + + t.test("inclusive bounds", [](testing & t) { + auto doc = parse(R"({"type": "integer", "minimum": -5, "maximum": 10})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", -5, i.minimum); + t.assert_equal("maximum", 10, i.maximum); + }); + + t.test("exclusive bounds are folded", [](testing & t) { + auto doc = parse(R"({"type": "integer", "exclusiveMinimum": 0, "exclusiveMaximum": 10})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", 1, i.minimum); + t.assert_equal("maximum", 9, i.maximum); + }); + + t.test("inclusive bound wins over exclusive", [](testing & t) { + auto doc = parse(R"({"type": "integer", "minimum": 3, "exclusiveMinimum": 0, "maximum": 7, "exclusiveMaximum": 100})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", 3, i.minimum); + t.assert_equal("maximum", 7, i.maximum); + }); + + t.test("fractional bounds round inwards", [](testing & t) { + auto doc = parse(R"({"type": "integer", "minimum": 1.5, "maximum": 9.5})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", 2, i.minimum); + t.assert_equal("maximum", 9, i.maximum); + }); + + t.test("fractional exclusive bounds round inwards", [](testing & t) { + auto doc = parse(R"({"type": "integer", "exclusiveMinimum": 1.5, "exclusiveMaximum": 9.5})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", 2, i.minimum); + t.assert_equal("maximum", 9, i.maximum); + }); + + t.test("integral floats as exclusive bounds", [](testing & t) { + auto doc = parse(R"({"type": "integer", "exclusiveMinimum": 2.0, "exclusiveMaximum": 9.0})"); + const auto & i = root(t, doc); + t.assert_equal("minimum", 3, i.minimum); + t.assert_equal("maximum", 8, i.maximum); + }); +} + +static void test_string(testing & t) { + t.test("defaults", [](testing & t) { + auto doc = parse(R"({"type": "string"})"); + const auto & s = root(t, doc); + t.assert_equal("pattern", "", s.pattern); + t.assert_equal("format", COMMON_SCHEMA_FORMAT_NONE, s.format); + t.assert_equal("min_length", 0, s.min_length); + t.assert_equal("max_length", -1, s.max_length); + }); + + t.test("all keywords are kept", [](testing & t) { + auto doc = parse(R"({"type": "string", "pattern": "^[a-z]+$", "format": "date", "minLength": 2, "maxLength": 8})"); + const auto & s = root(t, doc); + t.assert_equal("pattern", "^[a-z]+$", s.pattern); + t.assert_equal("format", COMMON_SCHEMA_FORMAT_DATE, s.format); + t.assert_equal("min_length", 2, s.min_length); + t.assert_equal("max_length", 8, s.max_length); + }); + + t.test("formats", [](testing & t) { + auto expect = [&](const char * format, common_schema_format expected) { + auto doc = parse(std::string(R"({"type": "string", "format": ")") + format + "\"}"); + t.assert_equal(format, expected, root(t, doc).format); + }; + expect("date", COMMON_SCHEMA_FORMAT_DATE); + expect("time", COMMON_SCHEMA_FORMAT_TIME); + expect("date-time", COMMON_SCHEMA_FORMAT_DATE_TIME); + expect("uuid", COMMON_SCHEMA_FORMAT_UUID); + expect("uuid1", COMMON_SCHEMA_FORMAT_UUID); + expect("uuid5", COMMON_SCHEMA_FORMAT_UUID); + expect("uuid6", COMMON_SCHEMA_FORMAT_NONE); + expect("email", COMMON_SCHEMA_FORMAT_NONE); + expect("uri", COMMON_SCHEMA_FORMAT_NONE); + }); + + t.test("pattern implies a string", [](testing & t) { + auto doc = parse(R"({"pattern": "^a$"})"); + t.assert_equal("pattern", "^a$", root(t, doc).pattern); + }); + + t.test("known format implies a string", [](testing & t) { + auto doc = parse(R"({"format": "uuid"})"); + t.assert_equal("format", COMMON_SCHEMA_FORMAT_UUID, root(t, doc).format); + }); +} + +static void test_array(testing & t) { + t.test("items with bounds", [](testing & t) { + auto doc = parse(R"({"type": "array", "items": {"type": "integer"}, "minItems": 1, "maxItems": 3})"); + const auto & a = root(t, doc); + as(t, a.items.get(), "items"); + t.assert_equal("min_items", 1, a.min_items); + t.assert_equal("max_items", 3, a.max_items); + }); + + t.test("no items", [](testing & t) { + auto doc = parse(R"({"type": "array"})"); + const auto & a = root(t, doc); + as(t, a.items.get(), "items"); + t.assert_equal("min_items", 0, a.min_items); + t.assert_equal("max_items", -1, a.max_items); + }); + + t.test("bounds without items", [](testing & t) { + auto doc = parse(R"({"type": "array", "minItems": 2})"); + const auto & a = root(t, doc); + as(t, a.items.get(), "items"); + t.assert_equal("min_items", 2, a.min_items); + }); + + t.test("items imply an array", [](testing & t) { + auto doc = parse(R"({"items": {"type": "string"}})"); + const auto & a = root(t, doc); + as(t, a.items.get(), "items"); + }); +} + +static void test_tuple(testing & t) { + t.test("prefixItems", [](testing & t) { + auto doc = parse(R"({"prefixItems": [{"type": "string"}, {"type": "number"}]})"); + const auto & tup = root(t, doc); + t.assert_equal("size", (size_t) 2, tup.items.size()); + as(t, tup.items[0].get(), "items[0]"); + as(t, tup.items[1].get(), "items[1]"); + }); + + t.test("items as an array", [](testing & t) { + auto doc = parse(R"({"type": "array", "items": [{"type": "boolean"}]})"); + const auto & tup = root(t, doc); + t.assert_equal("size", (size_t) 1, tup.items.size()); + as(t, tup.items[0].get(), "items[0]"); + }); + + t.test("items array wins over prefixItems", [](testing & t) { + auto doc = parse(R"({"items": [{"type": "null"}], "prefixItems": [{"type": "string"}, {"type": "string"}]})"); + const auto & tup = root(t, doc); + t.assert_equal("size", (size_t) 1, tup.items.size()); + as(t, tup.items[0].get(), "items[0]"); + }); + + t.test("empty", [](testing & t) { + auto doc = parse(R"({"prefixItems": []})"); + t.assert_true("no items", root(t, doc).items.empty()); + }); +} + +static void test_object(testing & t) { + t.test("type alone accepts any object", [](testing & t) { + auto doc = parse(R"({"type": "object"})"); + const auto & o = root(t, doc); + t.assert_true("no properties", o.properties.empty()); + as(t, o.additional_properties.get(), "additional_properties"); + }); + + t.test("properties", [](testing & t) { + auto doc = parse(R"({ + "type": "object", + "properties": { + "b": {"type": "string"}, + "a": {"type": "integer"}, + "c": {"type": "boolean"} + }, + "required": ["a", "c"] + })"); + const auto & o = root(t, doc); + t.assert_equal("size", (size_t) 3, o.properties.size()); + t.assert_equal("order", "b", o.properties[0].name); + t.assert_equal("order", "a", o.properties[1].name); + t.assert_equal("order", "c", o.properties[2].name); + t.assert_true("b optional", !o.properties[0].required); + t.assert_true("a required", o.properties[1].required); + t.assert_true("c required", o.properties[2].required); + as(t, o.properties[0].schema.get(), "b"); + as(t, o.properties[1].schema.get(), "a"); + as(t, o.properties[2].schema.get(), "c"); + t.assert_true("closed", o.additional_properties == nullptr); + }); + + t.test("properties imply an object", [](testing & t) { + auto doc = parse(R"({"properties": {"a": {}}})"); + const auto & o = root(t, doc); + t.assert_equal("size", (size_t) 1, o.properties.size()); + t.assert_true("closed", o.additional_properties == nullptr); + }); + + t.test("required entries that are not properties are ignored", [](testing & t) { + auto doc = parse(R"({"properties": {"a": {}}, "required": ["a", "zzz", 1]})"); + const auto & o = root(t, doc); + t.assert_equal("size", (size_t) 1, o.properties.size()); + t.assert_true("a required", o.properties[0].required); + }); + + t.test("required that is not an array is ignored", [](testing & t) { + auto doc = parse(R"({"properties": {"a": {}}, "required": "a"})"); + t.assert_true("a optional", !root(t, doc).properties[0].required); + }); + + t.test("additionalProperties false", [](testing & t) { + auto doc = parse(R"({"type": "object", "additionalProperties": false})"); + t.assert_true("closed", root(t, doc).additional_properties == nullptr); + }); + + t.test("additionalProperties false implies an object", [](testing & t) { + auto doc = parse(R"({"additionalProperties": false})"); + const auto & o = root(t, doc); + t.assert_true("no properties", o.properties.empty()); + t.assert_true("closed", o.additional_properties == nullptr); + }); + + t.test("additionalProperties true with properties", [](testing & t) { + auto doc = parse(R"({"properties": {"a": {}}, "additionalProperties": true})"); + const auto & o = root(t, doc); + t.assert_equal("size", (size_t) 1, o.properties.size()); + as(t, o.additional_properties.get(), "additional_properties"); + }); + + t.test("additionalProperties schema", [](testing & t) { + auto doc = parse(R"({"additionalProperties": {"type": "integer", "minimum": 0}})"); + const auto & o = root(t, doc); + t.assert_true("no properties", o.properties.empty()); + const auto & v = as(t, o.additional_properties.get(), "additional_properties"); + t.assert_equal("minimum", 0, v.minimum); + }); + + t.test("nested", [](testing & t) { + auto doc = parse(R"({"properties": {"inner": {"properties": {"leaf": {"type": "null"}}, "required": ["leaf"]}}})"); + const auto & o = root(t, doc); + const auto & inner = as(t, o.properties[0].schema.get(), "inner"); + t.assert_equal("leaf name", "leaf", inner.properties[0].name); + t.assert_true("leaf required", inner.properties[0].required); + as(t, inner.properties[0].schema.get(), "leaf"); + }); +} + +static void test_const_enum(testing & t) { + t.test("const", [](testing & t) { + auto doc = parse(R"({"const": "x"})"); + t.assert_equal("value", "\"x\"", root(t, doc).value.dump()); + }); + + t.test("const object", [](testing & t) { + auto doc = parse(R"({"const": {"a": [1, null]}})"); + t.assert_equal("value", R"({"a":[1,null]})", root(t, doc).value.dump()); + }); + + t.test("enum", [](testing & t) { + auto doc = parse(R"({"enum": ["a", 1, null, true]})"); + const auto & e = root(t, doc); + t.assert_equal("size", (size_t) 4, e.values.size()); + t.assert_equal("values[0]", "\"a\"", e.values[0].dump()); + t.assert_equal("values[1]", "1", e.values[1].dump()); + t.assert_equal("values[2]", "null", e.values[2].dump()); + t.assert_equal("values[3]", "true", e.values[3].dump()); + }); + + t.test("const and enum win over type", [](testing & t) { + auto doc_const = parse(R"({"type": "string", "const": "x"})"); + root(t, doc_const); + auto doc_enum = parse(R"({"type": "integer", "enum": [1, 2]})"); + root(t, doc_enum); + }); + + t.test("const wins over enum", [](testing & t) { + auto doc = parse(R"({"const": "x", "enum": ["y"]})"); + t.assert_equal("value", "\"x\"", root(t, doc).value.dump()); + }); +} + +static void test_any_of(testing & t) { + t.test("anyOf", [](testing & t) { + auto doc = parse(R"({"anyOf": [{"type": "string"}, {"type": "number"}]})"); + const auto & u = root(t, doc); + t.assert_equal("size", (size_t) 2, u.children.size()); + as(t, u.children[0].get(), "children[0]"); + as(t, u.children[1].get(), "children[1]"); + }); + + t.test("oneOf", [](testing & t) { + auto doc = parse(R"({"oneOf": [{"type": "null"}]})"); + const auto & u = root(t, doc); + t.assert_equal("size", (size_t) 1, u.children.size()); + as(t, u.children[0].get(), "children[0]"); + }); + + t.test("oneOf wins over anyOf and type", [](testing & t) { + auto doc = parse(R"({"type": "string", "oneOf": [{"type": "null"}], "anyOf": [{"type": "number"}, {"type": "boolean"}]})"); + const auto & u = root(t, doc); + t.assert_equal("size", (size_t) 1, u.children.size()); + as(t, u.children[0].get(), "children[0]"); + }); + + t.test("type array expands with sibling keywords", [](testing & t) { + auto doc = parse(R"({"type": ["string", "null", "integer"], "minLength": 2, "minimum": 5})"); + const auto & u = root(t, doc); + t.assert_equal("size", (size_t) 3, u.children.size()); + t.assert_equal("min_length", 2, as(t, u.children[0].get(), "children[0]").min_length); + as(t, u.children[1].get(), "children[1]"); + t.assert_equal("minimum", 5, as(t, u.children[2].get(), "children[2]").minimum); + }); + + t.test("type array with structural keywords", [](testing & t) { + auto doc = parse(R"({"type": ["object", "array"], "properties": {"a": {}}, "items": {"type": "null"}})"); + const auto & u = root(t, doc); + t.assert_equal("size", (size_t) 2, u.children.size()); + t.assert_equal("properties", (size_t) 1, as(t, u.children[0].get(), "children[0]").properties.size()); + as(t, as(t, u.children[1].get(), "children[1]").items.get(), "items"); + }); +} + +static void test_all_of(testing & t) { + t.test("without a type", [](testing & t) { + auto doc = parse(R"({"allOf": [{"properties": {"a": {}}}, {"properties": {"b": {}}}]})"); + const auto & all = root(t, doc); + t.assert_equal("size", (size_t) 2, all.children.size()); + as(t, all.children[0].get(), "children[0]"); + as(t, all.children[1].get(), "children[1]"); + }); + + t.test("type string", [](testing & t) { + auto doc = parse(R"({"type": "string", "allOf": [{"enum": ["a", "b"]}, {"enum": ["b", "c"]}]})"); + const auto & all = root(t, doc); + t.assert_equal("size", (size_t) 2, all.children.size()); + as(t, all.children[0].get(), "children[0]"); + }); + + t.test("type object without properties", [](testing & t) { + auto doc = parse(R"({"type": "object", "allOf": [{"properties": {"a": {}}}]})"); + root(t, doc); + }); + + t.test("properties win over allOf", [](testing & t) { + auto doc = parse(R"({"type": "object", "properties": {"a": {}}, "allOf": [{"properties": {"b": {}}}]})"); + t.assert_equal("size", (size_t) 1, root(t, doc).properties.size()); + }); + + t.test("nested anyOf component", [](testing & t) { + auto doc = parse(R"({"allOf": [{"anyOf": [{"properties": {"a": {}}}, {"properties": {"b": {}}}]}]})"); + const auto & all = root(t, doc); + const auto & any = as(t, all.children[0].get(), "children[0]"); + t.assert_equal("size", (size_t) 2, any.children.size()); + }); + + t.test("other types ignore allOf", [](testing & t) { + auto doc = parse(R"({"type": "integer", "allOf": [{"minimum": 1}]})"); + root(t, doc); + }); +} + +static void test_ref(testing & t) { + t.test("target is owned by the document", [](testing & t) { + auto doc = parse(R"({"$ref": "#/$defs/t", "$defs": {"t": {"type": "boolean"}}})"); + const auto & r = root(t, doc); + t.assert_equal("ref", "#/$defs/t", r.ref); + t.assert_equal("refs", (size_t) 1, doc.refs.size()); + t.assert_true("target", r.target != nullptr && r.target == doc.refs.at("#/$defs/t").get()); + as(t, r.target, "target"); + }); + + t.test("sibling keywords are ignored", [](testing & t) { + auto doc = parse(R"({"$ref": "#/$defs/t", "type": "string", "$defs": {"t": {"type": "null"}}})"); + as(t, root(t, doc).target, "target"); + }); + + t.test("definitions", [](testing & t) { + auto doc = parse(R"({"properties": {"a": {"$ref": "#/definitions/t"}}, "definitions": {"t": {"type": "number"}}})"); + const auto & o = root(t, doc); + const auto & r = as(t, o.properties[0].schema.get(), "a"); + as(t, r.target, "target"); + }); + + t.test("same ref shares one target", [](testing & t) { + auto doc = parse(R"({"properties": {"a": {"$ref": "#/$defs/t"}, "b": {"$ref": "#/$defs/t"}}, "$defs": {"t": {"type": "boolean"}}})"); + const auto & o = root(t, doc); + const auto & ra = as(t, o.properties[0].schema.get(), "a"); + const auto & rb = as(t, o.properties[1].schema.get(), "b"); + t.assert_true("shared", ra.target != nullptr && ra.target == rb.target); + t.assert_equal("refs", (size_t) 1, doc.refs.size()); + }); + + t.test("recursive", [](testing & t) { + auto doc = parse(R"({ + "$ref": "#/$defs/node", + "$defs": { + "node": { + "type": "object", + "properties": { + "value": {"type": "number"}, + "next": {"$ref": "#/$defs/node"} + }, + "required": ["value"] + } + } + })"); + const auto & r = root(t, doc); + const auto & node = as(t, r.target, "node"); + t.assert_equal("properties", (size_t) 2, node.properties.size()); + const auto & next = as(t, node.properties[1].schema.get(), "next"); + t.assert_true("cycle", next.target == r.target); + t.assert_equal("refs", (size_t) 1, doc.refs.size()); + }); + + t.test("mutually recursive", [](testing & t) { + auto doc = parse(R"({ + "$ref": "#/$defs/a", + "$defs": { + "a": {"properties": {"b": {"$ref": "#/$defs/b"}}}, + "b": {"properties": {"a": {"$ref": "#/$defs/a"}}} + } + })"); + const auto & ra = root(t, doc); + const auto & a = as(t, ra.target, "a"); + const auto & rb = as(t, a.properties[0].schema.get(), "a.b"); + const auto & b = as(t, rb.target, "b"); + const auto & back = as(t, b.properties[0].schema.get(), "b.a"); + t.assert_true("cycle", back.target == ra.target); + t.assert_equal("refs", (size_t) 2, doc.refs.size()); + }); + + t.test("pointer through an array", [](testing & t) { + auto doc = parse(R"({"oneOf": [{"type": "null"}, {"$ref": "#/oneOf/0"}]})"); + const auto & u = root(t, doc); + const auto & r = as(t, u.children[1].get(), "children[1]"); + as(t, r.target, "target"); + }); + + t.test("targets survive moving the document", [](testing & t) { + auto parsed = parse(R"({"items": {"$ref": "#/$defs/t"}, "$defs": {"t": {"type": "null"}}})"); + common_schema_document doc = std::move(parsed); + const auto & a = root(t, doc); + const auto & r = as(t, a.items.get(), "items"); + t.assert_true("target", r.target == doc.refs.at("#/$defs/t").get()); + as(t, r.target, "target"); + }); +} + +static void test_errors(testing & t) { + t.test("not a schema", [](testing & t) { + assert_error(t, R"([])", "#: schema must be an object"); + assert_error(t, R"("string")", "#: schema must be an object"); + }); + + t.test("type", [](testing & t) { + assert_error(t, R"({"type": "char"})", "#: unrecognized type char"); + assert_error(t, R"({"type": 5})", "#: type must be a string or an array of strings"); + assert_error(t, R"({"type": []})", "#: type must not be empty"); + assert_error(t, R"({"type": ["string", "bad"]})", "#/type/1: unrecognized type bad"); + }); + + t.test("ref", [](testing & t) { + assert_error(t, R"({"$ref": 5})", "#: $ref must be a string"); + assert_error(t, R"({"$ref": "https://example.com/x.json"})", "#: unsupported $ref https://example.com/x.json"); + assert_error(t, R"({"$ref": "#"})", "#: unsupported $ref #"); + assert_error(t, R"({"$ref": "#/$defs/missing"})", "#: cannot resolve $ref #/$defs/missing, $defs not found"); + assert_error(t, R"({"$defs": {}, "$ref": "#/$defs/missing"})", "#: cannot resolve $ref #/$defs/missing, missing not found"); + assert_error(t, R"({"oneOf": [{}], "$ref": "#/oneOf/1"})", "#: cannot resolve $ref #/oneOf/1, 1 is out of range"); + assert_error(t, R"({"oneOf": [{}], "$ref": "#/oneOf/x"})", "#: cannot resolve $ref #/oneOf/x, x is out of range"); + assert_error(t, R"({"$defs": {"a": {"$ref": "#/$defs/a/nope"}}, "$ref": "#/$defs/a"})", "#/$defs/a: cannot resolve $ref #/$defs/a/nope, nope not found"); + }); + + t.test("alternatives", [](testing & t) { + assert_error(t, R"({"oneOf": []})", "#/oneOf: must not be empty"); + assert_error(t, R"({"anyOf": {}})", "#/anyOf: must be an array of schemas"); + assert_error(t, R"({"allOf": []})", "#/allOf: must not be empty"); + assert_error(t, R"({"anyOf": [{"type": "string"}, {"items": {"type": "x"}}]})", "#/anyOf/1/items: unrecognized type x"); + }); + + t.test("enum", [](testing & t) { + assert_error(t, R"({"enum": []})", "#: enum must be a non-empty array"); + assert_error(t, R"({"enum": "a"})", "#: enum must be a non-empty array"); + }); + + t.test("string", [](testing & t) { + assert_error(t, R"({"type": "string", "pattern": 5})", "#: pattern must be a string"); + assert_error(t, R"({"type": "string", "format": 5})", "#: format must be a string"); + assert_error(t, R"({"type": "string", "minLength": -1})", "#: minLength must be a non-negative integer"); + assert_error(t, R"({"type": "string", "maxLength": "5"})", "#: maxLength must be a non-negative integer"); + }); + + t.test("integer", [](testing & t) { + assert_error(t, R"({"type": "integer", "minimum": "1"})", "#: minimum must be a number"); + assert_error(t, R"({"type": "integer", "exclusiveMaximum": null})", "#: exclusiveMaximum must be a number"); + }); + + t.test("array", [](testing & t) { + assert_error(t, R"({"type": "array", "maxItems": 1.5})", "#: maxItems must be a non-negative integer"); + assert_error(t, R"({"type": "array", "items": {"type": "x"}})", "#/items: unrecognized type x"); + assert_error(t, R"({"prefixItems": {}})", "#: prefixItems must be an array"); + assert_error(t, R"({"prefixItems": [{"type": "x"}]})", "#/prefixItems/0: unrecognized type x"); + }); + + t.test("object", [](testing & t) { + assert_error(t, R"({"properties": []})", "#: properties must be an object"); + assert_error(t, R"({"properties": {"a": {"type": "nope"}}})", "#/properties/a: unrecognized type nope"); + assert_error(t, R"({"additionalProperties": null})", "#: additionalProperties must be a boolean or a schema"); + assert_error(t, R"({"additionalProperties": {"type": "x"}})", "#/additionalProperties: unrecognized type x"); + }); +} + +int main(int argc, char * argv[]) { + testing t(std::cout); + if (argc >= 2) { + t.set_filter(argv[1]); + } + + const char * verbose = getenv("LLAMA_TEST_VERBOSE"); + if (verbose) { + t.verbose = std::string(verbose) == "1"; + } + + t.test("any", test_any); + t.test("primitives", test_primitives); + t.test("integer", test_integer); + t.test("string", test_string); + t.test("array", test_array); + t.test("tuple", test_tuple); + t.test("object", test_object); + t.test("const and enum", test_const_enum); + t.test("any_of", test_any_of); + t.test("all_of", test_all_of); + t.test("ref", test_ref); + t.test("errors", test_errors); + + return t.summary(); +}