find_path does not work when cross-compiling

.clang-format

@@ -1,14 +1,15 @@
+---
 BasedOnStyle:  LLVM
+AccessModifierOffset: -2
 #AlignConsecutiveAssignments: true
 #AlignConsecutiveDeclarations: true
 AllowShortFunctionsOnASingleLine: Inline
 BreakBeforeBraces: Linux
 ColumnLimit:     0
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
-IndentWidth: 4
+IndentWidth:     2
-IndentPPDirectives: AfterHash
+ObjCBlockIndentWidth: 2
-ObjCBlockIndentWidth: 0
 SpaceAfterCStyleCast: true
-TabWidth: 4
+TabWidth:        2
-AccessModifierOffset: -4
 UseTab:          ForIndentation
+...

.distro/.fmf/version

@@ -1 +0,0 @@
-1

.distro/.gitignore

@@ -1,4 +0,0 @@
-/main.fmf
-/plans/main.fmf
-/tests/main.fmf
-*.tar.gz

.distro/json-schema-validator.spec

@@ -1,61 +0,0 @@
-Name:           json-schema-validator
-Summary:        JSON schema validator for JSON for Modern C++
-Version:        0.0.0
-Release:        %autorelease
-License:        MIT
-URL:            https://github.com/pboettch/json-schema-validator
-
-Source:         https://github.com/pboettch/json-schema-validator/archive/refs/tags/v%{version}.tar.gz
-
-BuildRequires:  ninja-build
-BuildRequires:  cmake
-BuildRequires:  gcc-c++
-BuildRequires:  json-devel
-
-%description
-Json schema validator library for C++ projects using nlohmann/json
-
-%package        devel
-Summary:        Development files for JSON schema validator
-Requires:       json-schema-validator%{?_isa} = %{version}-%{release}
-Requires:       json-devel
-
-%description    devel
-Json schema validator development files for C++ projects using nlohmann/json
-
-
-%prep
-%autosetup -n json-schema-validator-%{version}
-
-
-%build
-%cmake \
-    -DJSON_VALIDATOR_SHARED_LIBS=ON \
-    -DJSON_VALIDATOR_INSTALL=ON \
-    -DJSON_VALIDATOR_BUILD_EXAMPLES=OFF \
-    -DJSON_VALIDATOR_BUILD_TESTS=ON
-
-%cmake_build
-
-
-%install
-%cmake_install
-
-
-%check
-%ctest
-
-
-%files
-%doc README.md
-%license LICENSE
-%{_libdir}/libnlohmann_json_validator.so.*
-
-%files devel
-%{_libdir}/libnlohmann_json_validator.so
-%{_includedir}/nlohmann/json-schema.hpp
-%{_libdir}/cmake/nlohmann_json_schema_validator
-
-
-%changelog
-%autochangelog

.distro/packit.toml

@@ -1,3 +0,0 @@
-Filters = [
-    "unknown-key",
-]

.distro/plans/import.fmf

@@ -1,12 +0,0 @@
-summary:
-  Basic importing tests
-prepare+:
-  - name: Include minimum fetching packages
-    how: install
-    package:
-      - git
-discover+:
-  how: fmf
-  filter: "tag: import"
-execute:
-    how: tmt

.distro/plans/main.fmf.dist-git

@@ -1,4 +0,0 @@
-discover:
-  how: fmf
-  dist-git-source: true
-  path: .distro

.distro/plans/rpmlint.fmf

@@ -1,14 +0,0 @@
-summary:
-  Perform rpmlint and rpminspect tests
-prepare:
-  - name: Download the source rpm
-    how: shell
-    script: cd /tmp && curl -O ${PACKIT_SRPM_URL}
-  - name: Download rpm packages
-    how: shell
-    script: cd /tmp && dnf download ${PACKIT_COPR_RPMS}
-discover+:
-  how: fmf
-  filter: "tag: rpmlint"
-execute:
-    how: tmt

.distro/plans/smoke.fmf

@@ -1,7 +0,0 @@
-summary:
-  Basic smoke tests
-discover+:
-  how: fmf
-  filter: "tag: smoke"
-execute:
-    how: tmt

.distro/tests/import/FetchContent/CMakeLists.txt

@@ -1,15 +0,0 @@
-# This is a simple project that tests using cmake to load the installed libraries
-cmake_minimum_required(VERSION 3.14)
-
-project(test_fetch_content LANGUAGES CXX)
-
-
-FetchContent_Declare(nlohmann_json_schema_validator
-		GIT_REPOSITORY https://github.com/pboettch/json-schema-validator
-		GIT_TAG main
-		)
-FetchContent_MakeAvailable(nlohmann_json_schema_validator)
-
-if (NOT TARGET nlohmann_json_schema_validator::validator)
-	message(FATAL_ERROR "Missing target nlohmann_json_schema_validator::validator")
-endif ()

.distro/tests/import/find_package/CMakeLists.txt

@@ -1,11 +0,0 @@
-# This is a simple project that tests using cmake to load the installed libraries
-cmake_minimum_required(VERSION 3.14)
-
-project(test_find_package LANGUAGES CXX)
-
-set(CMAKE_FIND_DEBUG_MODE ON)
-find_package(nlohmann_json_schema_validator REQUIRED)
-
-if (NOT TARGET nlohmann_json_schema_validator::validator)
-	message(FATAL_ERROR "Missing target nlohmann_json_schema_validator::validator")
-endif ()

.distro/tests/import/main.fmf

@@ -1,11 +0,0 @@
-# Common test variables
-tag:
-  - import
-tier: 0
-path: /tests/import
-
-# Define tests
-/find_package:
-  test: ./test_find_package.sh
-/FetchContent:
-  test: ./test_FetchContent.sh

.distro/tests/import/test_FetchContent.sh

@@ -1,4 +0,0 @@
-#!/bin/bash -eux
-
-tmp_dir=$(mktemp -d)
-cmake -S ./FetchContent -B ${tmp_dir}

.distro/tests/import/test_find_package.sh

@@ -1,4 +0,0 @@
-#!/bin/bash -eux
-
-tmp_dir=$(mktemp -d)
-cmake -S ./find_package -B ${tmp_dir}

.distro/tests/rpmlint.fmf

@@ -1,13 +0,0 @@
-# Common test variables
-tag:
-  - rpmlint
-tier: 0
-path: /
-
-# Define tests
-/rpmlint:
-  summary: Rpmlint spec and rpmfiles
-  test: rpmlint -c packit.toml -r json-schema-validator.rpmlintrc ./*.spec /tmp/*.rpm
-/rpminspect-rpms:
-  summary: Rpminspect the rpms
-  test: ls /tmp/*.rpm | xargs -L1 rpminspect-fedora -E metadata,disttag

.distro/tests/smoke.fmf

@@ -1,9 +0,0 @@
-# Common test variables
-tag:
-  - smoke
-tier: 0
-path: /
-
-# Define tests
-/version:
-  test: echo "TODO: Write a minimum working example"

.github/workflows/release.yaml

@@ -1,31 +0,0 @@
-name: release
-run-name: Release
-
-on:
-  push:
-    tags:
-      - "v[0-9]+.[0-9]+.[0-9]+"
-      - "v[0-9]+.[0-9]+.[0-9]+-rc[0-9]+"
-
-jobs:
-  tests:
-    uses: ./.github/workflows/test.yaml
-    secrets: inherit
-
-  build_conan:
-    runs-on: ubuntu-latest
-    container: ghcr.io/nlohmann/json-ci:v2.4.0
-    steps:
-      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
-      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub."
-      - run: echo "🔎 Branch name is ${{ github.ref }} and repository is ${{ github.repository }}."
-      - name: Clone json-schema-validator
-        uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - run: python -m pip install --upgrade conan
-      - run: conan config init
-      - run: conan profile update settings.compiler.libcxx=libstdc++11 default
-      - name: conan create package
-        run: conan create .

.github/workflows/test.yaml

@@ -1,94 +0,0 @@
-name: test
-run-name: Tests
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-  # Make it able to be used in other workflows
-  workflow_call:
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  pre-commit:
-    name: Check pre-commit
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-      - uses: pre-commit/action@v3.0.0
-
-  test:
-    name: Run ctests
-    needs: [ pre-commit ]
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        toolchain: [ gcc, llvm, intel ]
-        json_version: [ v3.11.2, v3.8.0 ]
-        experimental: [ false ]
-        include:
-          - toolchain: llvm
-            compiler_version: 15
-          - toolchain: gcc
-            compiler_version: latest
-    env:
-      NLOHMANN_JSON_VERSION: ${{ matrix.json_version }}
-    runs-on: ubuntu-latest
-    container: ghcr.io/nlohmann/json-ci:v2.4.0
-    steps:
-      - name: Activate Intel compilers
-        # Not elegant, it will propagate all environment variable.
-        # Intel does not provide a way to output the environment variables to a file
-        # Note: PATH needs to be exported to GITHUB_PATH otherwise it can be overwritten
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          printenv >> $GITHUB_ENV
-          echo $PATH >> $GITHUB_PATH
-        if: matrix.toolchain == 'intel'
-      - name: Setup gcc toolchain
-        run: |
-          update-alternatives --install /usr/bin/g++ g++ $(which g++-${{ matrix.compiler_version }}) 999
-        if: matrix.compiler_version && matrix.toolchain == 'gcc'
-      - name: Setup llvm toolchain
-        run: |
-          update-alternatives --install /usr/bin/clang++ clang++ $(which clang++-${{ matrix.compiler_version }}) 999
-        if: matrix.compiler_version && matrix.toolchain == 'llvm'
-      - uses: actions/checkout@v3
-        # container version is < 3.25 which does not have workflows
-      - name: Get a working cmake version
-        uses: lukka/get-cmake@v3.25.2
-      - name: Run CMake ${{ matrix.toolchain }}-ci workflow with nlohmann/json version ${{ matrix.json_version }}
-        uses: lukka/run-cmake@v10.5
-        with:
-          workflowPreset: "${{ matrix.toolchain }}-ci"
-  coverage:
-    name: Run coverage tests
-    needs: [ test ]
-    runs-on: ubuntu-latest
-    container: ghcr.io/nlohmann/json-ci:v2.4.0
-    if: ${{ github.event_name == 'push' || github.event_name == 'pull_request' }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Get latest cmake version
-        uses: lukka/get-cmake@latest
-      - name: Get test coverage
-        uses: lukka/run-cmake@v10.5
-        with:
-          workflowPreset: ci-coverage
-      - name: Get lcov data
-        uses: danielealbano/lcov-action@v3
-        with:
-          # Note lcov-action prepends and appends wild-cards *. Account for those
-          # https://github.com/danielealbano/lcov-action/issues/11
-          remove_patterns: /test/,/cmake-build*/
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
-        with:
-          files: coverage.info
-          verbose: true

.gitignore

@@ -1,7 +1,3 @@
 build*/
 *.sw?
-cmake-build-*
+
-venv
-env
-compile_commands.json
-.vs/*

.packit.yaml

@@ -1,79 +0,0 @@
-specfile_path: .distro/json-schema-validator.spec
-files_to_sync:
-    - src: .distro/json-schema-validator.spec
-      dest: json-schema-validator.spec
-    - .packit.yaml
-    - src: .distro/json-schema-validator.rpmlintrc
-      dest: json-schema-validator.rpmlintrc
-    # tmt setup
-    - src: .distro/.fmf/
-      dest: .fmf/
-    - src: .distro/plans/
-      dest: plans/
-      filters:
-          - "- .distro/plans/main.fmf.dist-git"
-          - "- .distro/plans/rpmlint.fmf"
-    - src: .distro/plans/main.fmf.dist-git
-      dest: plans/main.fmf
-upstream_package_name: json-schema-validator
-downstream_package_name: json-schema-validator
-update_release: false
-upstream_tag_template: v{version}
-
-jobs:
-    - job: copr_build
-      trigger: pull_request
-      owner: lecris
-      project: json-schema-validator
-      update_release: true
-      release_suffix: "{PACKIT_RPMSPEC_RELEASE}"
-      targets:
-          - fedora-development
-    - job: tests
-      trigger: pull_request
-      targets:
-          - fedora-development
-      fmf_path: .distro
-    - job: copr_build
-      trigger: commit
-      branch: main
-      owner: lecris
-      project: nightly
-      # TODO: Remove when upstream issue is resolved
-      # https://github.com/packit/packit/issues/1924
-      additional_repos:
-          - copr://@scikit-build/release
-      targets:
-          - fedora-development-x86_64
-          - fedora-latest-x86_64
-          - fedora-development-aarch64
-          - fedora-latest-aarch64
-    - job: copr_build
-      trigger: release
-      owner: lecris
-      project: release
-      targets:
-          - fedora-development-x86_64
-          - fedora-latest-x86_64
-          - fedora-development-aarch64
-          - fedora-latest-aarch64
-    - job: tests
-      trigger: commit
-      branch: main
-      targets:
-          - fedora-development
-          - fedora-latest
-      fmf_path: .distro
-    - job: propose_downstream
-      trigger: release
-      dist_git_branches:
-          - fedora-development
-          - fedora-latest
-    - job: koji_build
-      trigger: commit
-      dist_git_branches:
-          - fedora-all
-    - job: bodhi_update
-      trigger: commit
-      dist_git_branches:
-          - fedora-branched

.pre-commit-config.yaml

@@ -1,33 +0,0 @@
-repos:
-  - repo: https://github.com/Takishima/cmake-pre-commit-hooks
-    rev: v1.8.1
-    hooks:
-      - id: clang-format
-        args:
-          - '-i'
-      - id: clang-tidy
-        args:
-          # TODO: Remove when upstream issue is fixed
-          # https://gitlab.kitware.com/cmake/cmake/-/issues/24827
-          # https://github.com/Takishima/cmake-pre-commit-hooks/issues/63
-          - '-Bcmake-build-pre-commit'
-          - '--preset'
-          - 'pre-commit'
-        stages: [ manual ]
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-      - id: trailing-whitespace
-      - id: end-of-file-fixer
-      - id: check-yaml
-  - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.16
-    hooks:
-      - id: mdformat
-        additional_dependencies:
-          - mdformat-gfm
-          - mdformat-tables
-  - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.23.0
-    hooks:
-      - id: check-github-workflows

.travis.yml

@@ -0,0 +1,69 @@
+#########################
+# project configuration #
+#########################
+
+# C++ project
+language: cpp
+
+dist: trusty
+sudo: required
+group: edge
+
+matrix:
+  include:
+  - os: linux
+    compiler: gcc
+    env: COMPILER=g++-4.9
+    addons:
+      apt:
+        sources: ['ubuntu-toolchain-r-test']
+        packages: ['g++-4.9', 'ninja-build']
+
+  - os: linux
+    compiler: gcc
+    env: COMPILER=g++-5
+    addons:
+      apt:
+        sources: ['ubuntu-toolchain-r-test']
+        packages: ['g++-5', 'ninja-build']
+
+  - os: linux
+    compiler: gcc
+    env: COMPILER=g++-6
+    addons:
+      apt:
+        sources: ['ubuntu-toolchain-r-test']
+        packages: ['g++-6', 'ninja-build']
+
+  - os: linux
+    compiler: gcc
+    env: COMPILER=g++-7
+    addons:
+      apt:
+        sources: ['ubuntu-toolchain-r-test']
+        packages: ['g++-7', 'ninja-build']
+
+script:
+  # get CMake and Ninja (only for systems with brew - macOS)
+  - |
+     if [[ (-x $(which brew)) ]]; then
+       brew update
+       brew install cmake ninja
+       brew upgrade cmake
+     fi
+  # make sure CXX is correctly set
+  - if [[ "${COMPILER}" != "" ]]; then export CXX=${COMPILER}; fi
+
+  # show OS/compiler version
+  - uname -a
+  - cmake --version
+  - $CXX --version
+
+  # put json.hpp to nlohmann
+  - mkdir -p nlohmann && wget https://github.com/nlohmann/json/releases/download/v3.1.2/json.hpp -O nlohmann/json.hpp
+
+  # compile and execute unit tests
+  - mkdir -p build && cd build
+  - cmake .. -DNLOHMANN_JSON_DIR=.. ${CMAKE_OPTIONS} -GNinja && cmake --build . --config Release
+  - ctest -C Release -V -j
+  - cd ..

CMakeLists.txt

@@ -1,220 +1,97 @@
-cmake_minimum_required(VERSION 3.14)
+project(json-schema-validator CXX)
-# CMake version compatibility
+
-# TODO: Remove when bumping cmake >= 3.25
+cmake_minimum_required(VERSION 3.2)
-if (POLICY CMP0140)
+
-    # Enables: return(PROPAGATE)
+option(BUILD_TESTS      "Build tests"    ON)
-    cmake_policy(SET CMP0140 NEW)
+option(BUILD_EXAMPLES   "Build examples" ON)
+
+# if used as a subdirectory just define a json-hpp-target as add_library(json-hpp INTERFACE)
+# and associate the path to json.hpp via target_include_directories()
+if(NOT TARGET json-hpp)
+    set(NLOHMANN_JSON_DIR "" CACHE STRING "path to json.hpp")
+
+    if(NOT EXISTS ${NLOHMANN_JSON_DIR}/nlohmann/json.hpp)
+        message(FATAL_ERROR "please set NLOHMANN_JSON_DIR to a path in which NLohmann's json.hpp can be found. Looking for nlohmann/json.hpp in '${NLOHMANN_JSON_REALPATH}")
     endif()
 
-#[==============================================================================================[
+    get_filename_component(NLOHMANN_JSON_REALPATH ${NLOHMANN_JSON_DIR} REALPATH)
-#                                    Basic project definition                                   #
-]==============================================================================================]
 
-# TODO: CMake >= 3.19 can use string(JSON VERSION GET "${METADATA}" "version") to load from JSON
+    # create an interface-library for simple cmake-linking
-set(PROJECT_VERSION 2.4.0)
+    add_library(json-hpp INTERFACE)
+    target_include_directories(json-hpp
+        INTERFACE
+            ${NLOHMANN_JSON_REALPATH})
+endif()
 
-# TODO: Version 3, rename the project and namespace to something more compact
+# and one for the validator
-project(nlohmann_json_schema_validator
+add_library(json-schema-validator
-        VERSION ${PROJECT_VERSION}
+    src/json-schema-draft4.json.cpp
-        DESCRIPTION "Json validator for nlohmann::json library"
+    src/json-uri.cpp
-        HOMEPAGE_URL "https://github.com/pboettch/json-schema-validator"
+    src/json-validator.cpp)
-        LANGUAGES CXX)
+
-# TODO: Remove when bumping cmake >= 3.21
+install(TARGETS json-schema-validator
-if (NOT DEFINED nlohmann_json_schema_validator_IS_TOP_LEVEL)
+        LIBRARY DESTINATION lib
-    if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+        ARCHIVE DESTINATION lib)
-        set(PROJECT_IS_TOP_LEVEL ON)
+
+install(DIRECTORY src/
+        DESTINATION include
+        FILES_MATCHING PATTERN "*.h*")
+
+target_include_directories(json-schema-validator
+    PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+target_compile_features(json-schema-validator
+    PUBLIC
+        cxx_range_for) # for C++11 - flags
+# Enable more compiler warnings, except when using Visual Studio compiler
+if(NOT MSVC)
+    target_compile_options(json-schema-validator
+        PUBLIC
+            -Wall -Wextra)
+endif()
+target_link_libraries(json-schema-validator
+    PUBLIC
+        json-hpp)
+if(BUILD_SHARED_LIBS)
+    target_compile_definitions(json-schema-validator
+        PRIVATE
+            -DJSON_SCHEMA_VALIDATOR_EXPORTS)
+endif()
+
+# regex with boost if gcc < 4.9 - default is std::regex
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9.0")
+        find_package(Boost COMPONENTS regex)
+        if(NOT Boost_FOUND)
+            message(STATUS "GCC less then 4.9 and boost-regex NOT found - no regex used")
+            target_compile_definitions(json-schema-validator PRIVATE -DJSON_SCHEMA_NO_REGEX)
         else()
-        set(PROJECT_IS_TOP_LEVEL OFF)
+            message(STATUS "GCC less then 4.9 and boost-regex FOUND - using boost::regex")
+            target_compile_definitions(json-schema-validator PRIVATE -DJSON_SCHEMA_BOOST_REGEX)
+            target_include_directories(json-schema-validator PRIVATE ${Boost_INCLUDE_DIRS})
+            target_link_libraries(json-schema-validator PRIVATE ${Boost_LIBRARIES})
+        endif()
     endif()
 endif()
 
-#[==============================================================================================[
+if(NOT TARGET json-hpp) # if used as a subdirectory do not install json-schema.hpp
-#                                            Options                                            #
+    install(
-]==============================================================================================]
+        FILES
-
+           ${CMAKE_CURRENT_SOURCE_DIR}/src/json-schema.hpp
-option(JSON_VALIDATOR_INSTALL "JsonValidator: Install targets" ${PROJECT_IS_TOP_LEVEL})
+        DESTINATION
-option(JSON_VALIDATOR_BUILD_TESTS "JsonValidator: Build tests" ${PROJECT_IS_TOP_LEVEL})
+            ${CMAKE_INSTALL_PREFIX}/include
-option(JSON_VALIDATOR_BUILD_EXAMPLES "JsonValidator: Build examples" ${PROJECT_IS_TOP_LEVEL})
-option(JSON_VALIDATOR_SHARED_LIBS "JsonValidator: Build as shared library" ${PROJECT_IS_TOP_LEVEL})
-option(JSON_VALIDATOR_TEST_COVERAGE "JsonValidator: Build with test coverage" OFF)
-mark_as_advanced(JSON_VALIDATOR_TEST_COVERAGE)
-# Get a default JSON_FETCH_VERSION from environment variables to workaround the CI
-if (DEFINED ENV{NLOHMANN_JSON_VERSION})
-    set(JSON_FETCH_VERSION_DEFAULT $ENV{NLOHMANN_JSON_VERSION})
-else ()
-    set(JSON_FETCH_VERSION_DEFAULT v3.11.2)
-endif ()
-set(JSON_FETCH_VERSION ${JSON_FETCH_VERSION_DEFAULT} CACHE STRING "Fetch nlohmann::json version")
-
-#[==============================================================================================[
-#                                     Project configuration                                     #
-]==============================================================================================]
-
-# Include cmake modules
-include(FetchContent)
-if (JSON_VALIDATOR_INSTALL)
-    include(GNUInstallDirs)
-    include(CMakePackageConfigHelpers)
-endif ()
-
-# Default to release build
-if (NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release)
-endif ()
-
-# Enable cmake's BUILD_SHARED_LIBS
-set(BUILD_SHARED_LIBS ${nlohmann_json_schema_validator_SHARED_LIBS})
-
-if (JSON_VALIDATOR_TEST_COVERAGE)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL Clang)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-instr-generate -fcoverage-mapping")
-    elseif (CMAKE_CXX_COMPILER_ID STREQUAL GNU)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
-    else ()
-        message(WARNING
-                "JsonValidator: Other toolchain coverage flags unknown.\n"
-                "Using --coverage as default")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
-    endif ()
-endif ()
-
-#[==============================================================================================[
-#                                       External packages                                       #
-]==============================================================================================]
-
-set(fetch_packages "")
-if (NOT TARGET nlohmann_json)
-  # Fetch/Find nlohmann_json
-  # TODO: Remove when bumping cmake >= 3.24
-  if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.24)
-      FetchContent_Declare(nlohmann_json
-              GIT_REPOSITORY https://github.com/nlohmann/json
-              GIT_TAG ${JSON_FETCH_VERSION}
-              FIND_PACKAGE_ARGS
     )
-      list(APPEND fetch_packages nlohmann_json)
-  else ()
-      # Try to get system installed version
-      find_package(nlohmann_json QUIET)
-      if (NOT nlohmann_json_FOUND)
-          # If failed fetch the desired version
-          FetchContent_Declare(nlohmann_json
-                  GIT_REPOSITORY https://github.com/nlohmann/json
-                  GIT_TAG ${JSON_FETCH_VERSION}
-                  )
-          list(APPEND fetch_packages nlohmann_json)
-      endif ()
-  endif ()
 endif()
 
-# Handle configure flags
+if (BUILD_EXAMPLES)
-if (JSON_VALIDATOR_INSTALL)
+    # simple json-schema-validator-executable
-    # TODO: This is not ideal, this package should not be installing nlohmann::json
+    add_executable(json-schema-validate app/json-schema-validate.cpp)
-    # Currently required in order to satisfy cmake exporter
+    target_link_libraries(json-schema-validate json-schema-validator)
-    set(JSON_Install ON CACHE BOOL "")
 endif()
 
-# Get all dependencies
+if (BUILD_TESTS)
-FetchContent_MakeAvailable(${fetch_packages})
+    # test-zone
-if (JSON_VALIDATOR_INSTALL AND NOT nlohmann_json_FOUND AND JSON_Install)
-    # TODO: This is not ideal
-    message(WARNING
-            "JsonValidator: No nlohmann::json found on the system and nlohmann_json_schema_validator will be installed\n"
-            "This will also install nlohmann::json in its typical installation path\n"
-            "This is not ideal because it might overwrite system installed")
-endif ()
-
-#[==============================================================================================[
-#                                        Main definition                                        #
-]==============================================================================================]
-
-message(STATUS "JsonValidator: Configured for ${CMAKE_BUILD_TYPE}")
-if (DEFINED nlohmann_json_VERSION)
-    message(STATUS "JsonValidator: Using nlohmann/json version: ${nlohmann_json_VERSION}")
-else ()
-    message(STATUS "JsonValidator: nlohmann_json_VERSION is not set. Possible value: ${JSON_FETCH_VERSION}")
-endif ()
-
-## Main targets
-add_library(nlohmann_json_schema_validator)
-add_library(nlohmann_json_schema_validator::validator ALIAS nlohmann_json_schema_validator)
-set_target_properties(nlohmann_json_schema_validator PROPERTIES
-        VERSION ${PROJECT_VERSION}
-        SOVERSION ${PROJECT_VERSION_MAJOR}
-        EXPORT_NAME validator
-        # TODO: Version 3, simplify the library name
-#        OUTPUT_NAME nlohmann_json_validator
-        )
-
-# Main definitions in here
-add_subdirectory(src)
-
-# Enable examples
-
-# Enable testings
-if (JSON_VALIDATOR_BUILD_TESTS)
     enable_testing()
     add_subdirectory(test)
 endif()
-
-if (JSON_VALIDATOR_BUILD_EXAMPLES)
-    add_subdirectory(example)
-endif ()
-
-
-#[==============================================================================================[
-#                                       Install or Export                                       #
-]==============================================================================================]
-
-if (JSON_VALIDATOR_INSTALL)
-    # Note other install targets found in subdirectories
-    # Here mostly the cmake boilerplate are set
-    write_basic_package_version_file(nlohmann_json_schema_validatorConfigVersion.cmake
-            VERSION ${PROJECT_VERSION}
-            COMPATIBILITY SameMajorVersion
-            )
-    configure_package_config_file(cmake/nlohmann_json_schema_validatorConfig.cmake.in
-            nlohmann_json_schema_validatorConfig.cmake
-            INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/nlohmann_json_schema_validator
-            )
-
-    # Install Targets files
-    export(EXPORT nlohmann_json_schema_validatorTargets
-            NAMESPACE nlohmann_json_schema_validator::
-            FILE nlohmann_json_schema_validatorTargets.cmake
-            )
-    install(EXPORT nlohmann_json_schema_validatorTargets
-            FILE nlohmann_json_schema_validatorTargets.cmake
-            NAMESPACE nlohmann_json_schema_validator::
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/nlohmann_json_schema_validator
-            COMPONENT nlohmann_json_schema_validator_Development
-            )
-    # Install cmake export files
-    install(FILES
-            ${CMAKE_CURRENT_BINARY_DIR}/nlohmann_json_schema_validatorConfig.cmake
-            ${CMAKE_CURRENT_BINARY_DIR}/nlohmann_json_schema_validatorConfigVersion.cmake
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/nlohmann_json_schema_validator
-            COMPONENT nlohmann_json_schema_validator_Development
-            )
-endif ()
-
-# Handle the project being included externally (e.g. FetchContent)
-if (NOT PROJECT_IS_TOP_LEVEL)
-    # Export variables set in nlohmann_json_schema_validatorConfig.cmake
-    # TODO: Remove when bumping cmake >= 3.25
-    if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.25)
-        return(PROPAGATE
-                nlohmann_json_schema_validator_VERSION
-                nlohmann_json_schema_validator_VERSION_MAJOR
-                nlohmann_json_schema_validator_VERSION_MINOR
-                nlohmann_json_schema_validator_VERSION_PATCH
-                nlohmann_json_schema_validator_VERSION_TWEAK
-                )
-    else ()
-        set(nlohmann_json_schema_validator_VERSION ${nlohmann_json_schema_validator_VERSION} PARENT_SCOPE)
-        set(nlohmann_json_schema_validator_VERSION_MAJOR ${nlohmann_json_schema_validator_VERSION_MAJOR} PARENT_SCOPE)
-        set(nlohmann_json_schema_validator_VERSION_MINOR ${nlohmann_json_schema_validator_VERSION_MINOR} PARENT_SCOPE)
-        set(nlohmann_json_schema_validator_VERSION_PATCH ${nlohmann_json_schema_validator_VERSION_PATCH} PARENT_SCOPE)
-        set(nlohmann_json_schema_validator_VERSION_TWEAK ${nlohmann_json_schema_validator_VERSION_TWEAK} PARENT_SCOPE)
-    endif ()
-endif ()

CMakePresets.json

@@ -1,7 +0,0 @@
-{
-  "version": 6,
-  "include": [
-    "cmake/CMakePresets-defaults.json",
-    "cmake/CMakePresets-CI.json"
-  ]
-}

README.md

@@ -1,12 +1,13 @@
+
 [![Build Status](https://travis-ci.org/pboettch/json-schema-validator.svg?branch=master)](https://travis-ci.org/pboettch/json-schema-validator)
 
-# JSON schema validator for JSON for Modern C++
+# Modern C++ JSON schema validator
 
 # What is it?
 
 This is a C++ library for validating JSON documents based on a
 [JSON Schema](http://json-schema.org/) which itself should validate with
-[draft-7 of JSON Schema Validation](http://json-schema.org/schema).
+[draft-4 of JSON Schema Validation](http://json-schema.org/schema).
 
 First a disclaimer: *It is work in progress and
 contributions or hints or discussions are welcome.*
@@ -15,162 +16,101 @@ Niels Lohmann et al develop a great JSON parser for C++ called [JSON for Modern
 C++](https://github.com/nlohmann/json). This validator is based on this
 library, hence the name.
 
+The name is for the moment purely marketing, because there is, IMHO, not so much
+modern C++ inside. There is plenty of space to make it more modern.
+
 External documentation is missing as well. However the API of the validator
-is rather simple.
+will be rather simple.
-
-# New in version 2
-
-Although significant changes have been done for the 2nd version
-(a complete rewrite) the API is compatible with the 1.0.0 release. Except for
-the namespace which is now `nlohmann::json_schema`.
-
-Version **2** supports JSON schema draft 7, whereas 1 was supporting draft 4
-only. Please update your schemas.
-
-The primary change in 2 is the way a schema is used. While in version 1 the schema was
-kept as a JSON-document and used again and again during validation, in version 2 the schema
-is parsed into compiled C++ objects which are then used during validation. There are surely
-still optimizations to be done, but validation speed has improved by factor 100
-or more.
 
 # Design goals
 
 The main goal of this validator is to produce *human-comprehensible* error
-messages if a JSON-document/instance does not comply to its schema.
+messages if a JSON-document/instance does not comply with its schema. This is
-
+done with exceptions thrown at the users with a helpful message telling what's
-By default this is done with exceptions thrown at the users with a helpful
+wrong with the document while validating.
-message telling what's wrong with the document while validating.
-
-Starting with **2.0.0** the user can pass a `json_schema::basic_error_handler`-derived
-object along with the instance to validate to receive a callback each time
-a validation error occurs and decide what to do (throwing, counting, collecting).
 
 Another goal was to use Niels Lohmann's JSON-library. This is why the validator
 lives in his namespace.
 
-# Thread-safety
-
-Instance validation is thread-safe and the same validator-object can be used by
-different threads:
-
-The validate method is `const` which indicates the object is not modified when
-being called:
-
-```C++
-	json json_validator::validate(const json &) const;
-```
-
-Validator-object creation however is not thread-safe. A validator has to be
-created in one (main?) thread once.
-
 # Weaknesses
 
-Numerical validation uses nlohmann-json's integer, unsigned and floating point
+Schema-reference resolution is not recursivity-proven: If there is a nested
-types, depending on if the schema type is "integer" or "number". Bignum
+cross-schema reference, it will not stop.  (Though I haven't tested it)
-(i.e. arbitrary precision and range) is not supported at this time.
 
-# Building
+Numerical validation uses `int64_t`, `uint64_t` or `double`, depending on if
+the schema type is "integer" or "number". Bignum (i.e. arbitrary precision and
+range) is not supported at this time.
 
-This library is based on Niels Lohmann's JSON-library and thus has
+Unsigned integer validation will only take place if the following two conditions are true:
-a build-dependency to it.
+- The nlohmann `type()` of the json object under validation is `nlohmann::json::value_t::number_unsigned`
+- The schema specifies a numerical minimum greater than or equal to 0
 
-Currently at least version **3.8.0** of NLohmann's JSON library
+# How to use
-is required.
 
-Various methods using CMake can be used to build this project.
+The current state of the build-system needs at least version **3.1.1** of NLohmann's
+JSON library. It is looking for the `json.hpp` within a `nlohmann/`-path.
 
-## Build out-of-source
+When build the library you need to provide the path to the directory where the include-file
+is located as `nlohmann/json.hpp`.
 
-Do not run cmake inside the source-dir. Rather create a dedicated build-dir:
+## Build
+
+### Within a build-dir
 
 ```Bash
 git clone https://github.com/pboettch/json-schema-validator.git
 cd json-schema-validator
 mkdir build
 cd build
-cmake [..]
+cmake .. \
-make
+    -DNLOHMANN_JSON_DIR=<path/to/>nlohmann/json.hpp \
-make install # if needed
+    -DJSON_SCHEMA_TEST_SUITE_PATH=<path/to/JSON-Schema-test-suite> # optional
-ctest # run unit, non-regression and test-suite tests
+make # install
+ctest # if test-suite has been given
+```
+### As a subdirectory from within
+
+```CMake
+# create an interface-target called json-hpp
+add_library(json-hpp INTERFACE)
+target_include_directories(json-hpp
+    INTERFACE
+        path/to/nlohmann/json.hpp)
+
+# set this path to schema-test-suite to get tests compiled - optional
+set(JSON_SCHEMA_TEST_SUITE_PATH "path/to/json-schema-test-suite")
+enable_testing() # if you want to inherit tests
+
+add_subdirectory(path-to-this-project json-schema-validator)
 ```
 
-## Building as shared library
+### Building a shared library
 
-By default a static library is built. Shared libraries can be generated by using
+By default a static library is built. Shared libraries are generated by using
 the `BUILD_SHARED_LIBS`-cmake variable:
 
 In your initial call to cmake simply add:
-
 ```bash
-cmake [..] -DBUILD_SHARED_LIBS=ON [..]
+cmake -DBUILD_SHARED_LIBS=ON
 ```
 
-## nlohmann-json integration
-
-As nlohmann-json is a dependency, this library tries find it.
-
-The cmake-configuration first checks if nlohmann-json is available as a cmake-target. This may be the case, because it is used as a submodule in a super-project which already provides and uses nlohmann-json.
-Otherwise, it calls `find_package` for nlohmann-json and requires nlohmann-json to be installed on the system.
-
-### Building with Hunter package manager
-
-To enable access to nlohmann json library, Hunter can be used. Just run with `JSON_VALIDATOR_HUNTER=ON` option. No further dependencies needed
-
-```bash
-cmake [..] -DJSON_VALIDATOR_HUNTER=ON [..]
-```
-
-### Building as a CMake-subdirectory from within another project
-
-Adding this library as a subdirectory to a parent project is one way of
-building it.
-
-If the parent project already used `find_package()` to find the CMake-package of nlohmann_json or includes it as a submodule likewise.
-
-### Building directly, finding a CMake-package. (short)
-
-When nlohmann-json has been installed, it provides files which allows
-CMake's `find_package()` to be used.
-
-This library is using this mechanism if `nlohmann_json::nlohmann_json`-target
-does not exist.
-
-### Install
-
-Since version 2.1.0 this library can be installed and CMake-package-files will be
-created accordingly. If the installation of nlohmann-json and this library
-is done into default unix-system-paths CMake will be able to find this
-library by simply doing:
-
-```CMake
-find_package(nlohmann_json_schema_validator REQUIRED)
-```
-
-and
-
-```CMake
-target_link_libraries(<your-target> [..] nlohmann_json_schema_validator)
-```
-
-to build and link.
-
 ## Code
 
 See also `app/json-schema-validate.cpp`.
 
 ```C++
 #include <iostream>
-#include <iomanip>
 
-#include <nlohmann/json-schema.hpp>
+#include "json-schema.hpp"
 
 using nlohmann::json;
-using nlohmann::json_schema::json_validator;
+using nlohmann::json_uri;
+using nlohmann::json_schema_draft4::json_validator;
 
 // The schema is defined based upon a string literal
 static json person_schema = R"(
 {
-    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
     "title": "A person",
     "properties": {
         "name": {
@@ -197,8 +137,8 @@ static json person_schema = R"(
 static json bad_person = {{"age", 42}};
 static json good_person = {{"name", "Albert"}, {"age", 42}};
 
-int main()
+int main(){
-{
+
     /* json-parse the schema */
 
     json_validator validator; // create validator
@@ -210,157 +150,42 @@ int main()
         return EXIT_FAILURE;
     }
 
-    /* json-parse the people - API of 1.0.0, default throwing error handler */
+    /* json-parse the people */
 
-    for (auto &person : {bad_person, good_person}) {
+    for (auto &person : {bad_person, good_person})
-        std::cout << "About to validate this person:\n"
+    {
-                  << std::setw(2) << person << std::endl;
+        std::cout << "About to validate this person:\n" << std::setw(2) << person << std::endl;
         try {
-            validator.validate(person); // validate the document - uses the default throwing error-handler
+            validator.validate(person); // validate the document
             std::cout << "Validation succeeded\n";
         } catch (const std::exception &e) {
             std::cerr << "Validation failed, here is why: " << e.what() << "\n";
         }
     }
-
-    /* json-parse the people - with custom error handler */
-    class custom_error_handler : public nlohmann::json_schema::basic_error_handler
-    {
-        void error(const nlohmann::json_pointer<nlohmann::basic_json<>> &pointer, const json &instance,
-            const std::string &message) override
-        {
-            nlohmann::json_schema::basic_error_handler::error(pointer, instance, message);
-            std::cerr << "ERROR: '" << pointer << "' - '" << instance << "': " << message << "\n";
-        }
-    };
-
-
-    for (auto &person : {bad_person, good_person}) {
-        std::cout << "About to validate this person:\n"
-                  << std::setw(2) << person << std::endl;
-
-        custom_error_handler err;
-        validator.validate(person, err); // validate the document
-
-        if (err)
-            std::cerr << "Validation failed\n";
-        else
-            std::cout << "Validation succeeded\n";
-    }
-
     return EXIT_SUCCESS;
 }
+
 ```
 
 # Compliance
 
 There is an application which can be used for testing the validator with the
 [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite).
-In order to simplify the testing, the test-suite is included in the repository.
 
 If you have cloned this repository providing a path the repository-root via the
 cmake-variable `JSON_SCHEMA_TEST_SUITE_PATH` will enable the test-target(s).
 
 All required tests are **OK**.
 
-# Format
+**12** optional tests of **305** total (required + optional) tests are failing:
 
-Optionally JSON-schema-validator can validate predefined or user-defined formats.
+- 10 of them are `format`-strings which are not supported.
-Therefore a format-checker-function can be provided by the user which is called by
+- big numbers are not working (2)
-the validator when a format-check is required (ie. the schema contains a format-field).
 
-This is how the prototype looks like and how it can be passed to the validation-instance:
+# Additional features
 
-```C++
+## Default values
-static void my_format_checker(const std::string &format, const std::string &value)
-{
-	if (format == "something") {
-		if (!check_value_for_something(value))
-			throw std::invalid_argument("value is not a good something");
-	} else
-		throw std::logic_error("Don't know how to validate " + format);
-}
 
-// when creating the validator
+The goal is to create an empty document, based on schema-defined
+default-values, recursively populated.
 
-json_validator validator(nullptr, // or loader-callback
-                         my_format_checker); // create validator
-```
-
-## Default Checker
-
-The library contains a default-checker, which does some checks. It needs to be
-provided manually to the constructor of the validator:
-
-```C++
-json_validator validator(loader, // or nullptr for no loader
-                         nlohmann::json_schema::default_string_format_check);
-```
-
-Supported formats: `date-time, date, time, email, hostname, ipv4, ipv6, uuid, regex`
-
-More formats can be added in `src/string-format-check.cpp`. Please contribute implementions for missing json schema draft formats.
-
-## Default value processing
-
-As a result of the validation, the library returns a json patch including the default values of the specified schema.
-
-```C++
-#include <iostream>
-#include <nlohmann/json-schema.hpp>
-
-using nlohmann::json;
-using nlohmann::json_schema::json_validator;
-
-static const json rectangle_schema = R"(
-{
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "title": "A rectangle",
-    "properties": {
-        "width": {
-            "$ref": "#/definitions/length",
-            "default": 20
-        },
-        "height": {
-            "$ref": "#/definitions/length"
-        }
-    },
-    "definitions": {
-        "length": {
-            "type": "integer",
-            "minimum": 1,
-            "default": 10
-        }
-    }
-})"_json;
-
-int main()
-{
-	try {
-		json_validator validator{rectangle_schema};
-		/* validate empty json -> will be expanded by the default values defined in the schema */
-		json rectangle = "{}"_json;
-		const auto default_patch = validator.validate(rectangle);
-		rectangle = rectangle.patch(default_patch);
-		std::cout << rectangle.dump() << std::endl; // {"height":10,"width":20}
-	} catch (const std::exception &e) {
-		std::cerr << "Validation of schema failed: " << e.what() << "\n";
-		return EXIT_FAILURE;
-	}
-	return EXIT_SUCCESS;
-}
-```
-
-The example above will output the specified default values `{"height":10,"width":20}` to stdout.
-
-> Note that the default value specified in a `$ref` may be overridden by the current instance location. Also note that this behavior will break draft-7, but it is compliant to newer drafts (e.g. `2019-09` or `2020-12`).
-
-# Contributing
-
-This project uses [`pre-commit`](https://pre-commit.com/) to enforce style-checks. Please install and run it before
-creating commits and making pull requests.
-
-```console
-$ pip install pre-commit
-$ pre-commit install
-```

app/json-schema-validate.cpp

@@ -0,0 +1,108 @@
+/*
+ * Modern C++ JSON schema validator
+ *
+ * Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+ *
+ * Copyright (c) 2016 Patrick Boettcher <patrick.boettcher@posteo.de>.
+ *
+ * Permission is hereby  granted, free of charge, to any  person obtaining a
+ * copy of this software and associated  documentation files (the "Software"),
+ * to deal in the Software  without restriction, including without  limitation
+ * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
+ * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom
+ * the Software  is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
+ * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
+ * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
+ * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include <json-schema.hpp>
+
+#include <fstream>
+#include <iostream>
+
+using nlohmann::json;
+using nlohmann::json_uri;
+using nlohmann::json_schema_draft4::json_validator;
+
+static void usage(const char *name)
+{
+	std::cerr << "Usage: " << name << " <schema> < <document>\n";
+	exit(EXIT_FAILURE);
+}
+
+#if 0
+	resolver r(nlohmann::json_schema_draft4::root_schema,
+			   nlohmann::json_schema_draft4::root_schema["id"]);
+	schema_refs_.insert(r.schema_refs.begin(), r.schema_refs.end());
+	assert(r.undefined_refs.size() == 0);
+#endif
+
+static void loader(const json_uri &uri, json &schema)
+{
+	std::fstream lf("." + uri.path());
+	if (!lf.good())
+		throw std::invalid_argument("could not open " + uri.url() + " tried with " + uri.path());
+
+	try {
+		lf >> schema;
+	} catch (std::exception &e) {
+		throw e;
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc != 2)
+		usage(argv[0]);
+
+	std::fstream f(argv[1]);
+	if (!f.good()) {
+		std::cerr << "could not open " << argv[1] << " for reading\n";
+		usage(argv[0]);
+	}
+
+	// 1) Read the schema for the document you want to validate
+	json schema;
+	try {
+		f >> schema;
+	} catch (std::exception &e) {
+		std::cerr << e.what() << " at " << f.tellp() << " - while parsing the schema\n";
+		return EXIT_FAILURE;
+	}
+
+	// 2) create the validator and
+	json_validator validator(loader, [](const std::string &, const std::string &) {});
+
+	try {
+		// insert this schema as the root to the validator
+		// this resolves remote-schemas, sub-schemas and references via the given loader-function
+		validator.set_root_schema(schema);
+	} catch (std::exception &e) {
+		std::cerr << "setting root schema failed\n";
+		std::cerr << e.what() << "\n";
+	}
+
+	// 3) do the actual validation of the document
+	json document;
+
+	try {
+		std::cin >> document;
+		validator.validate(document);
+	} catch (std::exception &e) {
+		std::cerr << "schema validation failed\n";
+		std::cerr << e.what() << " at offset: " << std::cin.tellg() << "\n";
+		return EXIT_FAILURE;
+	}
+
+	std::cerr << "document is valid\n";
+
+	return EXIT_SUCCESS;
+}

cmake/CMakePresets-CI.json

@@ -1,281 +0,0 @@
-{
-  "version": 6,
-  "include": [
-    "CMakePresets-defaults.json"
-  ],
-  "configurePresets": [
-    {
-      "name": "ci-base",
-      "hidden": true,
-      "generator": "Ninja",
-      "inherits": [
-        "default"
-      ],
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": {
-          "type": "STRING",
-          "value": "Debug"
-        },
-        "JSON_VALIDATOR_BUILD_TESTS": {
-          "type": "BOOL",
-          "value": true
-        },
-        "JSON_VALIDATOR_INSTALL": {
-          "type": "BOOL",
-          "value": false
-        },
-        "JSON_BuildTests": {
-          "type": "BOOL",
-          "value": false
-        }
-      },
-      "errors": {
-        "deprecated": true
-      }
-    },
-    {
-      "name": "gcc-ci",
-      "displayName": "Configure preset for GCC toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "binaryDir": "cmake-build-ci-gcc",
-      "cacheVariables": {
-        "CMAKE_CXX_COMPILER": {
-          "type": "FILEPATH",
-          "value": "g++"
-        },
-        "CMAKE_LINKER": {
-          "type": "FILEPATH",
-          "value": "ld"
-        }
-      }
-    },
-    {
-      "name": "intel-ci",
-      "displayName": "Configure preset for Intel toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "binaryDir": "cmake-build-ci-intel",
-      "cacheVariables": {
-        "CMAKE_CXX_COMPILER": {
-          "type": "FILEPATH",
-          "value": "icpx"
-        }
-      }
-    },
-    {
-      "name": "llvm-ci",
-      "displayName": "Configure preset for LLVM toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "binaryDir": "cmake-build-ci-llvm",
-      "cacheVariables": {
-        "CMAKE_CXX_COMPILER": {
-          "type": "FILEPATH",
-          "value": "clang++"
-        },
-        "CMAKE_LINKER": {
-          "type": "FILEPATH",
-          "value": "lld"
-        }
-      }
-    },
-    {
-      "name": "ci-coverage",
-      "displayName": "Configure preset for test coverage",
-      "inherits": [
-        "gcc-ci"
-      ],
-      "binaryDir": "cmake-build-ci-coverage",
-      "errors": {
-        "deprecated": false
-      },
-      "cacheVariables": {
-        "JSON_VALIDATOR_TEST_COVERAGE": {
-          "type": "BOOL",
-          "value": true
-        }
-      }
-    },
-    {
-      "name": "pre-commit",
-      "displayName": "Configure preset for pre-commit checks",
-      "inherits": [
-        "default"
-      ],
-      "binaryDir": "cmake-build-pre-commit",
-      "cacheVariables": {
-        "JSON_VALIDATOR_TEST_COVERAGE": {
-          "type": "BOOL",
-          "value": true
-        },
-        "JSON_VALIDATOR_INSTALL": {
-          "type": "BOOL",
-          "value": false
-        }
-      }
-    }
-  ],
-  "buildPresets": [
-    {
-      "name": "ci-base",
-      "hidden": true,
-      "inherits": [
-        "default"
-      ],
-      "cleanFirst": true
-    },
-    {
-      "name": "ci-coverage",
-      "displayName": "Build preset for test coverage",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "ci-coverage"
-    },
-    {
-      "name": "gcc-ci",
-      "displayName": "Build preset for GCC toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "gcc-ci"
-    },
-    {
-      "name": "intel-ci",
-      "displayName": "Build preset for Intel toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "intel-ci"
-    },
-    {
-      "name": "llvm-ci",
-      "displayName": "Build preset for LLVM toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "llvm-ci"
-    }
-  ],
-  "testPresets": [
-    {
-      "name": "ci-base",
-      "hidden": true,
-      "inherits": [
-        "default"
-      ],
-      "output": {
-        "outputOnFailure": true
-      }
-    },
-    {
-      "name": "ci-coverage",
-      "inherits": [
-        "default"
-      ],
-      "configurePreset": "ci-coverage"
-    },
-    {
-      "name": "gcc-ci",
-      "displayName": "Test preset for GCC toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "gcc-ci"
-    },
-    {
-      "name": "intel-ci",
-      "displayName": "Test preset for Intel toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "intel-ci"
-    },
-    {
-      "name": "llvm-ci",
-      "displayName": "Test preset for LLVM toolchain",
-      "inherits": [
-        "ci-base"
-      ],
-      "configurePreset": "llvm-ci"
-    }
-  ],
-  "workflowPresets": [
-    {
-      "name": "gcc-ci",
-      "displayName": "CI test for GCC toolchain",
-      "steps": [
-        {
-          "type": "configure",
-          "name": "gcc-ci"
-        },
-        {
-          "type": "build",
-          "name": "gcc-ci"
-        },
-        {
-          "type": "test",
-          "name": "gcc-ci"
-        }
-      ]
-    },
-    {
-      "name": "intel-ci",
-      "displayName": "CI test for Intel toolchain",
-      "steps": [
-        {
-          "type": "configure",
-          "name": "intel-ci"
-        },
-        {
-          "type": "build",
-          "name": "intel-ci"
-        },
-        {
-          "type": "test",
-          "name": "intel-ci"
-        }
-      ]
-    },
-    {
-      "name": "llvm-ci",
-      "displayName": "CI test for LLVM toolchain",
-      "steps": [
-        {
-          "type": "configure",
-          "name": "llvm-ci"
-        },
-        {
-          "type": "build",
-          "name": "llvm-ci"
-        },
-        {
-          "type": "test",
-          "name": "llvm-ci"
-        }
-      ]
-    },
-    {
-      "name": "ci-coverage",
-      "displayName": "Coverage tests",
-      "steps": [
-        {
-          "type": "configure",
-          "name": "ci-coverage"
-        },
-        {
-          "type": "build",
-          "name": "ci-coverage"
-        },
-        {
-          "type": "test",
-          "name": "ci-coverage"
-        }
-      ]
-    }
-  ]
-}

cmake/CMakePresets-defaults.json

@@ -1,50 +0,0 @@
-{
-  "version": 6,
-  "configurePresets": [
-    {
-      "name": "default",
-      "displayName": "Default configuration preset",
-      "binaryDir": "cmake-build-release",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": {
-          "type": "STRING",
-          "value": "Release"
-        }
-      }
-    }
-  ],
-  "buildPresets": [
-    {
-      "name": "default",
-      "displayName": "Default build preset",
-      "configurePreset": "default"
-    }
-  ],
-  "testPresets": [
-    {
-      "name": "default",
-      "displayName": "Default test preset",
-      "configurePreset": "default"
-    }
-  ],
-  "workflowPresets": [
-    {
-      "name": "default",
-      "displayName": "Default workflow",
-      "steps": [
-        {
-          "type": "configure",
-          "name": "default"
-        },
-        {
-          "type": "build",
-          "name": "default"
-        },
-        {
-          "type": "test",
-          "name": "default"
-        }
-      ]
-    }
-  ]
-}

cmake/nlohmann_json_schema_validatorConfig.cmake.in

@@ -1,9 +0,0 @@
-@PACKAGE_INIT@
-
-include(CMakeFindDependencyMacro)
-find_dependency(nlohmann_json)
-
-include("${CMAKE_CURRENT_LIST_DIR}/nlohmann_json_schema_validatorTargets.cmake")
-check_required_components(
-  "nlohmann_json_schema_validator"
-  )

conanfile.py

@@ -1,93 +0,0 @@
-import os
-import re
-
-from conan import ConanFile
-from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
-from conans.tools import load
-from conans import tools as ctools
-
-def get_version():
-    try:
-        version = os.getenv('PROJECT_VERSION', None)
-        if version:
-            return version
-
-        content = load('CMakeLists.txt')
-        version = re.search('set\(PROJECT_VERSION (.*)\)', content).group(1)
-        return version.strip()
-    except:
-        return None
-
-class JsonSchemaValidatorConan(ConanFile):
-    name = 'JsonSchemaValidator'
-    version = get_version()
-    url = 'https://github.com/pboettch/json-schema-validator'
-    license = 'MIT'
-
-    settings = 'os', 'compiler', 'build_type', 'arch'
-
-    options = {
-        'shared': [True, False],
-        'fPIC': [True, False],
-        'build_examples': [True, False],
-        'build_tests': [True, False],
-        'test_coverage': [True, False],
-    }
-
-    default_options = {
-        'shared': False,
-        'fPIC': True,
-        'build_examples': True,
-        'build_tests': False,
-        'test_coverage': False,
-    }
-
-    generators = 'CMakeDeps', 'CMakeToolchain', 'VirtualBuildEnv', 'VirtualRunEnv'
-
-    exports_sources = [
-        'CMakeLists.txt',
-        'conanfile.py',
-        'cmake/*',
-        'src/*',
-        'example/*',
-        'test/*',
-    ]
-
-    requires = [
-        'nlohmann_json/3.11.2'
-    ]
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables['JSON_VALIDATOR_BUILD_EXAMPLES'] = self.options.build_examples
-        tc.variables['JSON_VALIDATOR_BUILD_TESTS'] = self.options.build_tests
-        tc.variables['JSON_VALIDATOR_SHARED_LIBS '] = self.options.shared
-        tc.variables['JSON_VALIDATOR_TEST_COVERAGE '] = self.options.test_coverage
-        tc.generate()
-
-    def layout(self):
-        cmake_layout(self)
-
-    def build(self):
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.verbose = True
-        cmake.build()
-
-    def package(self):
-        cmake = CMake(self)
-        cmake.install()
-
-    def package_info(self):
-        includedir = os.path.join(self.package_folder, "include")
-        self.cpp_info.includedirs = [includedir]
-
-        libdir = os.path.join(self.package_folder, "lib")
-        self.cpp_info.libdirs = [libdir]
-        self.cpp_info.libs += ctools.collect_libs(self, libdir)
-
-        bindir = os.path.join(self.package_folder, "bin")
-        self.output.info("Appending PATH environment variable: {}".format(bindir))
-        self.env_info.PATH.append(bindir)
-
-        self.user_info.VERSION = self.version

example/CMakeLists.txt

@@ -1,14 +0,0 @@
-# simple nlohmann_json_schema_validator-executable
-add_executable(json-schema-validate json-schema-validate.cpp)
-target_link_libraries(json-schema-validate nlohmann_json_schema_validator)
-
-add_executable(readme-json-schema readme.cpp)
-target_link_libraries(readme-json-schema nlohmann_json_schema_validator)
-
-add_executable(format-json-schema format.cpp)
-target_link_libraries(format-json-schema nlohmann_json_schema_validator)
-
-if (JSON_VALIDATOR_INSTALL)
-    install(TARGETS json-schema-validate readme-json-schema format-json-schema
-            DESTINATION ${CMAKE_INSTALL_BINDIR})
-endif ()

example/format.cpp

@@ -1,54 +0,0 @@
-#include <iostream>
-
-#include <nlohmann/json-schema.hpp>
-
-using nlohmann::json;
-using nlohmann::json_schema::json_validator;
-
-// The schema is defined based upon a string literal
-static json uri_schema = R"(
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "myUri": {
-      "type":"string",
-      "format": "uri"
-    }
-  }
-})"_json;
-
-// The people are defined with brace initialization
-static json good_uri = {{"myUri", "http://hostname.com/"}};
-static json bad_uri = {{"myUri", "http:/hostname.com/"}};
-
-static void uri_format_checker(const std::string &format, const std::string &value)
-{
-	if (format == "uri") {
-		if (value.find("://") == std::string::npos)
-			throw std::invalid_argument("URI does not contain :// - invalid");
-	} else
-		throw std::logic_error("Don't know how to validate " + format);
-}
-
-int main()
-{
-	json_validator validator(nullptr, uri_format_checker); // create validator
-
-	try {
-		validator.set_root_schema(uri_schema); // insert root-schema
-	} catch (const std::exception &e) {
-		std::cerr << "Validation of schema failed, here is why: " << e.what() << "\n";
-		return EXIT_FAILURE;
-	}
-
-	validator.validate(good_uri);
-
-	try {
-		validator.validate(bad_uri);
-	} catch (const std::exception &e) {
-		std::cerr << "Validation expectedly failed, here is why: " << e.what() << "\n";
-	}
-
-	return EXIT_SUCCESS;
-}

example/json-schema-validate.cpp

@@ -1,100 +0,0 @@
-/*
- * JSON schema validator for JSON for modern C++
- *
- * Copyright (c) 2016-2019 Patrick Boettcher <p@yai.se>.
- *
- * SPDX-License-Identifier: MIT
- *
- */
-#include <nlohmann/json-schema.hpp>
-
-#include <fstream>
-#include <iostream>
-
-using nlohmann::json;
-using nlohmann::json_uri;
-using nlohmann::json_schema::json_validator;
-
-static void usage(const char *name)
-{
-	std::cerr << "Usage: " << name << " <schema> < <document>\n";
-	exit(EXIT_FAILURE);
-}
-
-static void loader(const json_uri &uri, json &schema)
-{
-	std::string filename = "./" + uri.path();
-	std::ifstream lf(filename);
-	if (!lf.good())
-		throw std::invalid_argument("could not open " + uri.url() + " tried with " + filename);
-	try {
-		lf >> schema;
-	} catch (const std::exception &e) {
-		throw e;
-	}
-}
-
-class custom_error_handler : public nlohmann::json_schema::basic_error_handler
-{
-	void error(const nlohmann::json::json_pointer &ptr, const json &instance, const std::string &message) override
-	{
-		nlohmann::json_schema::basic_error_handler::error(ptr, instance, message);
-		std::cerr << "ERROR: '" << ptr << "' - '" << instance << "': " << message << "\n";
-	}
-};
-
-int main(int argc, char *argv[])
-{
-	if (argc != 2)
-		usage(argv[0]);
-
-	std::ifstream f(argv[1]);
-	if (!f.good()) {
-		std::cerr << "could not open " << argv[1] << " for reading\n";
-		usage(argv[0]);
-	}
-
-	// 1) Read the schema for the document you want to validate
-	json schema;
-	try {
-		f >> schema;
-	} catch (const std::exception &e) {
-		std::cerr << e.what() << " at " << f.tellg() << " - while parsing the schema\n";
-		return EXIT_FAILURE;
-	}
-
-	// 2) create the validator and
-	json_validator validator(loader,
-	                         nlohmann::json_schema::default_string_format_check);
-
-	try {
-		// insert this schema as the root to the validator
-		// this resolves remote-schemas, sub-schemas and references via the given loader-function
-		validator.set_root_schema(schema);
-	} catch (const std::exception &e) {
-		std::cerr << "setting root schema failed\n";
-		std::cerr << e.what() << "\n";
-	}
-
-	// 3) do the actual validation of the document
-	json document;
-
-	try {
-		std::cin >> document;
-	} catch (const std::exception &e) {
-		std::cerr << "json parsing failed: " << e.what() << " at offset: " << std::cin.tellg() << "\n";
-		return EXIT_FAILURE;
-	}
-
-	custom_error_handler err;
-	validator.validate(document, err);
-
-	if (err) {
-		std::cerr << "schema validation failed\n";
-		return EXIT_FAILURE;
-	}
-
-	std::cerr << "document is valid\n";
-
-	return EXIT_SUCCESS;
-}

example/readme.cpp

@@ -1,100 +0,0 @@
-#include <iomanip>
-#include <iostream>
-
-#include <nlohmann/json-schema.hpp>
-
-using nlohmann::json;
-using nlohmann::json_schema::json_validator;
-
-// The schema is defined based upon a string literal
-static json person_schema = R"(
-{
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "title": "A person",
-    "properties": {
-      "name": {
-          "description": "Name",
-          "type": "string"
-      },
-      "age": {
-          "description": "Age of the person",
-          "type": "number",
-          "minimum": 2,
-          "maximum": 200
-      },
-      "address":{
-        "type": "object",
-        "properties":{
-          "street":{
-            "type": "string",
-            "default": "Abbey Road"
-          }
-        }
-      }
-    },
-    "required": [
-                 "name",
-                 "age"
-                 ],
-    "type": "object"
-}
-
-)"_json;
-
-// The people are defined with brace initialization
-static json bad_person = {{"age", 42}};
-static json good_person = {{"name", "Albert"}, {"age", 42}, {"address", {{"street", "Main Street"}}}};
-static json good_defaulted_person = {{"name", "Knut"}, {"age", 69}, {"address", {}}};
-
-int main()
-{
-	/* json-parse the schema */
-
-	json_validator validator; // create validator
-
-	try {
-		validator.set_root_schema(person_schema); // insert root-schema
-	} catch (const std::exception &e) {
-		std::cerr << "Validation of schema failed, here is why: " << e.what() << "\n";
-		return EXIT_FAILURE;
-	}
-
-	/* json-parse the people - API of 1.0.0, default throwing error handler */
-
-	for (auto &person : {bad_person, good_person, good_defaulted_person}) {
-		std::cout << "About to validate this person:\n"
-		          << std::setw(2) << person << std::endl;
-		try {
-			auto defaultPatch = validator.validate(person); // validate the document - uses the default throwing error-handler
-			std::cout << "Validation succeeded\n";
-			std::cout << "Patch with defaults: " << defaultPatch.dump(2) << std::endl;
-		} catch (const std::exception &e) {
-			std::cerr << "Validation failed, here is why: " << e.what() << "\n";
-		}
-	}
-
-	/* json-parse the people - with custom error handler */
-	class custom_error_handler : public nlohmann::json_schema::basic_error_handler
-	{
-		void error(const nlohmann::json::json_pointer &ptr, const json &instance, const std::string &message) override
-		{
-			nlohmann::json_schema::basic_error_handler::error(ptr, instance, message);
-			std::cerr << "ERROR: '" << ptr << "' - '" << instance << "': " << message << "\n";
-		}
-	};
-
-	for (auto &person : {bad_person, good_person}) {
-		std::cout << "About to validate this person:\n"
-		          << std::setw(2) << person << std::endl;
-
-		custom_error_handler err;
-		validator.validate(person, err); // validate the document
-
-		if (err)
-			std::cerr << "Validation failed\n";
-		else
-			std::cout << "Validation succeeded\n";
-	}
-
-	return EXIT_SUCCESS;
-}

src/CMakeLists.txt

@@ -1,64 +0,0 @@
-target_sources(nlohmann_json_schema_validator PRIVATE
-        smtp-address-validator.cpp
-        json-schema-draft7.json.cpp
-        json-uri.cpp
-        json-validator.cpp
-        json-patch.cpp
-        string-format-check.cpp
-        )
-target_include_directories(nlohmann_json_schema_validator PUBLIC
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        )
-
-set_target_properties(nlohmann_json_schema_validator PROPERTIES
-        PUBLIC_HEADER nlohmann/json-schema.hpp)
-
-# TODO: Why would this need to be if guarded?
-if (JSON_VALIDATOR_SHARED_LIBS)
-    target_compile_definitions(nlohmann_json_schema_validator PRIVATE
-            -DJSON_SCHEMA_VALIDATOR_EXPORTS)
-endif ()
-
-# TODO: Consider setting minimum cxx standard instead
-target_compile_features(nlohmann_json_schema_validator PUBLIC
-        cxx_range_for) # for C++11 - flags
-
-# TODO: This should be handled by the CI/presets, not the cmake
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR
-        "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    target_compile_options(nlohmann_json_schema_validator
-            PRIVATE
-            -Wall -Wextra -Wshadow)
-endif ()
-
-# TODO: gcc support for <4.9 should be removed
-# regex with boost if gcc < 4.9 - default is std::regex
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9.0")
-        find_package(Boost COMPONENTS regex)
-        if (NOT Boost_FOUND)
-            message(STATUS "GCC less then 4.9 and boost-regex NOT found - no regex used")
-            target_compile_definitions(nlohmann_json_schema_validator PRIVATE -DJSON_SCHEMA_NO_REGEX)
-        else ()
-            message(STATUS "GCC less then 4.9 and boost-regex FOUND - using boost::regex")
-            target_compile_definitions(nlohmann_json_schema_validator PRIVATE -DJSON_SCHEMA_BOOST_REGEX)
-            target_include_directories(nlohmann_json_schema_validator PRIVATE ${Boost_INCLUDE_DIRS})
-            target_link_libraries(nlohmann_json_schema_validator PRIVATE ${Boost_LIBRARIES})
-        endif ()
-    endif ()
-endif ()
-
-target_link_libraries(nlohmann_json_schema_validator PUBLIC
-        nlohmann_json::nlohmann_json)
-
-if (JSON_VALIDATOR_INSTALL)
-    # Normal installation target to system. When using scikit-build check python subdirectory
-    install(TARGETS nlohmann_json_schema_validator
-            EXPORT nlohmann_json_schema_validatorTargets
-            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT nlohmann_json_schema_validator_Runtime
-            NAMELINK_COMPONENT nlohmann_json_schema_validator_Development
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT nlohmann_json_schema_validator_Development
-            PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/nlohmann COMPONENT nlohmann_json_schema_validator_Development
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT nlohmann_json_schema_validator_Runtime)
-endif ()

src/json-patch.cpp

@@ -1,115 +0,0 @@
-#include "json-patch.hpp"
-
-#include <nlohmann/json-schema.hpp>
-
-namespace
-{
-
-// originally from http://jsonpatch.com/, http://json.schemastore.org/json-patch
-// with fixes
-const nlohmann::json patch_schema = R"patch({
-    "title": "JSON schema for JSONPatch files",
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "type": "array",
-
-    "items": {
-        "oneOf": [
-            {
-                "additionalProperties": false,
-                "required": [ "value", "op", "path"],
-                "properties": {
-                    "path" : { "$ref": "#/definitions/path" },
-                    "op": {
-                        "description": "The operation to perform.",
-                        "type": "string",
-                        "enum": [ "add", "replace", "test" ]
-                    },
-                    "value": {
-                        "description": "The value to add, replace or test."
-                    }
-                }
-            },
-            {
-                "additionalProperties": false,
-                "required": [ "op", "path"],
-                "properties": {
-                    "path" : { "$ref": "#/definitions/path" },
-                    "op": {
-                        "description": "The operation to perform.",
-                        "type": "string",
-                        "enum": [ "remove" ]
-                    }
-                }
-            },
-            {
-                "additionalProperties": false,
-                "required": [ "from", "op", "path" ],
-                "properties": {
-                    "path" : { "$ref": "#/definitions/path" },
-                    "op": {
-                        "description": "The operation to perform.",
-                        "type": "string",
-                        "enum": [ "move", "copy" ]
-                    },
-                    "from": {
-                        "$ref": "#/definitions/path",
-                        "description": "A JSON Pointer path pointing to the location to move/copy from."
-                    }
-                }
-            }
-        ]
-    },
-    "definitions": {
-        "path": {
-            "description": "A JSON Pointer path.",
-            "type": "string"
-        }
-    }
-})patch"_json;
-} // namespace
-
-namespace nlohmann
-{
-
-json_patch::json_patch(json &&patch)
-    : j_(std::move(patch))
-{
-	validateJsonPatch(j_);
-}
-
-json_patch::json_patch(const json &patch)
-    : j_(std::move(patch))
-{
-	validateJsonPatch(j_);
-}
-
-json_patch &json_patch::add(const json::json_pointer &ptr, json value)
-{
-	j_.push_back(json{{"op", "add"}, {"path", ptr.to_string()}, {"value", std::move(value)}});
-	return *this;
-}
-
-json_patch &json_patch::replace(const json::json_pointer &ptr, json value)
-{
-	j_.push_back(json{{"op", "replace"}, {"path", ptr.to_string()}, {"value", std::move(value)}});
-	return *this;
-}
-
-json_patch &json_patch::remove(const json::json_pointer &ptr)
-{
-	j_.push_back(json{{"op", "remove"}, {"path", ptr.to_string()}});
-	return *this;
-}
-
-void json_patch::validateJsonPatch(json const &patch)
-{
-	// static put here to have it created at the first usage of validateJsonPatch
-	static nlohmann::json_schema::json_validator patch_validator(patch_schema);
-
-	patch_validator.validate(patch);
-
-	for (auto const &op : patch)
-		json::json_pointer(op["path"].get<std::string>());
-}
-
-} // namespace nlohmann

src/json-patch.hpp

@@ -1,41 +0,0 @@
-#pragma once
-
-#include <nlohmann/json.hpp>
-#include <string>
-
-namespace nlohmann
-{
-class JsonPatchFormatException : public std::exception
-{
-public:
-	explicit JsonPatchFormatException(std::string msg)
-	    : ex_{std::move(msg)} {}
-
-	inline const char *what() const noexcept override final { return ex_.c_str(); }
-
-private:
-	std::string ex_;
-};
-
-class json_patch
-{
-public:
-	json_patch() = default;
-	json_patch(json &&patch);
-	json_patch(const json &patch);
-
-	json_patch &add(const json::json_pointer &, json value);
-	json_patch &replace(const json::json_pointer &, json value);
-	json_patch &remove(const json::json_pointer &);
-
-	json &get_json() { return j_; }
-	const json &get_json() const { return j_; }
-
-	operator json() const { return j_; }
-
-private:
-	json j_ = nlohmann::json::array();
-
-	static void validateJsonPatch(json const &patch);
-};
-} // namespace nlohmann

src/json-schema-draft4.json.cpp

@@ -1,114 +1,109 @@
+#include <json-schema.hpp>
+
+namespace nlohmann
 {
-    "$schema": "http://json-schema.org/draft-07/schema#",
+namespace json_schema_draft4
-    "$id": "http://json-schema.org/draft-07/schema#",
+{
-    "title": "Core schema meta-schema",
+
+json draft4_schema_builtin = R"( {
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
     "definitions": {
         "schemaArray": {
             "type": "array",
             "minItems": 1,
             "items": { "$ref": "#" }
         },
-        "nonNegativeInteger": {
+        "positiveInteger": {
             "type": "integer",
             "minimum": 0
         },
-        "nonNegativeIntegerDefault0": {
+        "positiveIntegerDefault0": {
-            "allOf": [
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
-                { "$ref": "#/definitions/nonNegativeInteger" },
-                { "default": 0 }
-            ]
         },
         "simpleTypes": {
-            "enum": [
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
-                "array",
-                "boolean",
-                "integer",
-                "null",
-                "number",
-                "object",
-                "string"
-            ]
         },
         "stringArray": {
             "type": "array",
             "items": { "type": "string" },
-            "uniqueItems": true,
+            "minItems": 1,
-            "default": []
+            "uniqueItems": true
         }
     },
-    "type": ["object", "boolean"],
+    "type": "object",
     "properties": {
-        "$id": {
+        "id": {
             "type": "string",
-            "format": "uri-reference"
+            "format": "uri"
         },
         "$schema": {
             "type": "string",
             "format": "uri"
         },
-        "$ref": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "$comment": {
-            "type": "string"
-        },
         "title": {
             "type": "string"
         },
         "description": {
             "type": "string"
         },
-        "default": true,
+        "default": {},
-        "readOnly": {
-            "type": "boolean",
-            "default": false
-        },
-        "examples": {
-            "type": "array",
-            "items": true
-        },
         "multipleOf": {
             "type": "number",
-            "exclusiveMinimum": 0
+            "minimum": 0,
+            "exclusiveMinimum": true
         },
         "maximum": {
             "type": "number"
         },
         "exclusiveMaximum": {
-            "type": "number"
+            "type": "boolean",
+            "default": false
         },
         "minimum": {
             "type": "number"
         },
         "exclusiveMinimum": {
-            "type": "number"
+            "type": "boolean",
+            "default": false
         },
-        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
-        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
         "pattern": {
             "type": "string",
             "format": "regex"
         },
-        "additionalItems": { "$ref": "#" },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
         "items": {
             "anyOf": [
                 { "$ref": "#" },
                 { "$ref": "#/definitions/schemaArray" }
             ],
-            "default": true
+            "default": {}
         },
-        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
-        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
         "uniqueItems": {
             "type": "boolean",
             "default": false
         },
-        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
-        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
-        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
         "required": { "$ref": "#/definitions/stringArray" },
-        "additionalProperties": { "$ref": "#" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
         "definitions": {
             "type": "object",
             "additionalProperties": { "$ref": "#" },
@@ -122,7 +117,6 @@
         "patternProperties": {
             "type": "object",
             "additionalProperties": { "$ref": "#" },
-            "propertyNames": { "format": "regex" },
             "default": {}
         },
         "dependencies": {
@@ -134,11 +128,8 @@
                 ]
             }
         },
-        "propertyNames": { "$ref": "#" },
-        "const": true,
         "enum": {
             "type": "array",
-            "items": true,
             "minItems": 1,
             "uniqueItems": true
         },
@@ -153,16 +144,17 @@
                 }
             ]
         },
-        "format": { "type": "string" },
-        "contentMediaType": { "type": "string" },
-        "contentEncoding": { "type": "string" },
-        "if": {"$ref": "#"},
-        "then": {"$ref": "#"},
-        "else": {"$ref": "#"},
         "allOf": { "$ref": "#/definitions/schemaArray" },
         "anyOf": { "$ref": "#/definitions/schemaArray" },
         "oneOf": { "$ref": "#/definitions/schemaArray" },
         "not": { "$ref": "#" }
     },
-    "default": true
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+} )"_json;
+
+}
 }

src/json-schema-draft7.json.cpp

@@ -1,185 +0,0 @@
-/*
- * JSON schema validator for JSON for modern C++
- *
- * Copyright (c) 2016-2019 Patrick Boettcher <p@yai.se>.
- *
- * SPDX-License-Identifier: MIT
- *
- */
-#include <nlohmann/json.hpp>
-
-namespace nlohmann
-{
-namespace json_schema
-{
-
-json draft7_schema_builtin = R"( {
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "$id": "http://json-schema.org/draft-07/schema#",
-    "title": "Core schema meta-schema",
-    "definitions": {
-        "schemaArray": {
-            "type": "array",
-            "minItems": 1,
-            "items": { "$ref": "#" }
-        },
-        "nonNegativeInteger": {
-            "type": "integer",
-            "minimum": 0
-        },
-        "nonNegativeIntegerDefault0": {
-            "allOf": [
-                { "$ref": "#/definitions/nonNegativeInteger" },
-                { "default": 0 }
-            ]
-        },
-        "simpleTypes": {
-            "enum": [
-                "array",
-                "boolean",
-                "integer",
-                "null",
-                "number",
-                "object",
-                "string"
-            ]
-        },
-        "stringArray": {
-            "type": "array",
-            "items": { "type": "string" },
-            "uniqueItems": true,
-            "default": []
-        }
-    },
-    "type": ["object", "boolean"],
-    "properties": {
-        "$id": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "$schema": {
-            "type": "string",
-            "format": "uri"
-        },
-        "$ref": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "$comment": {
-            "type": "string"
-        },
-        "title": {
-            "type": "string"
-        },
-        "description": {
-            "type": "string"
-        },
-        "default": true,
-        "readOnly": {
-            "type": "boolean",
-            "default": false
-        },
-        "examples": {
-            "type": "array",
-            "items": true
-        },
-        "multipleOf": {
-            "type": "number",
-            "exclusiveMinimum": 0
-        },
-        "maximum": {
-            "type": "number"
-        },
-        "exclusiveMaximum": {
-            "type": "number"
-        },
-        "minimum": {
-            "type": "number"
-        },
-        "exclusiveMinimum": {
-            "type": "number"
-        },
-        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
-        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-        "pattern": {
-            "type": "string",
-            "format": "regex"
-        },
-        "additionalItems": { "$ref": "#" },
-        "items": {
-            "anyOf": [
-                { "$ref": "#" },
-                { "$ref": "#/definitions/schemaArray" }
-            ],
-            "default": true
-        },
-        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
-        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-        "uniqueItems": {
-            "type": "boolean",
-            "default": false
-        },
-        "contains": { "$ref": "#" },
-        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
-        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
-        "required": { "$ref": "#/definitions/stringArray" },
-        "additionalProperties": { "$ref": "#" },
-        "definitions": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "properties": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "default": {}
-        },
-        "patternProperties": {
-            "type": "object",
-            "additionalProperties": { "$ref": "#" },
-            "propertyNames": { "format": "regex" },
-            "default": {}
-        },
-        "dependencies": {
-            "type": "object",
-            "additionalProperties": {
-                "anyOf": [
-                    { "$ref": "#" },
-                    { "$ref": "#/definitions/stringArray" }
-                ]
-            }
-        },
-        "propertyNames": { "$ref": "#" },
-        "const": true,
-        "enum": {
-            "type": "array",
-            "items": true,
-            "minItems": 1,
-            "uniqueItems": true
-        },
-        "type": {
-            "anyOf": [
-                { "$ref": "#/definitions/simpleTypes" },
-                {
-                    "type": "array",
-                    "items": { "$ref": "#/definitions/simpleTypes" },
-                    "minItems": 1,
-                    "uniqueItems": true
-                }
-            ]
-        },
-        "format": { "type": "string" },
-        "contentMediaType": { "type": "string" },
-        "contentEncoding": { "type": "string" },
-        "if": { "$ref": "#" },
-        "then": { "$ref": "#" },
-        "else": { "$ref": "#" },
-        "allOf": { "$ref": "#/definitions/schemaArray" },
-        "anyOf": { "$ref": "#/definitions/schemaArray" },
-        "oneOf": { "$ref": "#/definitions/schemaArray" },
-        "not": { "$ref": "#" }
-    },
-    "default": true
-} )"_json;
-}
-} // namespace nlohmann

src/json-schema.hpp

@@ -0,0 +1,203 @@
+/*
+ * Modern C++ JSON schema validator
+ *
+ * Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+ *
+ * Copyright (c) 2016 Patrick Boettcher <patrick.boettcher@posteo.de>.
+ *
+ * Permission is hereby  granted, free of charge, to any  person obtaining a
+ * copy of this software and associated  documentation files (the "Software"),
+ * to deal in the Software  without restriction, including without  limitation
+ * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
+ * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom
+ * the Software  is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
+ * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
+ * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
+ * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NLOHMANN_JSON_SCHEMA_HPP__
+#define NLOHMANN_JSON_SCHEMA_HPP__
+
+#ifdef _WIN32
+#    if defined(JSON_SCHEMA_VALIDATOR_EXPORTS)
+#        define JSON_SCHEMA_VALIDATOR_API __declspec(dllexport)
+#    elif defined(JSON_SCHEMA_VALIDATOR_IMPORTS)
+#        define JSON_SCHEMA_VALIDATOR_API __declspec(dllimport)
+#    else
+#        define JSON_SCHEMA_VALIDATOR_API
+#    endif
+#else
+#    define JSON_SCHEMA_VALIDATOR_API
+#endif
+
+#include <nlohmann/json.hpp>
+
+// make yourself a home - welcome to nlohmann's namespace
+namespace nlohmann
+{
+
+// a class representing a JSON-pointer RFC6901
+//
+// examples of JSON pointers
+//
+//   #     - root of the current document
+//   #item - refers to the object which is identified ("id") by `item`
+//           in the current document
+//   #/path/to/element
+//         - refers to the element in /path/to from the root-document
+//
+//
+// The json_pointer-class stores everything in a string, which might seem bizarre
+// as parsing is done from a string to a string, but from_string() is also
+// doing some formatting.
+//
+// TODO
+//   ~ and %  - codec
+//   needs testing and clarification regarding the '#' at the beginning
+
+class local_json_pointer
+{
+	std::string str_;
+
+	void from_string(const std::string &r);
+
+public:
+	local_json_pointer(const std::string &s = "")
+	{
+		from_string(s);
+	}
+
+	void append(const std::string &elem)
+	{
+		str_.append(elem);
+	}
+
+	const std::string &to_string() const
+	{
+		return str_;
+	}
+};
+
+// A class representing a JSON-URI for schemas derived from
+// section 8 of JSON Schema: A Media Type for Describing JSON Documents
+// draft-wright-json-schema-00
+//
+// New URIs can be derived from it using the derive()-method.
+// This is useful for resolving refs or subschema-IDs in json-schemas.
+//
+// This is done implement the requirements described in section 8.2.
+//
+class JSON_SCHEMA_VALIDATOR_API json_uri
+{
+	std::string urn_;
+
+	std::string proto_;
+	std::string hostname_;
+	std::string path_;
+	local_json_pointer pointer_;
+
+protected:
+	// decodes a JSON uri and replaces all or part of the currently stored values
+	void from_string(const std::string &uri);
+
+	std::tuple<std::string, std::string, std::string, std::string, std::string> tie() const
+	{
+		return std::tie(urn_, proto_, hostname_, path_, pointer_.to_string());
+	}
+
+public:
+	json_uri(const std::string &uri)
+	{
+		from_string(uri);
+	}
+
+	const std::string protocol() const { return proto_; }
+	const std::string hostname() const { return hostname_; }
+	const std::string path() const { return path_; }
+	const local_json_pointer pointer() const { return pointer_; }
+
+	const std::string url() const;
+
+	// decode and encode strings for ~ and % escape sequences
+	static std::string unescape(const std::string &);
+	static std::string escape(const std::string &);
+
+	// create a new json_uri based in this one and the given uri
+	// resolves relative changes (pathes or pointers) and resets part if proto or hostname changes
+	json_uri derive(const std::string &uri) const
+	{
+		json_uri u = *this;
+		u.from_string(uri);
+		return u;
+	}
+
+	// append a pointer-field to the pointer-part of this uri
+	json_uri append(const std::string &field) const
+	{
+		json_uri u = *this;
+		u.pointer_.append("/" + field);
+		return u;
+	}
+
+	std::string to_string() const;
+
+	friend bool operator<(const json_uri &l, const json_uri &r)
+	{
+		return l.tie() < r.tie();
+	}
+
+	friend bool operator==(const json_uri &l, const json_uri &r)
+	{
+		return l.tie() == r.tie();
+	}
+
+	friend std::ostream &operator<<(std::ostream &os, const json_uri &u);
+};
+
+namespace json_schema_draft4
+{
+
+extern json draft4_schema_builtin;
+
+class JSON_SCHEMA_VALIDATOR_API json_validator
+{
+	std::vector<std::shared_ptr<json>> schema_store_;
+	std::shared_ptr<json> root_schema_;
+	std::function<void(const json_uri &, json &)> schema_loader_ = nullptr;
+	std::function<void(const std::string &, const std::string &)> format_check_ = nullptr;
+
+	std::map<json_uri, const json *> schema_refs_;
+
+	void validate(const json &instance, const json &schema_, const std::string &name);
+	void validate_array(const json &instance, const json &schema_, const std::string &name);
+	void validate_object(const json &instance, const json &schema_, const std::string &name);
+    void validate_string(const json &instance, const json &schema, const std::string &name);
+
+	void insert_schema(const json &input, const json_uri &id);
+
+public:
+	json_validator(std::function<void(const json_uri &, json &)> loader = nullptr,
+	               std::function<void(const std::string &, const std::string &)> format = nullptr)
+	    : schema_loader_(loader), format_check_(format)
+	{
+	}
+
+	// insert and set a root-schema
+	void set_root_schema(const json &);
+
+	// validate a json-document based on the root-schema
+	void validate(const json &instance);
+};
+
+} // json_schema_draft4
+} // nlohmann
+
+#endif /* NLOHMANN_JSON_SCHEMA_HPP__ */

src/json-uri.cpp

@@ -1,115 +1,111 @@
 /*
- * JSON schema validator for JSON for modern C++
+ * Modern C++ JSON schema validator
  *
- * Copyright (c) 2016-2019 Patrick Boettcher <p@yai.se>.
+ * Licensed under the MIT License <http://opensource.org/licenses/MIT>.
  *
- * SPDX-License-Identifier: MIT
+ * Copyright (c) 2016 Patrick Boettcher <patrick.boettcher@posteo.de>.
  *
+ * Permission is hereby  granted, free of charge, to any  person obtaining a
+ * copy of this software and associated  documentation files (the "Software"),
+ * to deal in the Software  without restriction, including without  limitation
+ * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
+ * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom
+ * the Software  is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
+ * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
+ * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
+ * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-#include <nlohmann/json-schema.hpp>
+#include "json-schema.hpp"
 
 #include <sstream>
 
 namespace nlohmann
 {
 
-void json_uri::update(const std::string &uri)
+void local_json_pointer::from_string(const std::string &r)
 {
-	std::string pointer = ""; // default pointer is document-root
+	str_ = "#";
 
-	// first split the URI into location and pointer
+	if (r.size() == 0)
-	auto pointer_separator = uri.find('#');
+		return;
-	if (pointer_separator != std::string::npos) {    // and extract the pointer-string if found
+
-		pointer = uri.substr(pointer_separator + 1); // remove #
+	if (r[0] != '#')
+		throw std::invalid_argument("not a valid JSON pointer - missing # at the beginning");
+
+	if (r.size() == 1)
+		return;
+
+	std::size_t pos = 1;
 
-		// unescape %-values IOW, decode JSON-URI-formatted JSON-pointer
-		std::size_t pos = pointer.size() - 1;
 	do {
-			pos = pointer.rfind('%', pos);
+		std::size_t next = r.find('/', pos + 1);
-			if (pos == std::string::npos)
+		str_.append(r.substr(pos, next - pos));
-				break;
+		pos = next;
-
+	} while (pos != std::string::npos);
-			if (pos >= pointer.size() - 2) {
-				pos--;
-				continue;
 }
 
-			std::string hex = pointer.substr(pos + 1, 2);
+void json_uri::from_string(const std::string &uri)
-			char ascii = static_cast<char>(std::strtoul(hex.c_str(), nullptr, 16));
+{
-			pointer.replace(pos, 3, 1, ascii);
+	// if it is an urn take it as it is - maybe there is more to be done
-
+	if (uri.find("urn:") == 0) {
-			pos--;
+		urn_ = uri;
-		} while (1);
+		return;
 	}
 
-	auto location = uri.substr(0, pointer_separator);
+	std::string pointer = "#"; // default pointer is the root
 
-	if (location.size()) { // a location part has been found
+	// first split the URI into URL and JSON-pointer
+	auto pointer_separator = uri.find('#');
+	if (pointer_separator != std::string::npos) // and extract the JSON-pointer-string if found
+		pointer = uri.substr(pointer_separator);
 
-		// if it is an URN take it as it is
+	// the rest is an URL
-		if (location.find("urn:") == 0) {
+	std::string url = uri.substr(0, pointer_separator);
-			urn_ = location;
+	if (url.size()) { // if an URL is part of the URI
 
-			// and clear URL members
-			scheme_ = "";
-			authority_ = "";
-			path_ = "";
-
-		} else { // it is an URL
-
-			// split URL in protocol, hostname and path
 		std::size_t pos = 0;
-			auto proto = location.find("://", pos);
+		auto proto = url.find("://", pos);
 		if (proto != std::string::npos) { // extract the protocol
-
+			proto_ = url.substr(pos, proto - pos);
-				urn_ = ""; // clear URN-member if URL is parsed
-
-				scheme_ = location.substr(pos, proto - pos);
 			pos = 3 + proto; // 3 == "://"
 
-				auto authority = location.find("/", pos);
+			auto hostname = url.find("/", pos);
-				if (authority != std::string::npos) { // and the hostname (no proto without hostname)
+			if (hostname != std::string::npos) { // and the hostname (no proto without hostname)
-					authority_ = location.substr(pos, authority - pos);
+				hostname_ = url.substr(pos, hostname - pos);
-					pos = authority;
+				pos = hostname;
 			}
 		}
 
-			auto path = location.substr(pos);
+		// the rest is the path
-
+		auto path = url.substr(pos);
-			// URNs cannot of have paths
-			if (urn_.size() && path.size())
-				throw std::invalid_argument("Cannot add a path (" + path + ") to an URN URI (" + urn_ + ")");
-
 		if (path[0] == '/') // if it starts with a / it is root-path
 			path_ = path;
-			else if (pos == 0) { // the URL contained only a path and the current path has no / at the end, strip last element until / and append
+		else // otherwise it is a subfolder
-				auto last_slash = path_.rfind('/');
-				path_ = path_.substr(0, last_slash) + '/' + path;
-			} else // otherwise it is a subfolder
 			path_.append(path);
-		}
+
+		pointer_ = local_json_pointer("");
 	}
 
-	pointer_ = ""_json_pointer;
+	if (pointer.size() > 0)
-	identifier_ = "";
+		pointer_ = pointer;
-
-	if (pointer[0] == '/')
-		pointer_ = json::json_pointer(pointer);
-	else
-		identifier_ = pointer;
 }
 
-std::string json_uri::location() const
+const std::string json_uri::url() const
 {
-	if (urn_.size())
-		return urn_;
-
 	std::stringstream s;
 
-	if (scheme_.size() > 0)
+	if (proto_.size() > 0)
-		s << scheme_ << "://";
+		s << proto_ << "://";
 
-	s << authority_
+	s << hostname_
 	  << path_;
 
 	return s.str();
@@ -119,12 +115,9 @@ std::string json_uri::to_string() const
 {
 	std::stringstream s;
 
-	s << location() << " # ";
+	s << urn_
-
+	  << url()
-	if (identifier_ == "")
+	  << pointer_.to_string();
-		s << pointer_.to_string();
-	else
-		s << identifier_;
 
 	return s.str();
 }
@@ -134,11 +127,48 @@ std::ostream &operator<<(std::ostream &os, const json_uri &u)
 	return os << u.to_string();
 }
 
+std::string json_uri::unescape(const std::string &src)
+{
+	std::string l = src;
+	std::size_t pos = src.size() - 1;
+
+	do {
+		pos = l.rfind('~', pos);
+
+		if (pos == std::string::npos)
+			break;
+
+		if (pos < l.size() - 1) {
+			switch (l[pos + 1]) {
+			case '0':
+				l.replace(pos, 2, "~");
+				break;
+
+			case '1':
+				l.replace(pos, 2, "/");
+				break;
+
+			default:
+				break;
+			}
+		}
+
+		if (pos == 0)
+			break;
+		pos--;
+	} while (pos != std::string::npos);
+
+	// TODO - percent handling
+
+	return l;
+}
+
 std::string json_uri::escape(const std::string &src)
 {
 	std::vector<std::pair<std::string, std::string>> chars = {
 	    {"~", "~0"},
-	    {"/", "~1"}};
+	    {"/", "~1"},
+	    {"%", "%25"}};
 
 	std::string l = src;
 
@@ -156,4 +186,4 @@ std::string json_uri::escape(const std::string &src)
 	return l;
 }
 
-} // namespace nlohmann
+} // nlohmann

src/nlohmann/json-schema.hpp

@@ -1,198 +0,0 @@
-/*
- * JSON schema validator for JSON for modern C++
- *
- * Copyright (c) 2016-2019 Patrick Boettcher <p@yai.se>.
- *
- * SPDX-License-Identifier: MIT
- *
- */
-#ifndef NLOHMANN_JSON_SCHEMA_HPP__
-#define NLOHMANN_JSON_SCHEMA_HPP__
-
-#ifdef _WIN32
-#	if defined(JSON_SCHEMA_VALIDATOR_EXPORTS)
-#		define JSON_SCHEMA_VALIDATOR_API __declspec(dllexport)
-#	elif defined(JSON_SCHEMA_VALIDATOR_IMPORTS)
-#		define JSON_SCHEMA_VALIDATOR_API __declspec(dllimport)
-#	else
-#		define JSON_SCHEMA_VALIDATOR_API
-#	endif
-#else
-#	define JSON_SCHEMA_VALIDATOR_API
-#endif
-
-#include <nlohmann/json.hpp>
-
-#ifdef NLOHMANN_JSON_VERSION_MAJOR
-#	if (NLOHMANN_JSON_VERSION_MAJOR * 10000 + NLOHMANN_JSON_VERSION_MINOR * 100 + NLOHMANN_JSON_VERSION_PATCH) < 30800
-#		error "Please use this library with NLohmann's JSON version 3.8.0 or higher"
-#	endif
-#else
-#	error "expected existing NLOHMANN_JSON_VERSION_MAJOR preproc variable, please update to NLohmann's JSON 3.8.0"
-#endif
-
-// make yourself a home - welcome to nlohmann's namespace
-namespace nlohmann
-{
-
-// A class representing a JSON-URI for schemas derived from
-// section 8 of JSON Schema: A Media Type for Describing JSON Documents
-// draft-wright-json-schema-00
-//
-// New URIs can be derived from it using the derive()-method.
-// This is useful for resolving refs or subschema-IDs in json-schemas.
-//
-// This is done implement the requirements described in section 8.2.
-//
-class JSON_SCHEMA_VALIDATOR_API json_uri
-{
-	std::string urn_;
-
-	std::string scheme_;
-	std::string authority_;
-	std::string path_;
-
-	json::json_pointer pointer_; // fragment part if JSON-Pointer
-	std::string identifier_;     // fragment part if Locatation Independent ID
-
-protected:
-	// decodes a JSON uri and replaces all or part of the currently stored values
-	void update(const std::string &uri);
-
-	std::tuple<std::string, std::string, std::string, std::string, std::string> as_tuple() const
-	{
-		return std::make_tuple(urn_, scheme_, authority_, path_, identifier_ != "" ? identifier_ : pointer_.to_string());
-	}
-
-public:
-	json_uri(const std::string &uri)
-	{
-		update(uri);
-	}
-
-	const std::string &scheme() const { return scheme_; }
-	const std::string &authority() const { return authority_; }
-	const std::string &path() const { return path_; }
-
-	const json::json_pointer &pointer() const { return pointer_; }
-	const std::string &identifier() const { return identifier_; }
-
-	std::string fragment() const
-	{
-		if (identifier_ == "")
-			return pointer_.to_string();
-		else
-			return identifier_;
-	}
-
-	std::string url() const { return location(); }
-	std::string location() const;
-
-	static std::string escape(const std::string &);
-
-	// create a new json_uri based in this one and the given uri
-	// resolves relative changes (pathes or pointers) and resets part if proto or hostname changes
-	json_uri derive(const std::string &uri) const
-	{
-		json_uri u = *this;
-		u.update(uri);
-		return u;
-	}
-
-	// append a pointer-field to the pointer-part of this uri
-	json_uri append(const std::string &field) const
-	{
-		if (identifier_ != "")
-			return *this;
-
-		json_uri u = *this;
-		u.pointer_ /= field;
-		return u;
-	}
-
-	std::string to_string() const;
-
-	friend bool operator<(const json_uri &l, const json_uri &r)
-	{
-		return l.as_tuple() < r.as_tuple();
-	}
-
-	friend bool operator==(const json_uri &l, const json_uri &r)
-	{
-		return l.as_tuple() == r.as_tuple();
-	}
-
-	friend std::ostream &operator<<(std::ostream &os, const json_uri &u);
-};
-
-namespace json_schema
-{
-
-extern json draft7_schema_builtin;
-
-typedef std::function<void(const json_uri & /*id*/, json & /*value*/)> schema_loader;
-typedef std::function<void(const std::string & /*format*/, const std::string & /*value*/)> format_checker;
-typedef std::function<void(const std::string & /*contentEncoding*/, const std::string & /*contentMediaType*/, const json & /*instance*/)> content_checker;
-
-// Interface for validation error handlers
-class JSON_SCHEMA_VALIDATOR_API error_handler
-{
-public:
-	virtual ~error_handler() {}
-	virtual void error(const json::json_pointer & /*ptr*/, const json & /*instance*/, const std::string & /*message*/) = 0;
-};
-
-class JSON_SCHEMA_VALIDATOR_API basic_error_handler : public error_handler
-{
-	bool error_{false};
-
-public:
-	void error(const json::json_pointer & /*ptr*/, const json & /*instance*/, const std::string & /*message*/) override
-	{
-		error_ = true;
-	}
-
-	virtual void reset() { error_ = false; }
-	operator bool() const { return error_; }
-};
-
-/**
- * Checks validity of JSON schema built-in string format specifiers like 'date-time', 'ipv4', ...
- */
-void JSON_SCHEMA_VALIDATOR_API default_string_format_check(const std::string &format, const std::string &value);
-
-class root_schema;
-
-class JSON_SCHEMA_VALIDATOR_API json_validator
-{
-	std::unique_ptr<root_schema> root_;
-
-public:
-	json_validator(schema_loader = nullptr, format_checker = nullptr, content_checker = nullptr);
-
-	json_validator(const json &, schema_loader = nullptr, format_checker = nullptr, content_checker = nullptr);
-	json_validator(json &&, schema_loader = nullptr, format_checker = nullptr, content_checker = nullptr);
-
-	json_validator(json_validator &&);
-	json_validator &operator=(json_validator &&);
-
-	json_validator(json_validator const &) = delete;
-	json_validator &operator=(json_validator const &) = delete;
-
-	~json_validator();
-
-	// insert and set the root-schema
-	void set_root_schema(const json &);
-	void set_root_schema(json &&);
-
-	// validate a json-document based on the root-schema
-	json validate(const json &) const;
-
-	// validate a json-document based on the root-schema with a custom error-handler
-	json validate(const json &, error_handler &, const json_uri &initial_uri = json_uri("#")) const;
-};
-
-} // namespace json_schema
-} // namespace nlohmann
-
-#endif /* NLOHMANN_JSON_SCHEMA_HPP__ */

src/smtp-address-validator.cpp

@@ -1,792 +0,0 @@
-/*
-
-Snarfed from <https://github.com/gene-hightower/smtp-address-validator>
-
-<http://opensource.org/licenses/MIT>:
-
-Copyright (c) 2021 Gene Hightower
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-*/
-
-#include "smtp-address-validator.hpp"
-
-static const signed char _address_actions[] = {
-    0, 1, 0, 1, 1, 0};
-
-static const short _address_key_offsets[] = {
-    0, 0, 24, 26, 50, 52, 54, 56,
-    58, 60, 62, 86, 103, 105, 107, 109,
-    111, 113, 115, 117, 134, 150, 161, 168,
-    176, 180, 181, 190, 195, 196, 201, 202,
-    207, 210, 213, 219, 222, 225, 228, 234,
-    237, 240, 243, 249, 252, 261, 270, 282,
-    293, 302, 311, 320, 328, 345, 353, 360,
-    367, 368, 375, 382, 389, 396, 397, 404,
-    411, 418, 425, 426, 433, 440, 447, 454,
-    455, 462, 469, 476, 483, 484, 491, 498,
-    505, 512, 513, 523, 531, 538, 545, 546,
-    552, 559, 566, 573, 581, 589, 597, 608,
-    618, 626, 634, 641, 649, 657, 665, 667,
-    673, 681, 689, 697, 699, 705, 713, 721,
-    729, 731, 737, 745, 753, 761, 763, 769,
-    777, 785, 793, 795, 802, 812, 821, 829,
-    837, 839, 848, 857, 865, 873, 875, 884,
-    893, 901, 909, 911, 920, 929, 937, 945,
-    947, 956, 965, 974, 983, 992, 1004, 1015,
-    1024, 1033, 1042, 1051, 1060, 1072, 1083, 1092,
-    1101, 1109, 1118, 1127, 1136, 1148, 1159, 1168,
-    1177, 1185, 1194, 1203, 1212, 1224, 1235, 1244,
-    1253, 1261, 1270, 1279, 1288, 1300, 1311, 1320,
-    1329, 1337, 1339, 1353, 1355, 1357, 1359, 1361,
-    1363, 1365, 1367, 1368, 1370, 1388, 0};
-
-static const signed char _address_trans_keys[] = {
-    -32, -19, -16, -12, 34, 45, 61, 63,
-    -62, -33, -31, -17, -15, -13, 33, 39,
-    42, 43, 47, 57, 65, 90, 94, 126,
-    -128, -65, -32, -19, -16, -12, 33, 46,
-    61, 64, -62, -33, -31, -17, -15, -13,
-    35, 39, 42, 43, 45, 57, 63, 90,
-    94, 126, -96, -65, -128, -65, -128, -97,
-    -112, -65, -128, -65, -128, -113, -32, -19,
-    -16, -12, 33, 45, 61, 63, -62, -33,
-    -31, -17, -15, -13, 35, 39, 42, 43,
-    47, 57, 65, 90, 94, 126, -32, -19,
-    -16, -12, 91, -62, -33, -31, -17, -15,
-    -13, 48, 57, 65, 90, 97, 122, -128,
-    -65, -96, -65, -128, -65, -128, -97, -112,
-    -65, -128, -65, -128, -113, -32, -19, -16,
-    -12, 45, -62, -33, -31, -17, -15, -13,
-    48, 57, 65, 90, 97, 122, -32, -19,
-    -16, -12, -62, -33, -31, -17, -15, -13,
-    48, 57, 65, 90, 97, 122, 45, 48,
-    49, 50, 73, 51, 57, 65, 90, 97,
-    122, 45, 48, 57, 65, 90, 97, 122,
-    45, 58, 48, 57, 65, 90, 97, 122,
-    33, 90, 94, 126, 93, 45, 46, 58,
-    48, 57, 65, 90, 97, 122, 48, 49,
-    50, 51, 57, 46, 48, 49, 50, 51,
-    57, 46, 48, 49, 50, 51, 57, 93,
-    48, 57, 93, 48, 57, 53, 93, 48,
-    52, 54, 57, 93, 48, 53, 46, 48,
-    57, 46, 48, 57, 46, 53, 48, 52,
-    54, 57, 46, 48, 53, 46, 48, 57,
-    46, 48, 57, 46, 53, 48, 52, 54,
-    57, 46, 48, 53, 45, 46, 58, 48,
-    57, 65, 90, 97, 122, 45, 46, 58,
-    48, 57, 65, 90, 97, 122, 45, 46,
-    53, 58, 48, 52, 54, 57, 65, 90,
-    97, 122, 45, 46, 58, 48, 53, 54,
-    57, 65, 90, 97, 122, 45, 58, 80,
-    48, 57, 65, 90, 97, 122, 45, 58,
-    118, 48, 57, 65, 90, 97, 122, 45,
-    54, 58, 48, 57, 65, 90, 97, 122,
-    45, 58, 48, 57, 65, 90, 97, 122,
-    58, 33, 47, 48, 57, 59, 64, 65,
-    70, 71, 90, 94, 96, 97, 102, 103,
-    126, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 48, 57, 65, 70, 97, 102,
-    58, 48, 57, 65, 70, 97, 102, 58,
-    58, 48, 57, 65, 70, 97, 102, 58,
-    48, 57, 65, 70, 97, 102, 58, 48,
-    57, 65, 70, 97, 102, 58, 48, 57,
-    65, 70, 97, 102, 58, 58, 48, 57,
-    65, 70, 97, 102, 58, 48, 57, 65,
-    70, 97, 102, 58, 48, 57, 65, 70,
-    97, 102, 58, 48, 57, 65, 70, 97,
-    102, 58, 58, 48, 57, 65, 70, 97,
-    102, 58, 48, 57, 65, 70, 97, 102,
-    58, 48, 57, 65, 70, 97, 102, 58,
-    48, 57, 65, 70, 97, 102, 58, 58,
-    48, 57, 65, 70, 97, 102, 58, 48,
-    57, 65, 70, 97, 102, 58, 48, 57,
-    65, 70, 97, 102, 58, 48, 57, 65,
-    70, 97, 102, 58, 58, 48, 57, 65,
-    70, 97, 102, 58, 48, 57, 65, 70,
-    97, 102, 58, 48, 57, 65, 70, 97,
-    102, 58, 48, 57, 65, 70, 97, 102,
-    58, 48, 49, 50, 58, 51, 57, 65,
-    70, 97, 102, 46, 58, 48, 57, 65,
-    70, 97, 102, 58, 48, 57, 65, 70,
-    97, 102, 58, 48, 57, 65, 70, 97,
-    102, 58, 48, 57, 65, 70, 97, 102,
-    93, 48, 57, 65, 70, 97, 102, 93,
-    48, 57, 65, 70, 97, 102, 93, 48,
-    57, 65, 70, 97, 102, 46, 58, 48,
-    57, 65, 70, 97, 102, 46, 58, 48,
-    57, 65, 70, 97, 102, 46, 58, 48,
-    57, 65, 70, 97, 102, 46, 53, 58,
-    48, 52, 54, 57, 65, 70, 97, 102,
-    46, 58, 48, 53, 54, 57, 65, 70,
-    97, 102, 46, 58, 48, 57, 65, 70,
-    97, 102, 46, 58, 48, 57, 65, 70,
-    97, 102, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 58, 48, 57, 65, 70,
-    97, 102, 48, 49, 50, 93, 51, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    49, 50, 51, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 49, 50, 51, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    49, 50, 51, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 49, 50, 51, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    57, 65, 70, 97, 102, 46, 58, 93,
-    48, 57, 65, 70, 97, 102, 46, 58,
-    93, 48, 57, 65, 70, 97, 102, 46,
-    58, 93, 48, 57, 65, 70, 97, 102,
-    46, 53, 58, 93, 48, 52, 54, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    53, 54, 57, 65, 70, 97, 102, 46,
-    58, 93, 48, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 57, 65, 70, 97,
-    102, 46, 58, 93, 48, 57, 65, 70,
-    97, 102, 46, 58, 93, 48, 57, 65,
-    70, 97, 102, 46, 58, 93, 48, 57,
-    65, 70, 97, 102, 46, 53, 58, 93,
-    48, 52, 54, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 53, 54, 57, 65,
-    70, 97, 102, 46, 58, 93, 48, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    57, 65, 70, 97, 102, 46, 58, 93,
-    48, 57, 65, 70, 97, 102, 46, 58,
-    93, 48, 57, 65, 70, 97, 102, 46,
-    58, 93, 48, 57, 65, 70, 97, 102,
-    46, 53, 58, 93, 48, 52, 54, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    53, 54, 57, 65, 70, 97, 102, 46,
-    58, 93, 48, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 46, 58, 93, 48, 57, 65, 70,
-    97, 102, 46, 58, 93, 48, 57, 65,
-    70, 97, 102, 46, 58, 93, 48, 57,
-    65, 70, 97, 102, 46, 53, 58, 93,
-    48, 52, 54, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 53, 54, 57, 65,
-    70, 97, 102, 46, 58, 93, 48, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    57, 65, 70, 97, 102, 58, 93, 48,
-    57, 65, 70, 97, 102, 46, 58, 93,
-    48, 57, 65, 70, 97, 102, 46, 58,
-    93, 48, 57, 65, 70, 97, 102, 46,
-    58, 93, 48, 57, 65, 70, 97, 102,
-    46, 53, 58, 93, 48, 52, 54, 57,
-    65, 70, 97, 102, 46, 58, 93, 48,
-    53, 54, 57, 65, 70, 97, 102, 46,
-    58, 93, 48, 57, 65, 70, 97, 102,
-    46, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, 48, 57, 65, 70, 97,
-    102, 58, 93, -32, -19, -16, -12, 34,
-    92, -62, -33, -31, -17, -15, -13, 32,
-    126, -128, -65, -96, -65, -128, -65, -128,
-    -97, -112, -65, -128, -65, -128, -113, 64,
-    32, 126, -32, -19, -16, -12, 45, 46,
-    -62, -33, -31, -17, -15, -13, 48, 57,
-    65, 90, 97, 122, 0};
-
-static const signed char _address_single_lengths[] = {
-    0, 8, 0, 8, 0, 0, 0, 0,
-    0, 0, 8, 5, 0, 0, 0, 0,
-    0, 0, 0, 5, 4, 5, 1, 2,
-    0, 1, 3, 3, 1, 3, 1, 3,
-    1, 1, 2, 1, 1, 1, 2, 1,
-    1, 1, 2, 1, 3, 3, 4, 3,
-    3, 3, 3, 2, 1, 2, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 4, 2, 1, 1, 1, 0,
-    1, 1, 1, 2, 2, 2, 3, 2,
-    2, 2, 1, 2, 2, 2, 2, 0,
-    2, 2, 2, 2, 0, 2, 2, 2,
-    2, 0, 2, 2, 2, 2, 0, 2,
-    2, 2, 2, 1, 4, 3, 2, 2,
-    2, 3, 3, 2, 2, 2, 3, 3,
-    2, 2, 2, 3, 3, 2, 2, 2,
-    3, 3, 3, 3, 3, 4, 3, 3,
-    3, 3, 3, 3, 4, 3, 3, 3,
-    2, 3, 3, 3, 4, 3, 3, 3,
-    2, 3, 3, 3, 4, 3, 3, 3,
-    2, 3, 3, 3, 4, 3, 3, 3,
-    2, 2, 6, 0, 0, 0, 0, 0,
-    0, 0, 1, 0, 6, 0, 0};
-
-static const signed char _address_range_lengths[] = {
-    0, 8, 1, 8, 1, 1, 1, 1,
-    1, 1, 8, 6, 1, 1, 1, 1,
-    1, 1, 1, 6, 6, 3, 3, 3,
-    2, 0, 3, 1, 0, 1, 0, 1,
-    1, 1, 2, 1, 1, 1, 2, 1,
-    1, 1, 2, 1, 3, 3, 4, 4,
-    3, 3, 3, 3, 8, 3, 3, 3,
-    0, 3, 3, 3, 3, 0, 3, 3,
-    3, 3, 0, 3, 3, 3, 3, 0,
-    3, 3, 3, 3, 0, 3, 3, 3,
-    3, 0, 3, 3, 3, 3, 0, 3,
-    3, 3, 3, 3, 3, 3, 4, 4,
-    3, 3, 3, 3, 3, 3, 0, 3,
-    3, 3, 3, 0, 3, 3, 3, 3,
-    0, 3, 3, 3, 3, 0, 3, 3,
-    3, 3, 0, 3, 3, 3, 3, 3,
-    0, 3, 3, 3, 3, 0, 3, 3,
-    3, 3, 0, 3, 3, 3, 3, 0,
-    3, 3, 3, 3, 3, 4, 4, 3,
-    3, 3, 3, 3, 4, 4, 3, 3,
-    3, 3, 3, 3, 4, 4, 3, 3,
-    3, 3, 3, 3, 4, 4, 3, 3,
-    3, 3, 3, 3, 4, 4, 3, 3,
-    3, 0, 4, 1, 1, 1, 1, 1,
-    1, 1, 0, 1, 6, 0, 0};
-
-static const short _address_index_offsets[] = {
-    0, 0, 17, 19, 36, 38, 40, 42,
-    44, 46, 48, 65, 77, 79, 81, 83,
-    85, 87, 89, 91, 103, 114, 123, 128,
-    134, 137, 139, 146, 151, 153, 158, 160,
-    165, 168, 171, 176, 179, 182, 185, 190,
-    193, 196, 199, 204, 207, 214, 221, 230,
-    238, 245, 252, 259, 265, 275, 281, 286,
-    291, 293, 298, 303, 308, 313, 315, 320,
-    325, 330, 335, 337, 342, 347, 352, 357,
-    359, 364, 369, 374, 379, 381, 386, 391,
-    396, 401, 403, 411, 417, 422, 427, 429,
-    433, 438, 443, 448, 454, 460, 466, 474,
-    481, 487, 493, 498, 504, 510, 516, 519,
-    523, 529, 535, 541, 544, 548, 554, 560,
-    566, 569, 573, 579, 585, 591, 594, 598,
-    604, 610, 616, 619, 624, 632, 639, 645,
-    651, 654, 661, 668, 674, 680, 683, 690,
-    697, 703, 709, 712, 719, 726, 732, 738,
-    741, 748, 755, 762, 769, 776, 785, 793,
-    800, 807, 814, 821, 828, 837, 845, 852,
-    859, 865, 872, 879, 886, 895, 903, 910,
-    917, 923, 930, 937, 944, 953, 961, 968,
-    975, 981, 988, 995, 1002, 1011, 1019, 1026,
-    1033, 1039, 1042, 1053, 1055, 1057, 1059, 1061,
-    1063, 1065, 1067, 1069, 1071, 1084, 0};
-
-static const short _address_cond_targs[] = {
-    4, 6, 7, 9, 186, 3, 3, 3,
-    2, 5, 8, 3, 3, 3, 3, 3,
-    0, 3, 0, 4, 6, 7, 9, 3,
-    10, 3, 11, 2, 5, 8, 3, 3,
-    3, 3, 3, 0, 2, 0, 2, 0,
-    2, 0, 5, 0, 5, 0, 5, 0,
-    4, 6, 7, 9, 3, 3, 3, 3,
-    2, 5, 8, 3, 3, 3, 3, 3,
-    0, 13, 15, 16, 18, 21, 12, 14,
-    17, 196, 196, 196, 0, 196, 0, 12,
-    0, 12, 0, 12, 0, 14, 0, 14,
-    0, 14, 0, 13, 15, 16, 18, 19,
-    12, 14, 17, 196, 196, 196, 0, 13,
-    15, 16, 18, 12, 14, 17, 196, 196,
-    196, 0, 22, 26, 44, 46, 48, 45,
-    23, 23, 0, 22, 23, 23, 23, 0,
-    22, 24, 23, 23, 23, 0, 25, 25,
-    0, 197, 0, 22, 27, 24, 23, 23,
-    23, 0, 28, 40, 42, 41, 0, 29,
-    0, 30, 36, 38, 37, 0, 31, 0,
-    25, 32, 34, 33, 0, 197, 33, 0,
-    197, 25, 0, 35, 197, 33, 25, 0,
-    197, 25, 0, 31, 37, 0, 31, 30,
-    0, 31, 39, 37, 30, 0, 31, 30,
-    0, 29, 41, 0, 29, 28, 0, 29,
-    43, 41, 28, 0, 29, 28, 0, 22,
-    27, 24, 45, 23, 23, 0, 22, 27,
-    24, 26, 23, 23, 0, 22, 27, 47,
-    24, 45, 26, 23, 23, 0, 22, 27,
-    24, 26, 23, 23, 23, 0, 22, 24,
-    49, 23, 23, 23, 0, 22, 24, 50,
-    23, 23, 23, 0, 22, 51, 24, 23,
-    23, 23, 0, 22, 52, 23, 23, 23,
-    0, 185, 25, 53, 25, 53, 25, 25,
-    53, 25, 0, 57, 197, 54, 54, 54,
-    0, 57, 55, 55, 55, 0, 57, 56,
-    56, 56, 0, 57, 0, 124, 58, 58,
-    58, 0, 62, 59, 59, 59, 0, 62,
-    60, 60, 60, 0, 62, 61, 61, 61,
-    0, 62, 0, 124, 63, 63, 63, 0,
-    67, 64, 64, 64, 0, 67, 65, 65,
-    65, 0, 67, 66, 66, 66, 0, 67,
-    0, 124, 68, 68, 68, 0, 72, 69,
-    69, 69, 0, 72, 70, 70, 70, 0,
-    72, 71, 71, 71, 0, 72, 0, 124,
-    73, 73, 73, 0, 77, 74, 74, 74,
-    0, 77, 75, 75, 75, 0, 77, 76,
-    76, 76, 0, 77, 0, 98, 78, 78,
-    78, 0, 82, 79, 79, 79, 0, 82,
-    80, 80, 80, 0, 82, 81, 81, 81,
-    0, 82, 0, 83, 91, 94, 98, 97,
-    123, 123, 0, 27, 87, 84, 84, 84,
-    0, 87, 85, 85, 85, 0, 87, 86,
-    86, 86, 0, 87, 0, 88, 88, 88,
-    0, 197, 89, 89, 89, 0, 197, 90,
-    90, 90, 0, 197, 25, 25, 25, 0,
-    27, 87, 92, 84, 84, 0, 27, 87,
-    93, 85, 85, 0, 27, 87, 86, 86,
-    86, 0, 27, 95, 87, 92, 96, 84,
-    84, 0, 27, 87, 93, 85, 85, 85,
-    0, 27, 87, 85, 85, 85, 0, 27,
-    87, 96, 84, 84, 0, 197, 99, 99,
-    99, 0, 103, 197, 100, 100, 100, 0,
-    103, 197, 101, 101, 101, 0, 103, 197,
-    102, 102, 102, 0, 103, 197, 0, 104,
-    104, 104, 0, 108, 197, 105, 105, 105,
-    0, 108, 197, 106, 106, 106, 0, 108,
-    197, 107, 107, 107, 0, 108, 197, 0,
-    109, 109, 109, 0, 113, 197, 110, 110,
-    110, 0, 113, 197, 111, 111, 111, 0,
-    113, 197, 112, 112, 112, 0, 113, 197,
-    0, 114, 114, 114, 0, 118, 197, 115,
-    115, 115, 0, 118, 197, 116, 116, 116,
-    0, 118, 197, 117, 117, 117, 0, 118,
-    197, 0, 119, 119, 119, 0, 87, 197,
-    120, 120, 120, 0, 87, 197, 121, 121,
-    121, 0, 87, 197, 122, 122, 122, 0,
-    87, 197, 0, 87, 84, 84, 84, 0,
-    125, 177, 180, 197, 183, 184, 184, 0,
-    27, 129, 197, 126, 126, 126, 0, 129,
-    197, 127, 127, 127, 0, 129, 197, 128,
-    128, 128, 0, 129, 197, 0, 130, 169,
-    172, 175, 176, 176, 0, 27, 134, 197,
-    131, 131, 131, 0, 134, 197, 132, 132,
-    132, 0, 134, 197, 133, 133, 133, 0,
-    134, 197, 0, 135, 161, 164, 167, 168,
-    168, 0, 27, 139, 197, 136, 136, 136,
-    0, 139, 197, 137, 137, 137, 0, 139,
-    197, 138, 138, 138, 0, 139, 197, 0,
-    140, 153, 156, 159, 160, 160, 0, 27,
-    144, 197, 141, 141, 141, 0, 144, 197,
-    142, 142, 142, 0, 144, 197, 143, 143,
-    143, 0, 144, 197, 0, 145, 146, 149,
-    152, 119, 119, 0, 27, 87, 197, 120,
-    120, 120, 0, 27, 87, 197, 147, 120,
-    120, 0, 27, 87, 197, 148, 121, 121,
-    0, 27, 87, 197, 122, 122, 122, 0,
-    27, 150, 87, 197, 147, 151, 120, 120,
-    0, 27, 87, 197, 148, 121, 121, 121,
-    0, 27, 87, 197, 121, 121, 121, 0,
-    27, 87, 197, 151, 120, 120, 0, 27,
-    144, 197, 154, 141, 141, 0, 27, 144,
-    197, 155, 142, 142, 0, 27, 144, 197,
-    143, 143, 143, 0, 27, 157, 144, 197,
-    154, 158, 141, 141, 0, 27, 144, 197,
-    155, 142, 142, 142, 0, 27, 144, 197,
-    142, 142, 142, 0, 27, 144, 197, 158,
-    141, 141, 0, 144, 197, 141, 141, 141,
-    0, 27, 139, 197, 162, 136, 136, 0,
-    27, 139, 197, 163, 137, 137, 0, 27,
-    139, 197, 138, 138, 138, 0, 27, 165,
-    139, 197, 162, 166, 136, 136, 0, 27,
-    139, 197, 163, 137, 137, 137, 0, 27,
-    139, 197, 137, 137, 137, 0, 27, 139,
-    197, 166, 136, 136, 0, 139, 197, 136,
-    136, 136, 0, 27, 134, 197, 170, 131,
-    131, 0, 27, 134, 197, 171, 132, 132,
-    0, 27, 134, 197, 133, 133, 133, 0,
-    27, 173, 134, 197, 170, 174, 131, 131,
-    0, 27, 134, 197, 171, 132, 132, 132,
-    0, 27, 134, 197, 132, 132, 132, 0,
-    27, 134, 197, 174, 131, 131, 0, 134,
-    197, 131, 131, 131, 0, 27, 129, 197,
-    178, 126, 126, 0, 27, 129, 197, 179,
-    127, 127, 0, 27, 129, 197, 128, 128,
-    128, 0, 27, 181, 129, 197, 178, 182,
-    126, 126, 0, 27, 129, 197, 179, 127,
-    127, 127, 0, 27, 129, 197, 127, 127,
-    127, 0, 27, 129, 197, 182, 126, 126,
-    0, 129, 197, 126, 126, 126, 0, 124,
-    197, 0, 188, 190, 191, 193, 194, 195,
-    187, 189, 192, 186, 0, 186, 0, 187,
-    0, 187, 0, 187, 0, 189, 0, 189,
-    0, 189, 0, 11, 0, 186, 0, 13,
-    15, 16, 18, 19, 20, 12, 14, 17,
-    196, 196, 196, 0, 0, 0, 1, 2,
-    3, 4, 5, 6, 7, 8, 9, 10,
-    11, 12, 13, 14, 15, 16, 17, 18,
-    19, 20, 21, 22, 23, 24, 25, 26,
-    27, 28, 29, 30, 31, 32, 33, 34,
-    35, 36, 37, 38, 39, 40, 41, 42,
-    43, 44, 45, 46, 47, 48, 49, 50,
-    51, 52, 53, 54, 55, 56, 57, 58,
-    59, 60, 61, 62, 63, 64, 65, 66,
-    67, 68, 69, 70, 71, 72, 73, 74,
-    75, 76, 77, 78, 79, 80, 81, 82,
-    83, 84, 85, 86, 87, 88, 89, 90,
-    91, 92, 93, 94, 95, 96, 97, 98,
-    99, 100, 101, 102, 103, 104, 105, 106,
-    107, 108, 109, 110, 111, 112, 113, 114,
-    115, 116, 117, 118, 119, 120, 121, 122,
-    123, 124, 125, 126, 127, 128, 129, 130,
-    131, 132, 133, 134, 135, 136, 137, 138,
-    139, 140, 141, 142, 143, 144, 145, 146,
-    147, 148, 149, 150, 151, 152, 153, 154,
-    155, 156, 157, 158, 159, 160, 161, 162,
-    163, 164, 165, 166, 167, 168, 169, 170,
-    171, 172, 173, 174, 175, 176, 177, 178,
-    179, 180, 181, 182, 183, 184, 185, 186,
-    187, 188, 189, 190, 191, 192, 193, 194,
-    195, 196, 197, 0};
-
-static const signed char _address_cond_actions[] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    3, 0, 3, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 3, 0, 3, 0, 3,
-    0, 3, 0, 3, 0, 3, 0, 3,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    3, 0, 0, 0, 0, 0, 0, 0,
-    0, 1, 1, 1, 3, 1, 3, 0,
-    3, 0, 3, 0, 3, 0, 3, 0,
-    3, 0, 3, 0, 0, 0, 0, 0,
-    0, 0, 0, 1, 1, 1, 3, 0,
-    0, 0, 0, 0, 0, 0, 1, 1,
-    1, 3, 0, 0, 0, 0, 0, 0,
-    0, 0, 3, 0, 0, 0, 0, 3,
-    0, 0, 0, 0, 0, 3, 0, 0,
-    3, 1, 3, 0, 0, 0, 0, 0,
-    0, 3, 0, 0, 0, 0, 3, 0,
-    3, 0, 0, 0, 0, 3, 0, 3,
-    0, 0, 0, 0, 3, 1, 0, 3,
-    1, 0, 3, 0, 1, 0, 0, 3,
-    1, 0, 3, 0, 0, 3, 0, 0,
-    3, 0, 0, 0, 0, 3, 0, 0,
-    3, 0, 0, 3, 0, 0, 3, 0,
-    0, 0, 0, 3, 0, 0, 3, 0,
-    0, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 0, 0, 3, 0, 0, 0,
-    0, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 0, 0, 3, 0, 0, 0,
-    0, 0, 0, 3, 0, 0, 0, 0,
-    0, 0, 3, 0, 0, 0, 0, 0,
-    3, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 3, 0, 1, 0, 0, 0,
-    3, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 3, 0, 3, 0, 0, 0,
-    0, 3, 0, 0, 0, 0, 3, 0,
-    0, 0, 0, 3, 0, 0, 0, 0,
-    3, 0, 3, 0, 0, 0, 0, 3,
-    0, 0, 0, 0, 3, 0, 0, 0,
-    0, 3, 0, 0, 0, 0, 3, 0,
-    3, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 3, 0, 0, 0, 0, 3,
-    0, 0, 0, 0, 3, 0, 3, 0,
-    0, 0, 0, 3, 0, 0, 0, 0,
-    3, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 3, 0, 3, 0, 0, 0,
-    0, 3, 0, 0, 0, 0, 3, 0,
-    0, 0, 0, 3, 0, 0, 0, 0,
-    3, 0, 3, 0, 0, 0, 0, 0,
-    0, 0, 3, 0, 0, 0, 0, 0,
-    3, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 3, 0, 3, 0, 0, 0,
-    3, 1, 0, 0, 0, 3, 1, 0,
-    0, 0, 3, 1, 0, 0, 0, 3,
-    0, 0, 0, 0, 0, 3, 0, 0,
-    0, 0, 0, 3, 0, 0, 0, 0,
-    0, 3, 0, 0, 0, 0, 0, 0,
-    0, 3, 0, 0, 0, 0, 0, 0,
-    3, 0, 0, 0, 0, 0, 3, 0,
-    0, 0, 0, 0, 3, 1, 0, 0,
-    0, 3, 0, 1, 0, 0, 0, 3,
-    0, 1, 0, 0, 0, 3, 0, 1,
-    0, 0, 0, 3, 0, 1, 3, 0,
-    0, 0, 3, 0, 1, 0, 0, 0,
-    3, 0, 1, 0, 0, 0, 3, 0,
-    1, 0, 0, 0, 3, 0, 1, 3,
-    0, 0, 0, 3, 0, 1, 0, 0,
-    0, 3, 0, 1, 0, 0, 0, 3,
-    0, 1, 0, 0, 0, 3, 0, 1,
-    3, 0, 0, 0, 3, 0, 1, 0,
-    0, 0, 3, 0, 1, 0, 0, 0,
-    3, 0, 1, 0, 0, 0, 3, 0,
-    1, 3, 0, 0, 0, 3, 0, 1,
-    0, 0, 0, 3, 0, 1, 0, 0,
-    0, 3, 0, 1, 0, 0, 0, 3,
-    0, 1, 3, 0, 0, 0, 0, 3,
-    0, 0, 0, 1, 0, 0, 0, 3,
-    0, 0, 1, 0, 0, 0, 3, 0,
-    1, 0, 0, 0, 3, 0, 1, 0,
-    0, 0, 3, 0, 1, 3, 0, 0,
-    0, 0, 0, 0, 3, 0, 0, 1,
-    0, 0, 0, 3, 0, 1, 0, 0,
-    0, 3, 0, 1, 0, 0, 0, 3,
-    0, 1, 3, 0, 0, 0, 0, 0,
-    0, 3, 0, 0, 1, 0, 0, 0,
-    3, 0, 1, 0, 0, 0, 3, 0,
-    1, 0, 0, 0, 3, 0, 1, 3,
-    0, 0, 0, 0, 0, 0, 3, 0,
-    0, 1, 0, 0, 0, 3, 0, 1,
-    0, 0, 0, 3, 0, 1, 0, 0,
-    0, 3, 0, 1, 3, 0, 0, 0,
-    0, 0, 0, 3, 0, 0, 1, 0,
-    0, 0, 3, 0, 0, 1, 0, 0,
-    0, 3, 0, 0, 1, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 3,
-    0, 0, 0, 1, 0, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 3,
-    0, 0, 1, 0, 0, 0, 3, 0,
-    0, 1, 0, 0, 0, 3, 0, 0,
-    1, 0, 0, 0, 3, 0, 0, 1,
-    0, 0, 0, 3, 0, 0, 0, 1,
-    0, 0, 0, 0, 3, 0, 0, 1,
-    0, 0, 0, 0, 3, 0, 0, 1,
-    0, 0, 0, 3, 0, 0, 1, 0,
-    0, 0, 3, 0, 1, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 3,
-    0, 0, 1, 0, 0, 0, 3, 0,
-    0, 1, 0, 0, 0, 3, 0, 0,
-    0, 1, 0, 0, 0, 0, 3, 0,
-    0, 1, 0, 0, 0, 0, 3, 0,
-    0, 1, 0, 0, 0, 3, 0, 0,
-    1, 0, 0, 0, 3, 0, 1, 0,
-    0, 0, 3, 0, 0, 1, 0, 0,
-    0, 3, 0, 0, 1, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 3,
-    0, 0, 0, 1, 0, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 0,
-    3, 0, 0, 1, 0, 0, 0, 3,
-    0, 0, 1, 0, 0, 0, 3, 0,
-    1, 0, 0, 0, 3, 0, 0, 1,
-    0, 0, 0, 3, 0, 0, 1, 0,
-    0, 0, 3, 0, 0, 1, 0, 0,
-    0, 3, 0, 0, 0, 1, 0, 0,
-    0, 0, 3, 0, 0, 1, 0, 0,
-    0, 0, 3, 0, 0, 1, 0, 0,
-    0, 3, 0, 0, 1, 0, 0, 0,
-    3, 0, 1, 0, 0, 0, 3, 0,
-    1, 3, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 3, 0, 3, 0,
-    3, 0, 3, 0, 3, 0, 3, 0,
-    3, 0, 3, 0, 3, 0, 3, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    1, 1, 1, 3, 3, 0, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3,
-    3, 0, 0, 0};
-
-static const short _address_eof_trans[] = {
-    1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093,
-    1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101,
-    1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109,
-    1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117,
-    1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125,
-    1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133,
-    1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141,
-    1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149,
-    1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157,
-    1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165,
-    1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173,
-    1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181,
-    1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189,
-    1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197,
-    1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205,
-    1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213,
-    1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221,
-    1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229,
-    1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237,
-    1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245,
-    1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253,
-    1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261,
-    1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269,
-    1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277,
-    1278, 1279, 1280, 1281, 1282, 1283, 0};
-
-static const int address_start = 1;
-
-bool is_address(const char *p, const char *pe)
-{
-	int cs = 0;
-
-	const char *eof = pe;
-
-	bool result = false;
-
-	{
-		cs = (int) address_start;
-	}
-	{
-		int _klen;
-		unsigned int _trans = 0;
-		const signed char *_keys;
-		const signed char *_acts;
-		unsigned int _nacts;
-	_resume : {
-	}
-		if (p == pe && p != eof)
-			goto _out;
-		if (p == eof) {
-			if (_address_eof_trans[cs] > 0) {
-				_trans = (unsigned int) _address_eof_trans[cs] - 1;
-			}
-		} else {
-			_keys = (_address_trans_keys + (_address_key_offsets[cs]));
-			_trans = (unsigned int) _address_index_offsets[cs];
-
-			_klen = (int) _address_single_lengths[cs];
-			if (_klen > 0) {
-				const signed char *_lower = _keys;
-				const signed char *_upper = _keys + _klen - 1;
-				const signed char *_mid;
-				while (1) {
-					if (_upper < _lower) {
-						_keys += _klen;
-						_trans += (unsigned int) _klen;
-						break;
-					}
-
-					_mid = _lower + ((_upper - _lower) >> 1);
-					if (((*(p))) < (*(_mid)))
-						_upper = _mid - 1;
-					else if (((*(p))) > (*(_mid)))
-						_lower = _mid + 1;
-					else {
-						_trans += (unsigned int) (_mid - _keys);
-						goto _match;
-					}
-				}
-			}
-
-			_klen = (int) _address_range_lengths[cs];
-			if (_klen > 0) {
-				const signed char *_lower = _keys;
-				const signed char *_upper = _keys + (_klen << 1) - 2;
-				const signed char *_mid;
-				while (1) {
-					if (_upper < _lower) {
-						_trans += (unsigned int) _klen;
-						break;
-					}
-
-					_mid = _lower + (((_upper - _lower) >> 1) & ~1);
-					if (((*(p))) < (*(_mid)))
-						_upper = _mid - 2;
-					else if (((*(p))) > (*(_mid + 1)))
-						_lower = _mid + 2;
-					else {
-						_trans += (unsigned int) ((_mid - _keys) >> 1);
-						break;
-					}
-				}
-			}
-
-		_match : {
-		}
-		}
-		cs = (int) _address_cond_targs[_trans];
-
-		if (_address_cond_actions[_trans] != 0) {
-
-			_acts = (_address_actions + (_address_cond_actions[_trans]));
-			_nacts = (unsigned int) (*(_acts));
-			_acts += 1;
-			while (_nacts > 0) {
-				switch ((*(_acts))) {
-				case 0: {
-					{
-						result = true;
-					}
-					break;
-				}
-				case 1: {
-					{
-						result = false;
-					}
-					break;
-				}
-				}
-				_nacts -= 1;
-				_acts += 1;
-			}
-		}
-
-		if (p == eof) {
-			if (cs >= 196)
-				goto _out;
-		} else {
-			if (cs != 0) {
-				p += 1;
-				goto _resume;
-			}
-		}
-	_out : {
-	}
-	}
-	return result;
-}

src/smtp-address-validator.hpp

@@ -1,34 +0,0 @@
-#ifndef SMTP_ADDRESS_PARSER_HPP_INCLUDED
-#define SMTP_ADDRESS_PARSER_HPP_INCLUDED
-
-/*
-
-Snarfed from <https://github.com/gene-hightower/smtp-address-validator>
-
-<http://opensource.org/licenses/MIT>:
-
-Copyright (c) 2021 Gene Hightower
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-*/
-
-bool is_address(const char *p, const char *pe);
-
-#endif // SMTP_ADDRESS_PARSER_HPP_INCLUDED

src/string-format-check.cpp

@@ -1,414 +0,0 @@
-#include <nlohmann/json-schema.hpp>
-
-#include "smtp-address-validator.hpp"
-
-#include <algorithm>
-#include <exception>
-#include <iostream>
-#include <regex>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#ifdef JSON_SCHEMA_BOOST_REGEX
-#	include <boost/regex.hpp>
-#	define REGEX_NAMESPACE boost
-#elif defined(JSON_SCHEMA_NO_REGEX)
-#	define NO_STD_REGEX
-#else
-#	include <regex>
-#	define REGEX_NAMESPACE std
-#endif
-
-/**
- * Many of the RegExes are from @see http://jmrware.com/articles/2009/uri_regexp/URI_regex.html
- */
-
-namespace
-{
-template <typename T>
-void range_check(const T value, const T min, const T max)
-{
-	if (!((value >= min) && (value <= max))) {
-		std::stringstream out;
-		out << "Value " << value << " should be in interval [" << min << "," << max << "] but is not!";
-		throw std::invalid_argument(out.str());
-	}
-}
-
-/** @see date_time_check */
-void rfc3339_date_check(const std::string &value)
-{
-	const static REGEX_NAMESPACE::regex dateRegex{R"(^([0-9]{4})\-([0-9]{2})\-([0-9]{2})$)"};
-
-	REGEX_NAMESPACE::smatch matches;
-	if (!REGEX_NAMESPACE::regex_match(value, matches, dateRegex)) {
-		throw std::invalid_argument(value + " is not a date string according to RFC 3339.");
-	}
-
-	const auto year = std::stoi(matches[1].str());
-	const auto month = std::stoi(matches[2].str());
-	const auto mday = std::stoi(matches[3].str());
-
-	const auto isLeapYear = (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
-
-	range_check(month, 1, 12);
-	if (month == 2) {
-		range_check(mday, 1, isLeapYear ? 29 : 28);
-	} else if (month <= 7) {
-		range_check(mday, 1, month % 2 == 0 ? 30 : 31);
-	} else {
-		range_check(mday, 1, month % 2 == 0 ? 31 : 30);
-	}
-}
-
-/** @see date_time_check */
-void rfc3339_time_check(const std::string &value)
-{
-	const static REGEX_NAMESPACE::regex timeRegex{R"(^([0-9]{2})\:([0-9]{2})\:([0-9]{2})(\.[0-9]+)?(?:[Zz]|((?:\+|\-)[0-9]{2})\:([0-9]{2}))$)"};
-
-	REGEX_NAMESPACE::smatch matches;
-	if (!REGEX_NAMESPACE::regex_match(value, matches, timeRegex)) {
-		throw std::invalid_argument(value + " is not a time string according to RFC 3339.");
-	}
-
-	auto hour = std::stoi(matches[1].str());
-	auto minute = std::stoi(matches[2].str());
-	auto second = std::stoi(matches[3].str());
-	// const auto secfrac      = std::stof( matches[4].str() );
-
-	range_check(hour, 0, 23);
-	range_check(minute, 0, 59);
-
-	int offsetHour = 0,
-	    offsetMinute = 0;
-
-	/* don't check the numerical offset if time zone is specified as 'Z' */
-	if (!matches[5].str().empty()) {
-		offsetHour = std::stoi(matches[5].str());
-		offsetMinute = std::stoi(matches[6].str());
-
-		range_check(offsetHour, -23, 23);
-		range_check(offsetMinute, 0, 59);
-		if (offsetHour < 0)
-			offsetMinute *= -1;
-	}
-
-	/**
-	 * @todo Could be made more exact by querying a leap second database and choosing the
-	 *       correct maximum in {58,59,60}. This current solution might match some invalid dates
-	 *       but it won't lead to false negatives. This only works if we know the full date, however
-	 */
-
-	auto day_minutes = hour * 60 + minute - (offsetHour * 60 + offsetMinute);
-	if (day_minutes < 0)
-		day_minutes += 60 * 24;
-	hour = day_minutes % 24;
-	minute = day_minutes / 24;
-
-	if (hour == 23 && minute == 59)
-		range_check(second, 0, 60); // possible leap-second
-	else
-		range_check(second, 0, 59);
-}
-
-/**
- * @see https://tools.ietf.org/html/rfc3339#section-5.6
- *
- * @verbatim
- * date-fullyear   = 4DIGIT
- * date-month      = 2DIGIT  ; 01-12
- * date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on
- *                          ; month/year
- * time-hour       = 2DIGIT  ; 00-23
- * time-minute     = 2DIGIT  ; 00-59
- * time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second
- *                          ; rules
- * time-secfrac    = "." 1*DIGIT
- * time-numoffset  = ("+" / "-") time-hour ":" time-minute
- * time-offset     = "Z" / time-numoffset
- *
- * partial-time    = time-hour ":" time-minute ":" time-second
- *                  [time-secfrac]
- * full-date       = date-fullyear "-" date-month "-" date-mday
- * full-time       = partial-time time-offset
- *
- * date-time       = full-date "T" full-time
- * @endverbatim
- * NOTE: Per [ABNF] and ISO8601, the "T" and "Z" characters in this
- *       syntax may alternatively be lower case "t" or "z" respectively.
- */
-void rfc3339_date_time_check(const std::string &value)
-{
-	const static REGEX_NAMESPACE::regex dateTimeRegex{R"(^([0-9]{4}\-[0-9]{2}\-[0-9]{2})[Tt]([0-9]{2}\:[0-9]{2}\:[0-9]{2}(?:\.[0-9]+)?(?:[Zz]|(?:\+|\-)[0-9]{2}\:[0-9]{2}))$)"};
-
-	REGEX_NAMESPACE::smatch matches;
-	if (!REGEX_NAMESPACE::regex_match(value, matches, dateTimeRegex)) {
-		throw std::invalid_argument(value + " is not a date-time string according to RFC 3339.");
-	}
-
-	rfc3339_date_check(matches[1].str());
-	rfc3339_time_check(matches[2].str());
-}
-
-const std::string decOctet{R"((?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9]))"}; // matches numbers 0-255
-const std::string ipv4Address{"(?:" + decOctet + R"(\.){3})" + decOctet};
-const std::string h16{R"([0-9A-Fa-f]{1,4})"};
-const std::string h16Left{"(?:" + h16 + ":)"};
-const std::string ipv6Address{
-    "(?:"
-    "(?:" +
-    h16Left + "{6}"
-              "|::" +
-    h16Left + "{5}"
-              "|(?:" +
-    h16 + ")?::" + h16Left + "{4}"
-                             "|(?:" +
-    h16Left + "{0,1}" + h16 + ")?::" + h16Left + "{3}"
-                                                 "|(?:" +
-    h16Left + "{0,2}" + h16 + ")?::" + h16Left + "{2}"
-                                                 "|(?:" +
-    h16Left + "{0,3}" + h16 + ")?::" + h16Left +
-    "|(?:" + h16Left + "{0,4}" + h16 + ")?::"
-                                       ")(?:" +
-    h16Left + h16 + "|" + ipv4Address + ")"
-                                        "|(?:" +
-    h16Left + "{0,5}" + h16 + ")?::" + h16 +
-    "|(?:" + h16Left + "{0,6}" + h16 + ")?::"
-                                       ")"};
-const std::string ipvFuture{R"([Vv][0-9A-Fa-f]+\.[A-Za-z0-9\-._~!$&'()*+,;=:]+)"};
-const std::string regName{R"((?:[A-Za-z0-9\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*)"};
-const std::string host{
-    "(?:"
-    R"(\[(?:)" +
-    ipv6Address + "|" + ipvFuture + R"()\])" +
-    "|" + ipv4Address +
-    "|" + regName +
-    ")"};
-
-const std::string uuid{R"([0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12})"};
-
-// from http://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
-const std::string hostname{R"(^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$)"};
-
-bool is_ascii(std::string const &value)
-{
-	for (auto ch : value) {
-		if (ch & 0x80) {
-			return false;
-		}
-	}
-	return true;
-}
-
-/**
- * @see
- *
- * @verbatim
- * URI           = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
- *
- *  hier-part     = "//" authority path-abempty
- *               / path-absolute
- *               / path-rootless
- *               / path-empty
- *
- * URI-reference = URI / relative-ref
- *
- * absolute-URI  = scheme ":" hier-part [ "?" query ]
- *
- * relative-ref  = relative-part [ "?" query ] [ "#" fragment ]
- *
- * relative-part = "//" authority path-abempty
- *               / path-absolute
- *               / path-noscheme
- *               / path-empty
- *
- * scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
- *
- * authority     = [ userinfo "@" ] host [ ":" port ]
- * userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
- * host          = IP-literal / IPv4address / reg-name
- * port          = *DIGIT
- *
- * IP-literal    = "[" ( IPv6address / IPvFuture  ) "]"
- *
- * IPvFuture     = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
- *
- * IPv6address   =                            6( h16 ":" ) ls32
- *               /                       "::" 5( h16 ":" ) ls32
- *               / [               h16 ] "::" 4( h16 ":" ) ls32
- *               / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
- *               / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
- *               / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
- *               / [ *4( h16 ":" ) h16 ] "::"              ls32
- *               / [ *5( h16 ":" ) h16 ] "::"              h16
- *               / [ *6( h16 ":" ) h16 ] "::"
- *
- * h16           = 1*4HEXDIG
- * ls32          = ( h16 ":" h16 ) / IPv4address
- * IPv4address   = dec-octet "." dec-octet "." dec-octet "." dec-octet
- *    dec-octet     = DIGIT                 ; 0-9
- *               / %x31-39 DIGIT         ; 10-99
- *               / "1" 2DIGIT            ; 100-199
- *               / "2" %x30-34 DIGIT     ; 200-249
- *               / "25" %x30-35          ; 250-255
- *
- * reg-name      = *( unreserved / pct-encoded / sub-delims )
- *
- * path          = path-abempty    ; begins with "/" or is empty
- *               / path-absolute   ; begins with "/" but not "//"
- *               / path-noscheme   ; begins with a non-colon segment
- *               / path-rootless   ; begins with a segment
- *               / path-empty      ; zero characters
- *
- * path-abempty  = *( "/" segment )
- * path-absolute = "/" [ segment-nz *( "/" segment ) ]
- * path-noscheme = segment-nz-nc *( "/" segment )
- * path-rootless = segment-nz *( "/" segment )
- * path-empty    = 0<pchar>
- *
- * segment       = *pchar
- * segment-nz    = 1*pchar
- * segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
- *               ; non-zero-length segment without any colon ":"
- *
- * pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
- *
- * query         = *( pchar / "/" / "?" )
- *
- * fragment      = *( pchar / "/" / "?" )
- *
- * pct-encoded   = "%" HEXDIG HEXDIG
- *
- * unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
- * reserved      = gen-delims / sub-delims
- * gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
- * sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
- *               / "*" / "+" / "," / ";" / "="
- *
- * @endverbatim
- * @see adapted from: https://github.com/jhermsmeier/uri.regex/blob/master/uri.regex
- *
- */
-void rfc3986_uri_check(const std::string &value)
-{
-	const static std::string scheme{R"(([A-Za-z][A-Za-z0-9+\-.]*):)"};
-	const static std::string hierPart{
-	    R"((?:(\/\/)(?:((?:[A-Za-z0-9\-._~!$&'()*+,;=:]|)"
-	    R"(%[0-9A-Fa-f]{2})*)@)?((?:\[(?:(?:(?:(?:[0-9A-Fa-f]{1,4}:){6}|)"
-	    R"(::(?:[0-9A-Fa-f]{1,4}:){5}|)"
-	    R"((?:[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:){4}|)"
-	    R"((?:(?:[0-9A-Fa-f]{1,4}:){0,1}[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:){3}|)"
-	    R"((?:(?:[0-9A-Fa-f]{1,4}:){0,2}[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:){2}|)"
-	    R"((?:(?:[0-9A-Fa-f]{1,4}:){0,3}[0-9A-Fa-f]{1,4})?::[0-9A-Fa-f]{1,4}:|)"
-	    R"((?:(?:[0-9A-Fa-f]{1,4}:){0,4}[0-9A-Fa-f]{1,4})?::)(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|)"
-	    R"((?:(?:25[0-5]|2[0-4][0-9]|)"
-	    R"([01]?[0-9][0-9]?)\.){3}(?:25[0-5]|)"
-	    R"(2[0-4][0-9]|)"
-	    R"([01]?[0-9][0-9]?))|)"
-	    R"((?:(?:[0-9A-Fa-f]{1,4}:){0,5}[0-9A-Fa-f]{1,4})?::[0-9A-Fa-f]{1,4}|)"
-	    R"((?:(?:[0-9A-Fa-f]{1,4}:){0,6}[0-9A-Fa-f]{1,4})?::)|)"
-	    R"([Vv][0-9A-Fa-f]+\.[A-Za-z0-9\-._~!$&'()*+,;=:]+)\]|)"
-	    R"((?:(?:25[0-5]|)"
-	    R"(2[0-4][0-9]|)"
-	    R"([01]?[0-9][0-9]?)\.){3}(?:25[0-5]|)"
-	    R"(2[0-4][0-9]|)"
-	    R"([01]?[0-9][0-9]?)|)"
-	    R"((?:[A-Za-z0-9\-._~!$&'()*+,;=]|)"
-	    R"(%[0-9A-Fa-f]{2})*))(?::([0-9]*))?((?:\/(?:[A-Za-z0-9\-._~!$&'()*+,;=:@]|)"
-	    R"(%[0-9A-Fa-f]{2})*)*)|)"
-	    R"(\/((?:(?:[A-Za-z0-9\-._~!$&'()*+,;=:@]|)"
-	    R"(%[0-9A-Fa-f]{2})+(?:\/(?:[A-Za-z0-9\-._~!$&'()*+,;=:@]|)"
-	    R"(%[0-9A-Fa-f]{2})*)*)?)|)"
-	    R"(((?:[A-Za-z0-9\-._~!$&'()*+,;=:@]|)"
-	    R"(%[0-9A-Fa-f]{2})+(?:\/(?:[A-Za-z0-9\-._~!$&'()*+,;=:@]|)"
-	    R"(%[0-9A-Fa-f]{2})*)*)|))"};
-
-	const static std::string query{R"((?:\?((?:[A-Za-z0-9\-._~!$&'()*+,;=:@\/?]|%[0-9A-Fa-f]{2})*))?)"};
-	const static std::string fragment{
-	    R"((?:\#((?:[A-Za-z0-9\-._~!$&'()*+,;=:@\/?]|%[0-9A-Fa-f]{2})*))?)"};
-	const static std::string uriFormat{scheme + hierPart + query + fragment};
-
-	const static REGEX_NAMESPACE::regex uriRegex{uriFormat};
-
-	if (!REGEX_NAMESPACE::regex_match(value, uriRegex)) {
-		throw std::invalid_argument(value + " is not a URI string according to RFC 3986.");
-	}
-}
-
-} // namespace
-
-namespace nlohmann
-{
-namespace json_schema
-{
-/**
- * Checks validity for built-ins by converting the definitions given as ABNF in the linked RFC from
- * @see https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
- * into regular expressions using @see https://www.msweet.org/abnf/ and some manual editing.
- *
- * @see https://json-schema.org/latest/json-schema-validation.html
- */
-void default_string_format_check(const std::string &format, const std::string &value)
-{
-	if (format == "date-time") {
-		rfc3339_date_time_check(value);
-	} else if (format == "date") {
-		rfc3339_date_check(value);
-	} else if (format == "time") {
-		rfc3339_time_check(value);
-	} else if (format == "uri") {
-		rfc3986_uri_check(value);
-	} else if (format == "email") {
-		if (!is_ascii(value)) {
-			throw std::invalid_argument(value + " contains non-ASCII values, not RFC 5321 compliant.");
-		}
-		if (!is_address(&*value.begin(), &*value.end())) {
-			throw std::invalid_argument(value + " is not a valid email according to RFC 5321.");
-		}
-	} else if (format == "idn-email") {
-		if (!is_address(&*value.begin(), &*value.end())) {
-			throw std::invalid_argument(value + " is not a valid idn-email according to RFC 6531.");
-		}
-	} else if (format == "hostname") {
-		static const REGEX_NAMESPACE::regex hostRegex{hostname};
-		if (!REGEX_NAMESPACE::regex_match(value, hostRegex)) {
-			throw std::invalid_argument(value + " is not a valid hostname according to RFC 3986 Appendix A.");
-		}
-	} else if (format == "ipv4") {
-		const static REGEX_NAMESPACE::regex ipv4Regex{"^" + ipv4Address + "$"};
-		if (!REGEX_NAMESPACE::regex_match(value, ipv4Regex)) {
-			throw std::invalid_argument(value + " is not an IPv4 string according to RFC 2673.");
-		}
-	} else if (format == "ipv6") {
-		static const REGEX_NAMESPACE::regex ipv6Regex{ipv6Address};
-		if (!REGEX_NAMESPACE::regex_match(value, ipv6Regex)) {
-			throw std::invalid_argument(value + " is not an IPv6 string according to RFC 5954.");
-		}
-	} else if (format == "uuid") {
-		static const REGEX_NAMESPACE::regex uuidRegex{uuid};
-		if (!REGEX_NAMESPACE::regex_match(value, uuidRegex)) {
-			throw std::invalid_argument(value + " is not an uuid string according to RFC 4122.");
-		}
-	} else if (format == "regex") {
-		try {
-			REGEX_NAMESPACE::regex re(value, std::regex::ECMAScript);
-		} catch (std::exception &exception) {
-			throw exception;
-		}
-	} else {
-		/* yet unsupported JSON schema draft 7 built-ins */
-		static const std::vector<std::string> jsonSchemaStringFormatBuiltIns{
-		    "date-time", "time", "date", "email", "idn-email", "hostname", "idn-hostname", "ipv4", "ipv6", "uri",
-		    "uri-reference", "iri", "iri-reference", "uri-template", "json-pointer", "relative-json-pointer", "regex"};
-		if (std::find(jsonSchemaStringFormatBuiltIns.begin(), jsonSchemaStringFormatBuiltIns.end(), format) != jsonSchemaStringFormatBuiltIns.end()) {
-			throw std::logic_error("JSON schema string format built-in " + format + " not yet supported. " +
-			                       "Please open an issue or use a custom format checker.");
-		}
-
-		throw std::logic_error("Don't know how to validate " + format);
-	}
-}
-} // namespace json_schema
-} // namespace nlohmann

test/CMakeLists.txt

@@ -7,8 +7,7 @@ function(add_test_simple_schema name schema instance)
         COMMAND ${PIPE_IN_TEST_SCRIPT}
             $<TARGET_FILE:json-schema-validate>
             ${schema}
-            ${instance}
+            ${instance})
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 endfunction()
 
 file(GLOB TEST_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/*)
@@ -18,78 +17,3 @@ foreach(DIR ${TEST_DIRS})
         add_subdirectory(${DIR})
     endif()
 endforeach()
-
-add_executable(uri uri.cpp)
-target_link_libraries(uri nlohmann_json_schema_validator)
-add_test(NAME uri COMMAND uri)
-
-add_executable(errors errors.cpp)
-target_link_libraries(errors nlohmann_json_schema_validator)
-add_test(NAME errors COMMAND errors)
-
-add_executable(issue-70 issue-70.cpp)
-target_link_libraries(issue-70 nlohmann_json_schema_validator)
-add_test(NAME issue-70 COMMAND issue-70)
-
-add_executable(issue-70-root-schema-constructor issue-70-root-schema-constructor.cpp)
-target_link_libraries(issue-70-root-schema-constructor nlohmann_json_schema_validator)
-add_test(NAME issue-70-root-schema-constructor COMMAND issue-70-root-schema-constructor)
-
-add_executable(issue-25-default-values issue-25-default-values.cpp)
-target_link_libraries(issue-25-default-values nlohmann_json_schema_validator)
-add_test(NAME issue-25-default-values COMMAND issue-25-default-values)
-
-add_executable(issue-98 issue-98.cpp)
-target_link_libraries(issue-98 nlohmann_json_schema_validator)
-add_test(NAME issue-98-erase-exception-unknown-keywords COMMAND issue-98)
-
-add_executable(issue-293 issue-293.cpp)
-target_link_libraries(issue-293 nlohmann_json_schema_validator)
-add_test(NAME issue-293-float-point-error COMMAND issue-293)
-
-# Unit test for string format checks
-add_executable(string-format-check-test string-format-check-test.cpp)
-target_include_directories(string-format-check-test PRIVATE ${PROJECT_SOURCE_DIR}/src/)
-target_link_libraries(string-format-check-test nlohmann_json_schema_validator)
-
-add_test(NAME string-format-check-test COMMAND string-format-check-test)
-
-# Unit test for json-patch
-add_executable(json-patch json-patch.cpp)
-target_include_directories(json-patch PRIVATE ${PROJECT_SOURCE_DIR}/src)
-target_link_libraries(json-patch nlohmann_json_schema_validator)
-add_test(NAME json-patch COMMAND json-patch)
-
-# Unit test for format checker fail at schema parsing time
-add_executable(issue-117-format-error issue-117-format-error.cpp)
-target_link_libraries(issue-117-format-error nlohmann_json_schema_validator)
-add_test(NAME issue-117-format-error COMMAND issue-117-format-error)
-
-add_executable(binary-validation binary-validation.cpp)
-target_include_directories(binary-validation PRIVATE ${PROJECT_SOURCE_DIR}/src)
-target_link_libraries(binary-validation PRIVATE nlohmann_json_schema_validator)
-add_test(NAME binary-validation COMMAND binary-validation)
-
-add_executable(issue-149-entry-selection issue-149-entry-selection.cpp)
-target_link_libraries(issue-149-entry-selection PRIVATE nlohmann_json_schema_validator)
-add_test(NAME issue-149-entry-selection COMMAND issue-149-entry-selection)
-
-add_executable(issue-189-default-values issue-189-default-values.cpp)
-target_link_libraries(issue-189-default-values nlohmann_json_schema_validator)
-add_test(NAME issue-189-default-values COMMAND issue-189-default-values)
-
-add_executable(issue-229-oneof-default-values issue-229-oneof-default-values.cpp)
-target_link_libraries(issue-229-oneof-default-values nlohmann_json_schema_validator)
-add_test(NAME issue-229-oneof-default-values COMMAND issue-229-oneof-default-values)
-
-add_executable(issue-243-root-default-values issue-243-root-default-values.cpp)
-target_link_libraries(issue-243-root-default-values nlohmann_json_schema_validator)
-add_test(NAME issue-243-root-default-values COMMAND issue-243-root-default-values)
-
-add_executable(issue-255-error-message-limit-precision issue-255-error-message-limit-precision.cpp)
-target_link_libraries(issue-255-error-message-limit-precision nlohmann_json_schema_validator)
-add_test(NAME issue-255-error-message-limit-precision COMMAND issue-255-error-message-limit-precision)
-
-add_executable(issue-105-verbose-combination-errors issue-105-verbose-combination-errors.cpp)
-target_link_libraries(issue-105-verbose-combination-errors nlohmann_json_schema_validator)
-add_test(NAME issue-105-verbose-combination-errors COMMAND issue-105-verbose-combination-errors)

test/JSON-Schema-Test-Suite/CMakeLists.txt

@@ -1,11 +1,9 @@
 set(JSON_SCHEMA_TEST_PREFIX "JSON-Suite" CACHE STRING "prefix for JSON-tests added to ctest")
 
-set(DRAFT "draft7")
-
 # find schema-test-suite
 find_path(JSON_SCHEMA_TEST_SUITE_PATH
     NAMES
-        tests/${DRAFT})
+        tests/draft4)
 
 if (NOT JSON_SCHEMA_TEST_SUITE_PATH)
     message(STATUS "Set JSON_SCHEMA_TEST_SUITE_PATH to a path in which JSON-Schema-Test-Suite is located (github.com/json-schema-org/JSON-Schema-Test-Suite). Using internal test-suite which might be out of date.")
@@ -15,7 +13,7 @@ endif()
 if(JSON_SCHEMA_TEST_SUITE_PATH)
     # json-schema-validator-tester
     add_executable(json-schema-test json-schema-test.cpp)
-    target_link_libraries(json-schema-test nlohmann_json_schema_validator)
+    target_link_libraries(json-schema-test json-schema-validator)
     target_compile_definitions(json-schema-test
         PRIVATE
             JSON_SCHEMA_TEST_SUITE_PATH="${JSON_SCHEMA_TEST_SUITE_PATH}")
@@ -23,7 +21,7 @@ if(JSON_SCHEMA_TEST_SUITE_PATH)
     option(JSON_SCHEMA_ENABLE_OPTIONAL_TESTS "Enable optional tests of the JSONSchema Test Suite" ON)
 
     # create tests foreach test-file
-    file(GLOB TEST_FILES ${JSON_SCHEMA_TEST_SUITE_PATH}/tests/${DRAFT}/*.json)
+    file(GLOB TEST_FILES ${JSON_SCHEMA_TEST_SUITE_PATH}/tests/draft4/*.json)
 
     foreach(TEST_FILE ${TEST_FILES})
         get_filename_component(TEST_NAME ${TEST_FILE} NAME_WE)
@@ -32,8 +30,7 @@ if(JSON_SCHEMA_TEST_SUITE_PATH)
     endforeach()
 
     if (JSON_SCHEMA_ENABLE_OPTIONAL_TESTS)
-        file(GLOB OPT_TEST_FILES ${JSON_SCHEMA_TEST_SUITE_PATH}/tests/${DRAFT}/optional/*.json)
+        file(GLOB OPT_TEST_FILES ${JSON_SCHEMA_TEST_SUITE_PATH}/tests/draft4/optional/*.json)
-        file(GLOB FORMAT_TEST_FILES ${JSON_SCHEMA_TEST_SUITE_PATH}/tests/${DRAFT}/optional/format/*.json)
 
         foreach(TEST_FILE ${OPT_TEST_FILES})
             get_filename_component(TEST_NAME ${TEST_FILE} NAME_WE)
@@ -41,28 +38,16 @@ if(JSON_SCHEMA_TEST_SUITE_PATH)
                      COMMAND ${PIPE_IN_TEST_SCRIPT} $<TARGET_FILE:json-schema-test> ${TEST_FILE})
         endforeach()
 
-        foreach(TEST_FILE ${FORMAT_TEST_FILES})
+        # XXX Unfortunately URLs are not very well handled yet, accept those tests which fail
-            get_filename_component(TEST_NAME ${TEST_FILE} NAME_WE)
+        set_tests_properties(JSON-Suite::ref
-            add_test(NAME "${JSON_SCHEMA_TEST_PREFIX}::Optional::Format::${TEST_NAME}"
+                             JSON-Suite::refRemote
-                     COMMAND ${PIPE_IN_TEST_SCRIPT} $<TARGET_FILE:json-schema-test> ${TEST_FILE})
+                             PROPERTIES
-        endforeach()
+                                WILL_FAIL ON)
-
-        # some optional tests will fail
-        set_tests_properties(
-            JSON-Suite::Optional::bignum
-            JSON-Suite::Optional::non-bmp-regex
-            JSON-Suite::Optional::float-overflow
 
+        # some optional tests will fail as well.
+        set_tests_properties(JSON-Suite::Optional::bignum
                              JSON-Suite::Optional::ecmascript-regex
-            JSON-Suite::Optional::Format::idn-hostname
+                             JSON-Suite::Optional::format
-            JSON-Suite::Optional::Format::iri-reference
-            JSON-Suite::Optional::Format::iri
-            JSON-Suite::Optional::Format::json-pointer
-            JSON-Suite::Optional::Format::relative-json-pointer
-            JSON-Suite::Optional::Format::uri-reference
-            JSON-Suite::Optional::Format::uri-template
-            JSON-Suite::Optional::unicode
-
                              PROPERTIES
                                 WILL_FAIL ON)
     endif()

test/JSON-Schema-Test-Suite/json-schema-test.cpp

@@ -1,25 +1,68 @@
 /*
- * JSON schema validator for JSON for modern C++
+ * Modern C++ JSON schema validator
  *
- * Copyright (c) 2016-2019 Patrick Boettcher <p@yai.se>.
+ * Licensed under the MIT License <http://opensource.org/licenses/MIT>.
  *
- * SPDX-License-Identifier: MIT
+ * Copyright (c) 2016 Patrick Boettcher <patrick.boettcher@posteo.de>.
  *
+ * Permission is hereby  granted, free of charge, to any  person obtaining a
+ * copy of this software and associated  documentation files (the "Software"),
+ * to deal in the Software  without restriction, including without  limitation
+ * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
+ * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom
+ * the Software  is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
+ * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
+ * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
+ * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-#include <nlohmann/json-schema.hpp>
+#include "json-schema.hpp"
 
 #include <fstream>
-#include <iostream>
 #include <regex>
+#include <iostream>
 
 using nlohmann::json;
 using nlohmann::json_uri;
-using nlohmann::json_schema::json_validator;
+using nlohmann::json_schema_draft4::json_validator;
+
+static void format_check(const std::string &format, const std::string &value)
+{
+	if (format == "hostname") {
+		// from http://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
+		std::regex re(R"(^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$)");
+		if (!std::regex_match(value, re))
+			throw std::invalid_argument(value + " is not a valid hostname.");
+	} else if (format == "ipv4") {
+		std::regex re(R"(^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$)");
+		if (!std::regex_match(value, re))
+			throw std::invalid_argument(value + " is not a IPv4-address.");
+
+	} else if (format == "ipv6") {
+		std::regex re(R"((([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])))");
+		if (!std::regex_match(value, re))
+			throw std::invalid_argument(value + " is not a IPv6-address.");
+	} else if (format == "regex") {
+		try {
+			std::regex re(value, std::regex::ECMAScript);
+		} catch (std::exception &e) {
+			throw e;
+		}
+	} else
+		throw std::logic_error("don't know how to validate " + format);
+}
 
 static void loader(const json_uri &uri, json &schema)
 {
-	if (uri.location() == "http://json-schema.org/draft-07/schema") {
+	if (uri.to_string() == "http://json-schema.org/draft-04/schema#") {
-		schema = nlohmann::json_schema::draft7_schema_builtin;
+		schema = nlohmann::json_schema_draft4::draft4_schema_builtin;
 		return;
 	}
 
@@ -39,50 +82,6 @@ static void loader(const json_uri &uri, json &schema)
 	}
 }
 
-// from here
-// https://stackoverflow.com/a/34571089/880584
-static std::string base64_decode(const std::string &in)
-{
-	std::string out;
-
-	std::vector<int> T(256, -1);
-	for (int i = 0; i < 64; i++)
-		T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i;
-
-	unsigned val = 0;
-	int valb = -8;
-	for (uint8_t c : in) {
-		if (c == '=')
-			break;
-
-		if (T[c] == -1) {
-			throw std::invalid_argument("base64-decode: unexpected character in encode string: '" + std::string(1, c) + "'");
-		}
-		val = (val << 6) + T[c];
-		valb += 6;
-		if (valb >= 0) {
-			out.push_back(char((val >> valb) & 0xFF));
-			valb -= 8;
-		}
-	}
-	return out;
-}
-
-static void content(const std::string &contentEncoding, const std::string &contentMediaType, const json &instance)
-{
-	std::string content = instance;
-
-	if (contentEncoding == "base64")
-		content = base64_decode(instance);
-	else if (contentEncoding != "")
-		throw std::invalid_argument("unable to check for contentEncoding '" + contentEncoding + "'");
-
-	if (contentMediaType == "application/json")
-		auto dummy = json::parse(content); // throws if conversion fails
-	else if (contentMediaType != "")
-		throw std::invalid_argument("unable to check for contentMediaType '" + contentMediaType + "'");
-}
-
 int main(void)
 {
 	json validation; // a validation case following the JSON-test-suite-schema
@@ -105,9 +104,7 @@ int main(void)
 
 		const auto &schema = test_group["schema"];
 
-		json_validator validator(loader,
+		json_validator validator(loader, format_check);
-		                         nlohmann::json_schema::default_string_format_check,
-		                         content);
 
 		validator.set_root_schema(schema);
 

test/JSON-Schema-Test-Suite/remotes/baseUriChange/folderInteger.json

@@ -1,3 +0,0 @@
-{
-    "type": "integer"
-}

test/JSON-Schema-Test-Suite/remotes/baseUriChangeFolder/folderInteger.json

@@ -1,3 +0,0 @@
-{
-    "type": "integer"
-}

test/JSON-Schema-Test-Suite/remotes/baseUriChangeFolderInSubschema/folderInteger.json

@@ -1,3 +0,0 @@
-{
-    "type": "integer"
-}

test/JSON-Schema-Test-Suite/remotes/folder/folderInteger.json

@@ -1,3 +0,0 @@
-{
-    "type": "integer"
-}

test/JSON-Schema-Test-Suite/remotes/integer.json

@@ -1,3 +0,0 @@
-{
-    "type": "integer"
-}

test/JSON-Schema-Test-Suite/remotes/name-defs.json

@@ -1,15 +0,0 @@
-{
-    "$defs": {
-        "orNull": {
-            "anyOf": [
-                {
-                    "type": "null"
-                },
-                {
-                    "$ref": "#"
-                }
-            ]
-        }
-    },
-    "type": "string"
-}

test/JSON-Schema-Test-Suite/remotes/name.json

@@ -1,15 +0,0 @@
-{
-    "definitions": {
-        "orNull": {
-            "anyOf": [
-                {
-                    "type": "null"
-                },
-                {
-                    "$ref": "#"
-                }
-            ]
-        }
-    },
-    "type": "string"
-}

test/JSON-Schema-Test-Suite/remotes/ref-and-definitions.json

@@ -1,11 +0,0 @@
-{
-    "$id": "http://localhost:1234/ref-and-definitions.json",
-    "definitions": {
-        "inner": {
-            "properties": {
-                "bar": { "type": "string" }
-            }
-        }
-    },
-    "allOf": [ { "$ref": "#/definitions/inner" } ]
-}

test/JSON-Schema-Test-Suite/remotes/ref-and-defs.json

@@ -1,11 +0,0 @@
-{
-    "$id": "http://localhost:1234/ref-and-defs.json",
-    "$defs": {
-        "inner": {
-            "properties": {
-                "bar": { "type": "string" }
-            }
-        }
-    },
-    "$ref": "#/$defs/inner"
-}

test/JSON-Schema-Test-Suite/remotes/subSchemas-defs.json

@@ -1,10 +0,0 @@
-{
-    "$defs": {
-        "integer": {
-            "type": "integer"
-        },
-        "refToInteger": {
-            "$ref": "#/$defs/integer"
-        }
-    }
-}

test/JSON-Schema-Test-Suite/remotes/subSchemas.json

@@ -1,8 +0,0 @@
-{
-    "integer": {
-        "type": "integer"
-    },
-    "refToInteger": {
-        "$ref": "#/integer"
-    }
-}

test/JSON-Schema-Test-Suite/tests/draft4/additionalItems.json

@@ -19,7 +19,7 @@
         ]
     },
     {
-        "description": "when items is schema, additionalItems does nothing",
+        "description": "items is schema, no additionalItems",
         "schema": {
             "items": {},
             "additionalItems": false
@@ -33,24 +33,14 @@
         ]
     },
     {
-        "description": "array of items with no additionalItems permitted",
+        "description": "array of items with no additionalItems",
         "schema": {
             "items": [{}, {}, {}],
             "additionalItems": false
         },
         "tests": [
             {
-                "description": "empty array",
+                "description": "fewer number of items present",
-                "data": [ ],
-                "valid": true
-            },
-            {
-                "description": "fewer number of items present (1)",
-                "data": [ 1 ],
-                "valid": true
-            },
-            {
-                "description": "fewer number of items present (2)",
                 "data": [ 1, 2 ],
                 "valid": true
             },
@@ -93,57 +83,5 @@
                 "valid": true
             }
         ]
-    },
-    {
-        "description": "additionalItems should not look in applicators, valid case",
-        "schema": {
-            "allOf": [
-                { "items": [ { "type": "integer" } ] }
-            ],
-            "additionalItems": { "type": "boolean" }
-        },
-        "tests": [
-            {
-                "description": "items defined in allOf are not examined",
-                "data": [ 1, null ],
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "additionalItems should not look in applicators, invalid case",
-        "schema": {
-            "allOf": [
-                { "items": [ { "type": "integer" }, { "type": "string" } ] }
-            ],
-            "items": [ {"type": "integer" } ],
-            "additionalItems": { "type": "boolean" }
-        },
-        "tests": [
-            {
-                "description": "items defined in allOf are not examined",
-                "data": [ 1, "hello" ],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "items validation adjusts the starting index for additionalItems",
-        "schema": {
-            "items": [ { "type": "string" } ],
-            "additionalItems": { "type": "integer" }
-        },
-        "tests": [
-            {
-                "description": "valid items",
-                "data": [ "x", 2, 3 ],
-                "valid": true
-            },
-            {
-                "description": "wrong type of second item",
-                "data": [ "x", "y" ],
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/additionalProperties.json

@@ -40,25 +40,6 @@
             }
         ]
     },
-    {
-        "description": "non-ASCII pattern with additionalProperties",
-        "schema": {
-            "patternProperties": {"^á": {}},
-            "additionalProperties": false
-        },
-        "tests": [
-            {
-                "description": "matching the pattern is valid",
-                "data": {"ármányos": 2},
-                "valid": true
-            },
-            {
-                "description": "not matching the pattern is invalid",
-                "data": {"élmény": 2},
-                "valid": false
-            }
-        ]
-    },
     {
         "description":
             "additionalProperties allows a schema which should validate",
@@ -113,21 +94,5 @@
                 "valid": true
             }
         ]
-    },
-    {
-        "description": "additionalProperties should not look in applicators",
-        "schema": {
-            "allOf": [
-                {"properties": {"foo": {}}}
-            ],
-            "additionalProperties": {"type": "boolean"}
-        },
-        "tests": [
-            {
-                "description": "properties defined in allOf are not examined",
-                "data": {"foo": 1, "bar": true},
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/allOf.json

@@ -0,0 +1,112 @@
+[
+    {
+        "description": "allOf",
+        "schema": {
+            "allOf": [
+                {
+                    "properties": {
+                        "bar": {"type": "integer"}
+                    },
+                    "required": ["bar"]
+                },
+                {
+                    "properties": {
+                        "foo": {"type": "string"}
+                    },
+                    "required": ["foo"]
+                }
+            ]
+        },
+        "tests": [
+            {
+                "description": "allOf",
+                "data": {"foo": "baz", "bar": 2},
+                "valid": true
+            },
+            {
+                "description": "mismatch second",
+                "data": {"foo": "baz"},
+                "valid": false
+            },
+            {
+                "description": "mismatch first",
+                "data": {"bar": 2},
+                "valid": false
+            },
+            {
+                "description": "wrong type",
+                "data": {"foo": "baz", "bar": "quux"},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "allOf with base schema",
+        "schema": {
+            "properties": {"bar": {"type": "integer"}},
+            "required": ["bar"],
+            "allOf" : [
+                {
+                    "properties": {
+                        "foo": {"type": "string"}
+                    },
+                    "required": ["foo"]
+                },
+                {
+                    "properties": {
+                        "baz": {"type": "null"}
+                    },
+                    "required": ["baz"]
+                }
+            ]
+        },
+        "tests": [
+            {
+                "description": "valid",
+                "data": {"foo": "quux", "bar": 2, "baz": null},
+                "valid": true
+            },
+            {
+                "description": "mismatch base schema",
+                "data": {"foo": "quux", "baz": null},
+                "valid": false
+            },
+            {
+                "description": "mismatch first allOf",
+                "data": {"bar": 2, "baz": null},
+                "valid": false
+            },
+            {
+                "description": "mismatch second allOf",
+                "data": {"foo": "quux", "bar": 2},
+                "valid": false
+            },
+            {
+                "description": "mismatch both",
+                "data": {"bar": 2},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "allOf simple types",
+        "schema": {
+            "allOf": [
+                {"maximum": 30},
+                {"minimum": 20}
+            ]
+        },
+        "tests": [
+            {
+                "description": "valid",
+                "data": 25,
+                "valid": true
+            },
+            {
+                "description": "mismatch one",
+                "data": 35,
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/anyOf.json

@@ -65,39 +65,6 @@
             }
         ]
     },
-    {
-        "description": "anyOf with boolean schemas, all true",
-        "schema": {"anyOf": [true, true]},
-        "tests": [
-            {
-                "description": "any value is valid",
-                "data": "foo",
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "anyOf with boolean schemas, some true",
-        "schema": {"anyOf": [true, false]},
-        "tests": [
-            {
-                "description": "any value is valid",
-                "data": "foo",
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "anyOf with boolean schemas, all false",
-        "schema": {"anyOf": [false, false]},
-        "tests": [
-            {
-                "description": "any value is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
-    },
     {
         "description": "anyOf complex types",
         "schema": {
@@ -138,78 +105,5 @@
                 "valid": false
             }
         ]
-    },
-    {
-        "description": "anyOf with one empty schema",
-        "schema": {
-            "anyOf": [
-                { "type": "number" },
-                {}
-            ]
-        },
-        "tests": [
-            {
-                "description": "string is valid",
-                "data": "foo",
-                "valid": true
-            },
-            {
-                "description": "number is valid",
-                "data": 123,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "nested anyOf, to check validation semantics",
-        "schema": {
-            "anyOf": [
-                {
-                    "anyOf": [
-                        {
-                            "type": "null"
-                        }
-                    ]
-                }
-            ]
-        },
-        "tests": [
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "anything non-null is invalid",
-                "data": 123,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "nested anyOf, to check validation semantics",
-        "schema": {
-            "anyOf": [
-                {
-                    "anyOf": [
-                        {
-                            "type": "null"
-                        }
-                    ]
-                }
-            ]
-        },
-        "tests": [
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "anything non-null is invalid",
-                "data": 123,
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/default.json

@@ -45,35 +45,5 @@
                 "valid": true
             }
         ]
-    },
-    {
-        "description": "the default keyword does not do anything if the property is missing",
-        "schema": {
-            "type": "object",
-            "properties": {
-                "alpha": {
-                    "type": "number",
-                    "maximum": 3,
-                    "default": 5
-                }
-            }
-        },
-        "tests": [
-            {
-                "description": "an explicit property value is checked against maximum (passing)",
-                "data": { "alpha": 1 },
-                "valid": true
-            },
-            {
-                "description": "an explicit property value is checked against maximum (failing)",
-                "data": { "alpha": 5 },
-                "valid": false
-            },
-            {
-                "description": "missing properties are not filled in with the default",
-                "data": {},
-                "valid": true
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/definitions.json

@@ -1,7 +1,7 @@
 [
     {
-        "description": "validate definition against metaschema",
+        "description": "valid definition",
-        "schema": {"$ref": "http://json-schema.org/draft-07/schema#"},
+        "schema": {"$ref": "http://json-schema.org/draft-04/schema#"},
         "tests": [
             {
                 "description": "valid definition schema",
@@ -11,7 +11,13 @@
                     }
                 },
                 "valid": true
+            }
+        ]
     },
+    {
+        "description": "invalid definition",
+        "schema": {"$ref": "http://json-schema.org/draft-04/schema#"},
+        "tests": [
             {
                 "description": "invalid definition schema",
                 "data": {

test/JSON-Schema-Test-Suite/tests/draft4/dependencies.json

@@ -0,0 +1,123 @@
+[
+    {
+        "description": "dependencies",
+        "schema": {
+            "dependencies": {"bar": ["foo"]}
+        },
+        "tests": [
+            {
+                "description": "neither",
+                "data": {},
+                "valid": true
+            },
+            {
+                "description": "nondependant",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "with dependency",
+                "data": {"foo": 1, "bar": 2},
+                "valid": true
+            },
+            {
+                "description": "missing dependency",
+                "data": {"bar": 2},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": ["bar"],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "foobar",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "multiple dependencies",
+        "schema": {
+            "dependencies": {"quux": ["foo", "bar"]}
+        },
+        "tests": [
+            {
+                "description": "neither",
+                "data": {},
+                "valid": true
+            },
+            {
+                "description": "nondependants",
+                "data": {"foo": 1, "bar": 2},
+                "valid": true
+            },
+            {
+                "description": "with dependencies",
+                "data": {"foo": 1, "bar": 2, "quux": 3},
+                "valid": true
+            },
+            {
+                "description": "missing dependency",
+                "data": {"foo": 1, "quux": 2},
+                "valid": false
+            },
+            {
+                "description": "missing other dependency",
+                "data": {"bar": 1, "quux": 2},
+                "valid": false
+            },
+            {
+                "description": "missing both dependencies",
+                "data": {"quux": 1},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "multiple dependencies subschema",
+        "schema": {
+            "dependencies": {
+                "bar": {
+                    "properties": {
+                        "foo": {"type": "integer"},
+                        "bar": {"type": "integer"}
+                    }
+                }
+            }
+        },
+        "tests": [
+            {
+                "description": "valid",
+                "data": {"foo": 1, "bar": 2},
+                "valid": true
+            },
+            {
+                "description": "no dependency",
+                "data": {"foo": "quux"},
+                "valid": true
+            },
+            {
+                "description": "wrong type",
+                "data": {"foo": "quux", "bar": 2},
+                "valid": false
+            },
+            {
+                "description": "wrong type other",
+                "data": {"foo": 2, "bar": "quux"},
+                "valid": false
+            },
+            {
+                "description": "wrong type both",
+                "data": {"foo": "quux", "bar": "quux"},
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/enum.json

@@ -0,0 +1,72 @@
+[
+    {
+        "description": "simple enum validation",
+        "schema": {"enum": [1, 2, 3]},
+        "tests": [
+            {
+                "description": "one of the enum is valid",
+                "data": 1,
+                "valid": true
+            },
+            {
+                "description": "something else is invalid",
+                "data": 4,
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "heterogeneous enum validation",
+        "schema": {"enum": [6, "foo", [], true, {"foo": 12}]},
+        "tests": [
+            {
+                "description": "one of the enum is valid",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "something else is invalid",
+                "data": null,
+                "valid": false
+            },
+            {
+                "description": "objects are deep compared",
+                "data": {"foo": false},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "enums in properties",
+        "schema": {
+           "type":"object",
+		     "properties": {
+		        "foo": {"enum":["foo"]},
+		        "bar": {"enum":["bar"]}
+		     },
+		     "required": ["bar"]
+		  },
+        "tests": [
+            {
+                "description": "both properties are valid",
+                "data": {"foo":"foo", "bar":"bar"},
+                "valid": true
+            },
+            {
+                "description": "missing optional property is valid",
+                "data": {"bar":"bar"},
+                "valid": true
+            },
+            {
+                "description": "missing required property is invalid",
+                "data": {"foo":"foo"},
+                "valid": false
+            },
+            {
+                "description": "missing all properties is invalid",
+                "data": {},
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/items.json

@@ -0,0 +1,78 @@
+[
+    {
+        "description": "a schema given for items",
+        "schema": {
+            "items": {"type": "integer"}
+        },
+        "tests": [
+            {
+                "description": "valid items",
+                "data": [ 1, 2, 3 ],
+                "valid": true
+            },
+            {
+                "description": "wrong type of items",
+                "data": [1, "x"],
+                "valid": false
+            },
+            {
+                "description": "ignores non-arrays",
+                "data": {"foo" : "bar"},
+                "valid": true
+            },
+            {
+                "description": "JavaScript pseudo-array is valid",
+                "data": {
+                    "0": "invalid",
+                    "length": 1
+                },
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "an array of schemas for items",
+        "schema": {
+            "items": [
+                {"type": "integer"},
+                {"type": "string"}
+            ]
+        },
+        "tests": [
+            {
+                "description": "correct types",
+                "data": [ 1, "foo" ],
+                "valid": true
+            },
+            {
+                "description": "wrong types",
+                "data": [ "foo", 1 ],
+                "valid": false
+            },
+            {
+                "description": "incomplete array of items",
+                "data": [ 1 ],
+                "valid": true
+            },
+            {
+                "description": "array with additional items",
+                "data": [ 1, "foo", true ],
+                "valid": true
+            },
+            {
+                "description": "empty array",
+                "data": [ ],
+                "valid": true
+            },
+            {
+                "description": "JavaScript pseudo-array is valid",
+                "data": {
+                    "0": "invalid",
+                    "1": "valid",
+                    "length": 2
+                },
+                "valid": true
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/maxProperties.json

@@ -34,21 +34,5 @@
                 "valid": true
             }
         ]
-    },
-    {
-        "description": "maxProperties = 0 means the object is empty",
-        "schema": { "maxProperties": 0 },
-        "tests": [
-            {
-                "description": "no properties is valid",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "one property is invalid",
-                "data": { "foo": 1 },
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/maximum.json

@@ -26,27 +26,46 @@
         ]
     },
     {
-        "description": "maximum validation with unsigned integer",
+        "description": "maximum validation (explicit false exclusivity)",
-        "schema": {"maximum": 300},
+        "schema": {"maximum": 3.0, "exclusiveMaximum": false},
         "tests": [
             {
-                "description": "below the maximum is invalid",
+                "description": "below the maximum is valid",
-                "data": 299.97,
+                "data": 2.6,
                 "valid": true
             },
             {
-                "description": "boundary point integer is valid",
+                "description": "boundary point is valid",
-                "data": 300,
+                "data": 3.0,
-                "valid": true
-            },
-            {
-                "description": "boundary point float is valid",
-                "data": 300.00,
                 "valid": true
             },
             {
                 "description": "above the maximum is invalid",
-                "data": 300.5,
+                "data": 3.5,
+                "valid": false
+            },
+            {
+                "description": "ignores non-numbers",
+                "data": "x",
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "exclusiveMaximum validation",
+        "schema": {
+            "maximum": 3.0,
+            "exclusiveMaximum": true
+        },
+        "tests": [
+            {
+                "description": "below the maximum is still valid",
+                "data": 2.2,
+                "valid": true
+            },
+            {
+                "description": "boundary point is invalid",
+                "data": 3.0,
                 "valid": false
             }
         ]

test/JSON-Schema-Test-Suite/tests/draft4/minimum.json

@@ -26,37 +26,22 @@
         ]
     },
     {
-        "description": "minimum validation with signed integer",
+        "description": "minimum validation (explicit false exclusivity)",
-        "schema": {"minimum": -2},
+        "schema": {"minimum": 1.1, "exclusiveMinimum": false},
         "tests": [
             {
-                "description": "negative above the minimum is valid",
+                "description": "above the minimum is valid",
-                "data": -1,
+                "data": 2.6,
-                "valid": true
-            },
-            {
-                "description": "positive above the minimum is valid",
-                "data": 0,
                 "valid": true
             },
             {
                 "description": "boundary point is valid",
-                "data": -2,
+                "data": 1.1,
                 "valid": true
             },
             {
-                "description": "boundary point with float is valid",
+                "description": "below the minimum is invalid",
-                "data": -2.0,
+                "data": 0.6,
-                "valid": true
-            },
-            {
-                "description": "float below the minimum is invalid",
-                "data": -2.0001,
-                "valid": false
-            },
-            {
-                "description": "int below the minimum is invalid",
-                "data": -3,
                 "valid": false
             },
             {
@@ -65,5 +50,24 @@
                 "valid": true
             }
         ]
+    },
+    {
+        "description": "exclusiveMinimum validation",
+        "schema": {
+            "minimum": 1.1,
+            "exclusiveMinimum": true
+        },
+        "tests": [
+            {
+                "description": "above the minimum is still valid",
+                "data": 1.2,
+                "valid": true
+            },
+            {
+                "description": "boundary point is invalid",
+                "data": 1.1,
+                "valid": false
+            }
+        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/multipleOf.json

@@ -56,16 +56,5 @@
                 "valid": false
             }
         ]
-    },
-    {
-        "description": "invalid instance should not raise error when float division = inf",
-        "schema": {"type": "integer", "multipleOf": 0.123456789},
-        "tests": [
-            {
-                "description": "always invalid, but naive implementations may raise an overflow error",
-                "data": 1e308,
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/not.json

@@ -91,27 +91,6 @@
                 "valid": true
             }
         ]
-    },
-    {
-        "description": "not with boolean schema true",
-        "schema": {"not": true},
-        "tests": [
-            {
-                "description": "any value is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "not with boolean schema false",
-        "schema": {"not": false},
-        "tests": [
-            {
-                "description": "any value is valid",
-                "data": "foo",
-                "valid": true
-            }
-        ]
     }
+
 ]

test/JSON-Schema-Test-Suite/tests/draft4/oneOf.json

@@ -0,0 +1,109 @@
+[
+    {
+        "description": "oneOf",
+        "schema": {
+            "oneOf": [
+                {
+                    "type": "integer"
+                },
+                {
+                    "minimum": 2
+                }
+            ]
+        },
+        "tests": [
+            {
+                "description": "first oneOf valid",
+                "data": 1,
+                "valid": true
+            },
+            {
+                "description": "second oneOf valid",
+                "data": 2.5,
+                "valid": true
+            },
+            {
+                "description": "both oneOf valid",
+                "data": 3,
+                "valid": false
+            },
+            {
+                "description": "neither oneOf valid",
+                "data": 1.5,
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "oneOf with base schema",
+        "schema": {
+            "type": "string",
+            "oneOf" : [
+                {
+                    "minLength": 2
+                },
+                {
+                    "maxLength": 4
+                }
+            ]
+        },
+        "tests": [
+            {
+                "description": "mismatch base schema",
+                "data": 3,
+                "valid": false
+            },
+            {
+                "description": "one oneOf valid",
+                "data": "foobar",
+                "valid": true
+            },
+            {
+                "description": "both oneOf valid",
+                "data": "foo",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "oneOf complex types",
+        "schema": {
+            "oneOf": [
+                {
+                    "properties": {
+                        "bar": {"type": "integer"}
+                    },
+                    "required": ["bar"]
+                },
+                {
+                    "properties": {
+                        "foo": {"type": "string"}
+                    },
+                    "required": ["foo"]
+                }
+            ]
+        },
+        "tests": [
+            {
+                "description": "first oneOf valid (complex)",
+                "data": {"bar": 2},
+                "valid": true
+            },
+            {
+                "description": "second oneOf valid (complex)",
+                "data": {"foo": "baz"},
+                "valid": true
+            },
+            {
+                "description": "both oneOf valid (complex)",
+                "data": {"foo": "baz", "bar": 2},
+                "valid": false
+            },
+            {
+                "description": "neither oneOf valid (complex)",
+                "data": {"foo": 2, "bar": "quux"},
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/optional/bignum.json

@@ -7,11 +7,6 @@
                 "description": "a bignum is an integer",
                 "data": 12345678910111213141516171819202122232425262728293031,
                 "valid": true
-            },
-            {
-                "description": "a negative bignum is an integer",
-                "data": -12345678910111213141516171819202122232425262728293031,
-                "valid": true
             }
         ]
     },
@@ -23,7 +18,24 @@
                 "description": "a bignum is a number",
                 "data": 98249283749234923498293171823948729348710298301928331,
                 "valid": true
+            }
+        ]
     },
+    {
+        "description": "integer",
+        "schema": {"type": "integer"},
+        "tests": [
+            {
+                "description": "a negative bignum is an integer",
+                "data": -12345678910111213141516171819202122232425262728293031,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "number",
+        "schema": {"type": "number"},
+        "tests": [
             {
                 "description": "a negative bignum is a number",
                 "data": -98249283749234923498293171823948729348710298301928331,
@@ -56,7 +68,8 @@
     {
         "description": "float comparison with high precision",
         "schema": {
-            "exclusiveMaximum": 972783798187987123879878123.18878137
+            "maximum": 972783798187987123879878123.18878137,
+            "exclusiveMaximum": true
         },
         "tests": [
             {
@@ -80,7 +93,8 @@
     {
         "description": "float comparison with high precision on negative numbers",
         "schema": {
-            "exclusiveMinimum": -972783798187987123879878123.18878137
+            "minimum": -972783798187987123879878123.18878137,
+            "exclusiveMinimum": true
         },
         "tests": [
             {

test/JSON-Schema-Test-Suite/tests/draft4/optional/ecmascript-regex.json

@@ -0,0 +1,13 @@
+[
+    {
+        "description": "ECMA 262 regex non-compliance",
+        "schema": { "format": "regex" },
+        "tests": [
+            {
+                "description": "ECMA 262 has no support for \\Z anchor from .NET",
+                "data": "^\\S(|(.|\\n)*\\S)\\Z",
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/optional/format.json

@@ -0,0 +1,223 @@
+[
+    {
+        "description": "validation of date-time strings",
+        "schema": {"format": "date-time"},
+        "tests": [
+            {
+                "description": "a valid date-time string",
+                "data": "1963-06-19T08:30:06.283185Z",
+                "valid": true
+            },
+            {
+                "description": "an invalid date-time string",
+                "data": "06/19/1963 08:30:06 PST",
+                "valid": false
+            },
+            {
+                "description": "only RFC3339 not all of ISO 8601 are valid",
+                "data": "2013-350T01:01:01",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "validation of URIs",
+        "schema": {"format": "uri"},
+        "tests": [
+            {
+                "description": "a valid URL with anchor tag",
+                "data": "http://foo.bar/?baz=qux#quux",
+                "valid": true
+            },
+            {
+                "description": "a valid URL with anchor tag and parantheses",
+                "data": "http://foo.com/blah_(wikipedia)_blah#cite-1",
+                "valid": true
+            },
+            {
+                "description": "a valid URL with URL-encoded stuff",
+                "data": "http://foo.bar/?q=Test%20URL-encoded%20stuff",
+                "valid": true
+            },
+            {
+                "description": "a valid puny-coded URL ",
+                "data": "http://xn--nw2a.xn--j6w193g/",
+                "valid": true
+            },
+            {
+                "description": "a valid URL with many special characters",
+                "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com",
+                "valid": true
+            },
+            {
+                "description": "a valid URL based on IPv4",
+                "data": "http://223.255.255.254",
+                "valid": true
+            },
+            {
+                "description": "a valid URL with ftp scheme",
+                "data": "ftp://ftp.is.co.za/rfc/rfc1808.txt",
+                "valid": true
+            },
+            {
+                "description": "a valid URL for a simple text file",
+                "data": "http://www.ietf.org/rfc/rfc2396.txt",
+                "valid": true
+            },
+            {
+                "description": "a valid URL ",
+                "data": "ldap://[2001:db8::7]/c=GB?objectClass?one",
+                "valid": true
+            },
+            {
+                "description": "a valid mailto URI",
+                "data": "mailto:John.Doe@example.com",
+                "valid": true
+            },
+            {
+                "description": "a valid newsgroup URI",
+                "data": "news:comp.infosystems.www.servers.unix",
+                "valid": true
+            },
+            {
+                "description": "a valid tel URI",
+                "data": "tel:+1-816-555-1212",
+                "valid": true
+            },
+            {
+                "description": "a valid URN",
+                "data": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2",
+                "valid": true
+            },
+            {
+                "description": "an invalid protocol-relative URI Reference",
+                "data": "//foo.bar/?baz=qux#quux",
+                "valid": false
+            },
+            {
+                "description": "an invalid relative URI Reference",
+                "data": "/abc",
+                "valid": false
+            },
+            {
+                "description": "an invalid URI",
+                "data": "\\\\WINDOWS\\fileshare",
+                "valid": false
+            },
+            {
+                "description": "an invalid URI though valid URI reference",
+                "data": "abc",
+                "valid": false
+            },
+            {
+                "description": "an invalid URI with spaces",
+                "data": "http:// shouldfail.com",
+                "valid": false
+            },
+            {
+                "description": "an invalid URI with spaces and missing scheme",
+                "data": ":// should fail",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "validation of e-mail addresses",
+        "schema": {"format": "email"},
+        "tests": [
+            {
+                "description": "a valid e-mail address",
+                "data": "joe.bloggs@example.com",
+                "valid": true
+            },
+            {
+                "description": "an invalid e-mail address",
+                "data": "2962",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "validation of IP addresses",
+        "schema": {"format": "ipv4"},
+        "tests": [
+            {
+                "description": "a valid IP address",
+                "data": "192.168.0.1",
+                "valid": true
+            },
+            {
+                "description": "an IP address with too many components",
+                "data": "127.0.0.0.1",
+                "valid": false
+            },
+            {
+                "description": "an IP address with out-of-range values",
+                "data": "256.256.256.256",
+                "valid": false
+            },
+            {
+                "description": "an IP address without 4 components",
+                "data": "127.0",
+                "valid": false
+            },
+            {
+                "description": "an IP address as an integer",
+                "data": "0x7f000001",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "validation of IPv6 addresses",
+        "schema": {"format": "ipv6"},
+        "tests": [
+            {
+                "description": "a valid IPv6 address",
+                "data": "::1",
+                "valid": true
+            },
+            {
+                "description": "an IPv6 address with out-of-range values",
+                "data": "12345::",
+                "valid": false
+            },
+            {
+                "description": "an IPv6 address with too many components",
+                "data": "1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1",
+                "valid": false
+            },
+            {
+                "description": "an IPv6 address containing illegal characters",
+                "data": "::laptop",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "validation of host names",
+        "schema": {"format": "hostname"},
+        "tests": [
+            {
+                "description": "a valid host name",
+                "data": "www.example.com",
+                "valid": true
+            },
+            {
+                "description": "a host name starting with an illegal character",
+                "data": "-a-host-name-that-starts-with--",
+                "valid": false
+            },
+            {
+                "description": "a host name containing illegal characters",
+                "data": "not_a_valid_host_name",
+                "valid": false
+            },
+            {
+                "description": "a host name with a component too long",
+                "data": "a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component",
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/optional/zeroTerminatedFloats.json

@@ -0,0 +1,15 @@
+[
+    {
+        "description": "some languages do not distinguish between different types of numeric value",
+        "schema": {
+            "type": "integer"
+        },
+        "tests": [
+            {
+                "description": "a float is not an integer even without fractional part",
+                "data": 1.0,
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/pattern.json

@@ -14,34 +14,9 @@
                 "valid": false
             },
             {
-                "description": "ignores booleans",
+                "description": "ignores non-strings",
                 "data": true,
                 "valid": true
-            },
-            {
-                "description": "ignores integers",
-                "data": 123,
-                "valid": true
-            },
-            {
-                "description": "ignores floats",
-                "data": 1.0,
-                "valid": true
-            },
-            {
-                "description": "ignores objects",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "ignores arrays",
-                "data": [],
-                "valid": true
-            },
-            {
-                "description": "ignores null",
-                "data": null,
-                "valid": true
             }
         ]
     },

test/JSON-Schema-Test-Suite/tests/draft4/patternProperties.json

@@ -30,12 +30,12 @@
             },
             {
                 "description": "ignores arrays",
-                "data": ["foo"],
+                "data": [],
                 "valid": true
             },
             {
                 "description": "ignores strings",
-                "data": "foo",
+                "data": "",
                 "valid": true
             },
             {
@@ -116,41 +116,5 @@
                 "valid": false
             }
         ]
-    },
-    {
-        "description": "patternProperties with boolean schemas",
-        "schema": {
-            "patternProperties": {
-                "f.*": true,
-                "b.*": false
-            }
-        },
-        "tests": [
-            {
-                "description": "object with property matching schema true is valid",
-                "data": {"foo": 1},
-                "valid": true
-            },
-            {
-                "description": "object with property matching schema false is invalid",
-                "data": {"bar": 2},
-                "valid": false
-            },
-            {
-                "description": "object with both properties is invalid",
-                "data": {"foo": 1, "bar": 2},
-                "valid": false
-            },
-            {
-                "description": "object with a property matching both true and false is invalid",
-                "data": {"foobar":1},
-                "valid": false
-            },
-            {
-                "description": "empty object is valid",
-                "data": {},
-                "valid": true
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/properties.json

@@ -93,75 +93,5 @@
                 "valid": false
             }
         ]
-    },
-    {
-        "description": "properties with boolean schema",
-        "schema": {
-            "properties": {
-                "foo": true,
-                "bar": false
-            }
-        },
-        "tests": [
-            {
-                "description": "no property present is valid",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "only 'true' property present is valid",
-                "data": {"foo": 1},
-                "valid": true
-            },
-            {
-                "description": "only 'false' property present is invalid",
-                "data": {"bar": 2},
-                "valid": false
-            },
-            {
-                "description": "both properties present is invalid",
-                "data": {"foo": 1, "bar": 2},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "properties with escaped characters",
-        "schema": {
-            "properties": {
-                "foo\nbar": {"type": "number"},
-                "foo\"bar": {"type": "number"},
-                "foo\\bar": {"type": "number"},
-                "foo\rbar": {"type": "number"},
-                "foo\tbar": {"type": "number"},
-                "foo\fbar": {"type": "number"}
-            }
-        },
-        "tests": [
-            {
-                "description": "object with all numbers is valid",
-                "data": {
-                    "foo\nbar": 1,
-                    "foo\"bar": 1,
-                    "foo\\bar": 1,
-                    "foo\rbar": 1,
-                    "foo\tbar": 1,
-                    "foo\fbar": 1
-                },
-                "valid": true
-            },
-            {
-                "description": "object with strings is invalid",
-                "data": {
-                    "foo\nbar": "1",
-                    "foo\"bar": "1",
-                    "foo\\bar": "1",
-                    "foo\rbar": "1",
-                    "foo\tbar": "1",
-                    "foo\fbar": "1"
-                },
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/ref.json

@@ -0,0 +1,300 @@
+[
+    {
+        "description": "root pointer ref",
+        "schema": {
+            "properties": {
+                "foo": {"$ref": "#"}
+            },
+            "additionalProperties": false
+        },
+        "tests": [
+            {
+                "description": "match",
+                "data": {"foo": false},
+                "valid": true
+            },
+            {
+                "description": "recursive match",
+                "data": {"foo": {"foo": false}},
+                "valid": true
+            },
+            {
+                "description": "mismatch",
+                "data": {"bar": false},
+                "valid": false
+            },
+            {
+                "description": "recursive mismatch",
+                "data": {"foo": {"bar": false}},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "relative pointer ref to object",
+        "schema": {
+            "properties": {
+                "foo": {"type": "integer"},
+                "bar": {"$ref": "#/properties/foo"}
+            }
+        },
+        "tests": [
+            {
+                "description": "match",
+                "data": {"bar": 3},
+                "valid": true
+            },
+            {
+                "description": "mismatch",
+                "data": {"bar": true},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "relative pointer ref to array",
+        "schema": {
+            "items": [
+                {"type": "integer"},
+                {"$ref": "#/items/0"}
+            ]
+        },
+        "tests": [
+            {
+                "description": "match array",
+                "data": [1, 2],
+                "valid": true
+            },
+            {
+                "description": "mismatch array",
+                "data": [1, "foo"],
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "escaped pointer ref",
+        "schema": {
+            "tilda~field": {"type": "integer"},
+            "slash/field": {"type": "integer"},
+            "percent%field": {"type": "integer"},
+            "properties": {
+                "tilda": {"$ref": "#/tilda~0field"},
+                "slash": {"$ref": "#/slash~1field"},
+                "percent": {"$ref": "#/percent%25field"}
+            }
+        },
+        "tests": [
+            {
+                "description": "slash invalid",
+                "data": {"slash": "aoeu"},
+                "valid": false
+            },
+            {
+                "description": "tilda invalid",
+                "data": {"tilda": "aoeu"},
+                "valid": false
+            },
+            {
+                "description": "percent invalid",
+                "data": {"percent": "aoeu"},
+                "valid": false
+            },
+            {
+                "description": "slash valid",
+                "data": {"slash": 123},
+                "valid": true
+            },
+            {
+                "description": "tilda valid",
+                "data": {"tilda": 123},
+                "valid": true
+            },
+            {
+                "description": "percent valid",
+                "data": {"percent": 123},
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "nested refs",
+        "schema": {
+            "definitions": {
+                "a": {"type": "integer"},
+                "b": {"$ref": "#/definitions/a"},
+                "c": {"$ref": "#/definitions/b"}
+            },
+            "$ref": "#/definitions/c"
+        },
+        "tests": [
+            {
+                "description": "nested ref valid",
+                "data": 5,
+                "valid": true
+            },
+            {
+                "description": "nested ref invalid",
+                "data": "a",
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "ref overrides any sibling keywords",
+        "schema": {
+            "definitions": {
+                "reffed": {
+                    "type": "array"
+                }
+            },
+            "properties": {
+                "foo": {
+                    "$ref": "#/definitions/reffed",
+                    "maxItems": 2
+                }
+            }
+        },
+        "tests": [
+            {
+                "description": "ref valid",
+                "data": { "foo": [] },
+                "valid": true
+            },
+            {
+                "description": "ref valid, maxItems ignored",
+                "data": { "foo": [ 1, 2, 3] },
+                "valid": true
+            },
+            {
+                "description": "ref invalid",
+                "data": { "foo": "string" },
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "remote ref, containing refs itself",
+        "schema": {"$ref": "http://json-schema.org/draft-04/schema#"},
+        "tests": [
+            {
+                "description": "remote ref valid",
+                "data": {"minLength": 1},
+                "valid": true
+            },
+            {
+                "description": "remote ref invalid",
+                "data": {"minLength": -1},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "property named $ref that is not a reference",
+        "schema": {
+            "properties": {
+                "$ref": {"type": "string"}
+            }
+        },
+        "tests": [
+            {
+                "description": "property named $ref valid",
+                "data": {"$ref": "a"},
+                "valid": true
+            },
+            {
+                "description": "property named $ref invalid",
+                "data": {"$ref": 2},
+                "valid": false
+            }
+        ]
+    },
+    {
+        "description": "Recursive references between schemas",
+        "schema": {
+            "id": "http://localhost:1234/tree",
+            "description": "tree of nodes",
+            "type": "object",
+            "properties": {
+                "meta": {"type": "string"},
+                "nodes": {
+                    "type": "array",
+                    "items": {"$ref": "node"}
+                }
+            },
+            "required": ["meta", "nodes"],
+            "definitions": {
+                "node": {
+                    "id": "http://localhost:1234/node",
+                    "description": "node",
+                    "type": "object",
+                    "properties": {
+                        "value": {"type": "number"},
+                        "subtree": {"$ref": "tree"}
+                    },
+                    "required": ["value"]
+                }
+            }
+        },
+        "tests": [
+            {
+                "description": "valid tree",
+                "data": {
+                    "meta": "root",
+                    "nodes": [
+                        {
+                            "value": 1,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [
+                                    {"value": 1.1},
+                                    {"value": 1.2}
+                                ]
+                            }
+                        },
+                        {
+                            "value": 2,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [
+                                    {"value": 2.1},
+                                    {"value": 2.2}
+                                ]
+                            }
+                        }
+                    ]
+                },
+                "valid": true
+            },
+            {
+                "description": "invalid tree",
+                "data": {
+                    "meta": "root",
+                    "nodes": [
+                        {
+                            "value": 1,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [
+                                    {"value": "string is invalid"},
+                                    {"value": 1.2}
+                                ]
+                            }
+                        },
+                        {
+                            "value": 2,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [
+                                    {"value": 2.1},
+                                    {"value": 2.2}
+                                ]
+                            }
+                        }
+                    ]
+                },
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/refRemote.json

@@ -52,9 +52,9 @@
     {
         "description": "base URI change",
         "schema": {
-            "$id": "http://localhost:1234/",
+            "id": "http://localhost:1234/",
             "items": {
-                "$id": "baseUriChange/",
+                "id": "folder/",
                 "items": {"$ref": "folderInteger.json"}
             }
         },
@@ -74,14 +74,14 @@
     {
         "description": "base URI change - change folder",
         "schema": {
-            "$id": "http://localhost:1234/scope_change_defs1.json",
+            "id": "http://localhost:1234/scope_change_defs1.json",
             "type" : "object",
             "properties": {
                 "list": {"$ref": "#/definitions/baz"}
             },
             "definitions": {
                 "baz": {
-                    "$id": "baseUriChangeFolder/",
+                    "id": "folder/",
                     "type": "array",
                     "items": {"$ref": "folderInteger.json"}
                 }
@@ -103,14 +103,14 @@
     {
         "description": "base URI change - change folder in subschema",
         "schema": {
-            "$id": "http://localhost:1234/scope_change_defs2.json",
+            "id": "http://localhost:1234/scope_change_defs2.json",
             "type" : "object",
             "properties": {
                 "list": {"$ref": "#/definitions/baz/definitions/bar"}
             },
             "definitions": {
                 "baz": {
-                    "$id": "baseUriChangeFolderInSubschema/",
+                    "id": "folder/",
                     "definitions": {
                         "bar": {
                             "type": "array",
@@ -136,7 +136,7 @@
     {
         "description": "root ref in remote ref",
         "schema": {
-            "$id": "http://localhost:1234/object",
+            "id": "http://localhost:1234/object",
             "type": "object",
             "properties": {
                 "name": {"$ref": "name.json#/definitions/orNull"}
@@ -167,30 +167,5 @@
                 "valid": false
             }
         ]
-    },
-    {
-        "description": "remote ref with ref to definitions",
-        "schema": {
-            "$id": "http://localhost:1234/schema-remote-ref-ref-defs1.json",
-            "allOf": [
-                { "$ref": "ref-and-definitions.json" }
-            ]
-        },
-        "tests": [
-            {
-                "description": "invalid",
-                "data": {
-                    "bar": 1
-                },
-                "valid": false
-            },
-            {
-                "description": "valid",
-                "data": {
-                    "bar": "a"
-                },
-                "valid": true
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/required.json

@@ -0,0 +1,54 @@
+[
+    {
+        "description": "required validation",
+        "schema": {
+            "properties": {
+                "foo": {},
+                "bar": {}
+            },
+            "required": ["foo"]
+        },
+        "tests": [
+            {
+                "description": "present required property is valid",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "non-present required property is invalid",
+                "data": {"bar": 1},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required default validation",
+        "schema": {
+            "properties": {
+                "foo": {}
+            }
+        },
+        "tests": [
+            {
+                "description": "not required by default",
+                "data": {},
+                "valid": true
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft4/type.json

@@ -54,11 +54,6 @@
                 "data": 1,
                 "valid": true
             },
-            {
-                "description": "a float with zero fractional part is a number (and an integer)",
-                "data": 1.0,
-                "valid": true
-            },
             {
                 "description": "a float is a number",
                 "data": 1.1,
@@ -120,11 +115,6 @@
                 "data": "1",
                 "valid": true
             },
-            {
-                "description": "an empty string is still a string",
-                "data": "",
-                "valid": true
-            },
             {
                 "description": "an object is not a string",
                 "data": {},
@@ -238,11 +228,6 @@
                 "data": 1,
                 "valid": false
             },
-            {
-                "description": "zero is not a boolean",
-                "data": 0,
-                "valid": false
-            },
             {
                 "description": "a float is not a boolean",
                 "data": 1.1,
@@ -253,11 +238,6 @@
                 "data": "foo",
                 "valid": false
             },
-            {
-                "description": "an empty string is not a boolean",
-                "data": "",
-                "valid": false
-            },
             {
                 "description": "an object is not a boolean",
                 "data": {},
@@ -269,15 +249,10 @@
                 "valid": false
             },
             {
-                "description": "true is a boolean",
+                "description": "a boolean is a boolean",
                 "data": true,
                 "valid": true
             },
-            {
-                "description": "false is a boolean",
-                "data": false,
-                "valid": true
-            },
             {
                 "description": "null is not a boolean",
                 "data": null,
@@ -299,21 +274,11 @@
                 "data": 1.1,
                 "valid": false
             },
-            {
-                "description": "zero is not null",
-                "data": 0,
-                "valid": false
-            },
             {
                 "description": "a string is not null",
                 "data": "foo",
                 "valid": false
             },
-            {
-                "description": "an empty string is not null",
-                "data": "",
-                "valid": false
-            },
             {
                 "description": "an object is not null",
                 "data": {},
@@ -325,15 +290,10 @@
                 "valid": false
             },
             {
-                "description": "true is not null",
+                "description": "a boolean is not null",
                 "data": true,
                 "valid": false
             },
-            {
-                "description": "false is not null",
-                "data": false,
-                "valid": false
-            },
             {
                 "description": "null is null",
                 "data": null,
@@ -381,89 +341,5 @@
                 "valid": false
             }
         ]
-    },
-    {
-        "description": "type as array with one item",
-        "schema": {
-            "type": ["string"]
-        },
-        "tests": [
-            {
-                "description": "string is valid",
-                "data": "foo",
-                "valid": true
-            },
-            {
-                "description": "number is invalid",
-                "data": 123,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "type: array or object",
-        "schema": {
-            "type": ["array", "object"]
-        },
-        "tests": [
-            {
-                "description": "array is valid",
-                "data": [1,2,3],
-                "valid": true
-            },
-            {
-                "description": "object is valid",
-                "data": {"foo": 123},
-                "valid": true
-            },
-            {
-                "description": "number is invalid",
-                "data": 123,
-                "valid": false
-            },
-            {
-                "description": "string is invalid",
-                "data": "foo",
-                "valid": false
-            },
-            {
-                "description": "null is invalid",
-                "data": null,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "type: array, object or null",
-        "schema": {
-            "type": ["array", "object", "null"]
-        },
-        "tests": [
-            {
-                "description": "array is valid",
-                "data": [1,2,3],
-                "valid": true
-            },
-            {
-                "description": "object is valid",
-                "data": {"foo": 123},
-                "valid": true
-            },
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "number is invalid",
-                "data": 123,
-                "valid": false
-            },
-            {
-                "description": "string is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
     }
 ]

test/JSON-Schema-Test-Suite/tests/draft4/uniqueItems.json

@@ -0,0 +1,79 @@
+[
+    {
+        "description": "uniqueItems validation",
+        "schema": {"uniqueItems": true},
+        "tests": [
+            {
+                "description": "unique array of integers is valid",
+                "data": [1, 2],
+                "valid": true
+            },
+            {
+                "description": "non-unique array of integers is invalid",
+                "data": [1, 1],
+                "valid": false
+            },
+            {
+                "description": "numbers are unique if mathematically unequal",
+                "data": [1.0, 1.00, 1],
+                "valid": false
+            },
+            {
+                "description": "unique array of objects is valid",
+                "data": [{"foo": "bar"}, {"foo": "baz"}],
+                "valid": true
+            },
+            {
+                "description": "non-unique array of objects is invalid",
+                "data": [{"foo": "bar"}, {"foo": "bar"}],
+                "valid": false
+            },
+            {
+                "description": "unique array of nested objects is valid",
+                "data": [
+                    {"foo": {"bar" : {"baz" : true}}},
+                    {"foo": {"bar" : {"baz" : false}}}
+                ],
+                "valid": true
+            },
+            {
+                "description": "non-unique array of nested objects is invalid",
+                "data": [
+                    {"foo": {"bar" : {"baz" : true}}},
+                    {"foo": {"bar" : {"baz" : true}}}
+                ],
+                "valid": false
+            },
+            {
+                "description": "unique array of arrays is valid",
+                "data": [["foo"], ["bar"]],
+                "valid": true
+            },
+            {
+                "description": "non-unique array of arrays is invalid",
+                "data": [["foo"], ["foo"]],
+                "valid": false
+            },
+            {
+                "description": "1 and true are unique",
+                "data": [1, true],
+                "valid": true
+            },
+            {
+                "description": "0 and false are unique",
+                "data": [0, false],
+                "valid": true
+            },
+            {
+                "description": "unique heterogeneous types are valid",
+                "data": [{}, [1], true, null, 1],
+                "valid": true
+            },
+            {
+                "description": "non-unique heterogeneous types are invalid",
+                "data": [{}, [1], true, null, {}, 1],
+                "valid": false
+            }
+        ]
+    }
+]

test/JSON-Schema-Test-Suite/tests/draft7/allOf.json

@@ -1,294 +0,0 @@
-[
-    {
-        "description": "allOf",
-        "schema": {
-            "allOf": [
-                {
-                    "properties": {
-                        "bar": {"type": "integer"}
-                    },
-                    "required": ["bar"]
-                },
-                {
-                    "properties": {
-                        "foo": {"type": "string"}
-                    },
-                    "required": ["foo"]
-                }
-            ]
-        },
-        "tests": [
-            {
-                "description": "allOf",
-                "data": {"foo": "baz", "bar": 2},
-                "valid": true
-            },
-            {
-                "description": "mismatch second",
-                "data": {"foo": "baz"},
-                "valid": false
-            },
-            {
-                "description": "mismatch first",
-                "data": {"bar": 2},
-                "valid": false
-            },
-            {
-                "description": "wrong type",
-                "data": {"foo": "baz", "bar": "quux"},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf with base schema",
-        "schema": {
-            "properties": {"bar": {"type": "integer"}},
-            "required": ["bar"],
-            "allOf" : [
-                {
-                    "properties": {
-                        "foo": {"type": "string"}
-                    },
-                    "required": ["foo"]
-                },
-                {
-                    "properties": {
-                        "baz": {"type": "null"}
-                    },
-                    "required": ["baz"]
-                }
-            ]
-        },
-        "tests": [
-            {
-                "description": "valid",
-                "data": {"foo": "quux", "bar": 2, "baz": null},
-                "valid": true
-            },
-            {
-                "description": "mismatch base schema",
-                "data": {"foo": "quux", "baz": null},
-                "valid": false
-            },
-            {
-                "description": "mismatch first allOf",
-                "data": {"bar": 2, "baz": null},
-                "valid": false
-            },
-            {
-                "description": "mismatch second allOf",
-                "data": {"foo": "quux", "bar": 2},
-                "valid": false
-            },
-            {
-                "description": "mismatch both",
-                "data": {"bar": 2},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf simple types",
-        "schema": {
-            "allOf": [
-                {"maximum": 30},
-                {"minimum": 20}
-            ]
-        },
-        "tests": [
-            {
-                "description": "valid",
-                "data": 25,
-                "valid": true
-            },
-            {
-                "description": "mismatch one",
-                "data": 35,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf with boolean schemas, all true",
-        "schema": {"allOf": [true, true]},
-        "tests": [
-            {
-                "description": "any value is valid",
-                "data": "foo",
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "allOf with boolean schemas, some false",
-        "schema": {"allOf": [true, false]},
-        "tests": [
-            {
-                "description": "any value is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf with boolean schemas, all false",
-        "schema": {"allOf": [false, false]},
-        "tests": [
-            {
-                "description": "any value is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf with one empty schema",
-        "schema": {
-            "allOf": [
-                {}
-            ]
-        },
-        "tests": [
-            {
-                "description": "any data is valid",
-                "data": 1,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "allOf with two empty schemas",
-        "schema": {
-            "allOf": [
-                {},
-                {}
-            ]
-        },
-        "tests": [
-            {
-                "description": "any data is valid",
-                "data": 1,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "allOf with the first empty schema",
-        "schema": {
-            "allOf": [
-                {},
-                { "type": "number" }
-            ]
-        },
-        "tests": [
-            {
-                "description": "number is valid",
-                "data": 1,
-                "valid": true
-            },
-            {
-                "description": "string is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf with the last empty schema",
-        "schema": {
-            "allOf": [
-                { "type": "number" },
-                {}
-            ]
-        },
-        "tests": [
-            {
-                "description": "number is valid",
-                "data": 1,
-                "valid": true
-            },
-            {
-                "description": "string is invalid",
-                "data": "foo",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "nested allOf, to check validation semantics",
-        "schema": {
-            "allOf": [
-                {
-                    "allOf": [
-                        {
-                            "type": "null"
-                        }
-                    ]
-                }
-            ]
-        },
-        "tests": [
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "anything non-null is invalid",
-                "data": 123,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "allOf combined with anyOf, oneOf",
-        "schema": {
-            "allOf": [ { "multipleOf": 2 } ],
-            "anyOf": [ { "multipleOf": 3 } ],
-            "oneOf": [ { "multipleOf": 5 } ]
-        },
-        "tests": [
-            {
-                "description": "allOf: false, anyOf: false, oneOf: false",
-                "data": 1,
-                "valid": false
-            },
-            {
-                "description": "allOf: false, anyOf: false, oneOf: true",
-                "data": 5,
-                "valid": false
-            },
-            {
-                "description": "allOf: false, anyOf: true, oneOf: false",
-                "data": 3,
-                "valid": false
-            },
-            {
-                "description": "allOf: false, anyOf: true, oneOf: true",
-                "data": 15,
-                "valid": false
-            },
-            {
-                "description": "allOf: true, anyOf: false, oneOf: false",
-                "data": 2,
-                "valid": false
-            },
-            {
-                "description": "allOf: true, anyOf: false, oneOf: true",
-                "data": 10,
-                "valid": false
-            },
-            {
-                "description": "allOf: true, anyOf: true, oneOf: false",
-                "data": 6,
-                "valid": false
-            },
-            {
-                "description": "allOf: true, anyOf: true, oneOf: true",
-                "data": 30,
-                "valid": true
-            }
-        ]
-    }
-]

test/JSON-Schema-Test-Suite/tests/draft7/boolean_schema.json

@@ -1,104 +0,0 @@
-[
-    {
-        "description": "boolean schema 'true'",
-        "schema": true,
-        "tests": [
-            {
-                "description": "number is valid",
-                "data": 1,
-                "valid": true
-            },
-            {
-                "description": "string is valid",
-                "data": "foo",
-                "valid": true
-            },
-            {
-                "description": "boolean true is valid",
-                "data": true,
-                "valid": true
-            },
-            {
-                "description": "boolean false is valid",
-                "data": false,
-                "valid": true
-            },
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "object is valid",
-                "data": {"foo": "bar"},
-                "valid": true
-            },
-            {
-                "description": "empty object is valid",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "array is valid",
-                "data": ["foo"],
-                "valid": true
-            },
-            {
-                "description": "empty array is valid",
-                "data": [],
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "boolean schema 'false'",
-        "schema": false,
-        "tests": [
-            {
-                "description": "number is invalid",
-                "data": 1,
-                "valid": false
-            },
-            {
-                "description": "string is invalid",
-                "data": "foo",
-                "valid": false
-            },
-            {
-                "description": "boolean true is invalid",
-                "data": true,
-                "valid": false
-            },
-            {
-                "description": "boolean false is invalid",
-                "data": false,
-                "valid": false
-            },
-            {
-                "description": "null is invalid",
-                "data": null,
-                "valid": false
-            },
-            {
-                "description": "object is invalid",
-                "data": {"foo": "bar"},
-                "valid": false
-            },
-            {
-                "description": "empty object is invalid",
-                "data": {},
-                "valid": false
-            },
-            {
-                "description": "array is invalid",
-                "data": ["foo"],
-                "valid": false
-            },
-            {
-                "description": "empty array is invalid",
-                "data": [],
-                "valid": false
-            }
-        ]
-    }
-]

test/JSON-Schema-Test-Suite/tests/draft7/const.json

@@ -1,342 +0,0 @@
-[
-    {
-        "description": "const validation",
-        "schema": {"const": 2},
-        "tests": [
-            {
-                "description": "same value is valid",
-                "data": 2,
-                "valid": true
-            },
-            {
-                "description": "another value is invalid",
-                "data": 5,
-                "valid": false
-            },
-            {
-                "description": "another type is invalid",
-                "data": "a",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with object",
-        "schema": {"const": {"foo": "bar", "baz": "bax"}},
-        "tests": [
-            {
-                "description": "same object is valid",
-                "data": {"foo": "bar", "baz": "bax"},
-                "valid": true
-            },
-            {
-                "description": "same object with different property order is valid",
-                "data": {"baz": "bax", "foo": "bar"},
-                "valid": true
-            },
-            {
-                "description": "another object is invalid",
-                "data": {"foo": "bar"},
-                "valid": false
-            },
-            {
-                "description": "another type is invalid",
-                "data": [1, 2],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with array",
-        "schema": {"const": [{ "foo": "bar" }]},
-        "tests": [
-            {
-                "description": "same array is valid",
-                "data": [{"foo": "bar"}],
-                "valid": true
-            },
-            {
-                "description": "another array item is invalid",
-                "data": [2],
-                "valid": false
-            },
-            {
-                "description": "array with additional items is invalid",
-                "data": [1, 2, 3],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with null",
-        "schema": {"const": null},
-        "tests": [
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "not null is invalid",
-                "data": 0,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with false does not match 0",
-        "schema": {"const": false},
-        "tests": [
-            {
-                "description": "false is valid",
-                "data": false,
-                "valid": true
-            },
-            {
-                "description": "integer zero is invalid",
-                "data": 0,
-                "valid": false
-            },
-            {
-                "description": "float zero is invalid",
-                "data": 0.0,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with true does not match 1",
-        "schema": {"const": true},
-        "tests": [
-            {
-                "description": "true is valid",
-                "data": true,
-                "valid": true
-            },
-            {
-                "description": "integer one is invalid",
-                "data": 1,
-                "valid": false
-            },
-            {
-                "description": "float one is invalid",
-                "data": 1.0,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with [false] does not match [0]",
-        "schema": {"const": [false]},
-        "tests": [
-            {
-                "description": "[false] is valid",
-                "data": [false],
-                "valid": true
-            },
-            {
-                "description": "[0] is invalid",
-                "data": [0],
-                "valid": false
-            },
-            {
-                "description": "[0.0] is invalid",
-                "data": [0.0],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with [true] does not match [1]",
-        "schema": {"const": [true]},
-        "tests": [
-            {
-                "description": "[true] is valid",
-                "data": [true],
-                "valid": true
-            },
-            {
-                "description": "[1] is invalid",
-                "data": [1],
-                "valid": false
-            },
-            {
-                "description": "[1.0] is invalid",
-                "data": [1.0],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with {\"a\": false} does not match {\"a\": 0}",
-        "schema": {"const": {"a": false}},
-        "tests": [
-            {
-                "description": "{\"a\": false} is valid",
-                "data": {"a": false},
-                "valid": true
-            },
-            {
-                "description": "{\"a\": 0} is invalid",
-                "data": {"a": 0},
-                "valid": false
-            },
-            {
-                "description": "{\"a\": 0.0} is invalid",
-                "data": {"a": 0.0},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with {\"a\": true} does not match {\"a\": 1}",
-        "schema": {"const": {"a": true}},
-        "tests": [
-            {
-                "description": "{\"a\": true} is valid",
-                "data": {"a": true},
-                "valid": true
-            },
-            {
-                "description": "{\"a\": 1} is invalid",
-                "data": {"a": 1},
-                "valid": false
-            },
-            {
-                "description": "{\"a\": 1.0} is invalid",
-                "data": {"a": 1.0},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with 0 does not match other zero-like types",
-        "schema": {"const": 0},
-        "tests": [
-            {
-                "description": "false is invalid",
-                "data": false,
-                "valid": false
-            },
-            {
-                "description": "integer zero is valid",
-                "data": 0,
-                "valid": true
-            },
-            {
-                "description": "float zero is valid",
-                "data": 0.0,
-                "valid": true
-            },
-            {
-                "description": "empty object is invalid",
-                "data": {},
-                "valid": false
-            },
-            {
-                "description": "empty array is invalid",
-                "data": [],
-                "valid": false
-            },
-            {
-                "description": "empty string is invalid",
-                "data": "",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "const with 1 does not match true",
-        "schema": {"const": 1},
-        "tests": [
-            {
-                "description": "true is invalid",
-                "data": true,
-                "valid": false
-            },
-            {
-                "description": "integer one is valid",
-                "data": 1,
-                "valid": true
-            },
-            {
-                "description": "float one is valid",
-                "data": 1.0,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "const with -2.0 matches integer and float types",
-        "schema": {"const": -2.0},
-        "tests": [
-            {
-                "description": "integer -2 is valid",
-                "data": -2,
-                "valid": true
-            },
-            {
-                "description": "integer 2 is invalid",
-                "data": 2,
-                "valid": false
-            },
-            {
-                "description": "float -2.0 is valid",
-                "data": -2.0,
-                "valid": true
-            },
-            {
-                "description": "float 2.0 is invalid",
-                "data": 2.0,
-                "valid": false
-            },
-            {
-                "description": "float -2.00001 is invalid",
-                "data": -2.00001,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "float and integers are equal up to 64-bit representation limits",
-        "schema": {"const": 9007199254740992},
-        "tests": [
-            {
-                "description": "integer is valid",
-                "data": 9007199254740992,
-                "valid": true
-            },
-            {
-                "description": "integer minus one is invalid",
-                "data": 9007199254740991,
-                "valid": false
-            },
-            {
-                "description": "float is valid",
-                "data": 9007199254740992.0,
-                "valid": true
-            },
-            {
-                "description": "float minus one is invalid",
-                "data": 9007199254740991.0,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "nul characters in strings",
-        "schema": { "const": "hello\u0000there" },
-        "tests": [
-            {
-                "description": "match string with nul",
-                "data": "hello\u0000there",
-                "valid": true
-            },
-            {
-                "description": "do not match string lacking nul",
-                "data": "hellothere",
-                "valid": false
-            }
-        ]
-    }
-]

test/JSON-Schema-Test-Suite/tests/draft7/contains.json

@@ -1,150 +0,0 @@
-[
-    {
-        "description": "contains keyword validation",
-        "schema": {
-            "contains": {"minimum": 5}
-        },
-        "tests": [
-            {
-                "description": "array with item matching schema (5) is valid",
-                "data": [3, 4, 5],
-                "valid": true
-            },
-            {
-                "description": "array with item matching schema (6) is valid",
-                "data": [3, 4, 6],
-                "valid": true
-            },
-            {
-                "description": "array with two items matching schema (5, 6) is valid",
-                "data": [3, 4, 5, 6],
-                "valid": true
-            },
-            {
-                "description": "array without items matching schema is invalid",
-                "data": [2, 3, 4],
-                "valid": false
-            },
-            {
-                "description": "empty array is invalid",
-                "data": [],
-                "valid": false
-            },
-            {
-                "description": "not array is valid",
-                "data": {},
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "contains keyword with const keyword",
-        "schema": {
-            "contains": { "const": 5 }
-        },
-        "tests": [
-            {
-                "description": "array with item 5 is valid",
-                "data": [3, 4, 5],
-                "valid": true
-            },
-            {
-                "description": "array with two items 5 is valid",
-                "data": [3, 4, 5, 5],
-                "valid": true
-            },
-            {
-                "description": "array without item 5 is invalid",
-                "data": [1, 2, 3, 4],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "contains keyword with boolean schema true",
-        "schema": {"contains": true},
-        "tests": [
-            {
-                "description": "any non-empty array is valid",
-                "data": ["foo"],
-                "valid": true
-            },
-            {
-                "description": "empty array is invalid",
-                "data": [],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "contains keyword with boolean schema false",
-        "schema": {"contains": false},
-        "tests": [
-            {
-                "description": "any non-empty array is invalid",
-                "data": ["foo"],
-                "valid": false
-            },
-            {
-                "description": "empty array is invalid",
-                "data": [],
-                "valid": false
-            },
-            {
-                "description": "non-arrays are valid",
-                "data": "contains does not apply to strings",
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "items + contains",
-        "schema": {
-            "items": { "multipleOf": 2 },
-            "contains": { "multipleOf": 3 }
-        },
-        "tests": [
-            {
-                "description": "matches items, does not match contains",
-                "data": [ 2, 4, 8 ],
-                "valid": false
-            },
-            {
-                "description": "does not match items, matches contains",
-                "data": [ 3, 6, 9 ],
-                "valid": false
-            },
-            {
-                "description": "matches both items and contains",
-                "data": [ 6, 12 ],
-                "valid": true
-            },
-            {
-                "description": "matches neither items nor contains",
-                "data": [ 1, 5 ],
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "contains with false if subschema",
-        "schema": {
-            "contains": {
-                "if": false,
-                "else": true
-            }
-        },
-        "tests": [
-            {
-                "description": "any non-empty array is valid",
-                "data": ["foo"],
-                "valid": true
-            },
-            {
-                "description": "empty array is invalid",
-                "data": [],
-                "valid": false
-            }
-        ]
-    }
-]

test/JSON-Schema-Test-Suite/tests/draft7/dependencies.json

@@ -1,248 +0,0 @@
-[
-    {
-        "description": "dependencies",
-        "schema": {
-            "dependencies": {"bar": ["foo"]}
-        },
-        "tests": [
-            {
-                "description": "neither",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "nondependant",
-                "data": {"foo": 1},
-                "valid": true
-            },
-            {
-                "description": "with dependency",
-                "data": {"foo": 1, "bar": 2},
-                "valid": true
-            },
-            {
-                "description": "missing dependency",
-                "data": {"bar": 2},
-                "valid": false
-            },
-            {
-                "description": "ignores arrays",
-                "data": ["bar"],
-                "valid": true
-            },
-            {
-                "description": "ignores strings",
-                "data": "foobar",
-                "valid": true
-            },
-            {
-                "description": "ignores other non-objects",
-                "data": 12,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "dependencies with empty array",
-        "schema": {
-            "dependencies": {"bar": []}
-        },
-        "tests": [
-            {
-                "description": "empty object",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "object with one property",
-                "data": {"bar": 2},
-                "valid": true
-            },
-            {
-                "description": "non-object is valid",
-                "data": 1,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "multiple dependencies",
-        "schema": {
-            "dependencies": {"quux": ["foo", "bar"]}
-        },
-        "tests": [
-            {
-                "description": "neither",
-                "data": {},
-                "valid": true
-            },
-            {
-                "description": "nondependants",
-                "data": {"foo": 1, "bar": 2},
-                "valid": true
-            },
-            {
-                "description": "with dependencies",
-                "data": {"foo": 1, "bar": 2, "quux": 3},
-                "valid": true
-            },
-            {
-                "description": "missing dependency",
-                "data": {"foo": 1, "quux": 2},
-                "valid": false
-            },
-            {
-                "description": "missing other dependency",
-                "data": {"bar": 1, "quux": 2},
-                "valid": false
-            },
-            {
-                "description": "missing both dependencies",
-                "data": {"quux": 1},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "multiple dependencies subschema",
-        "schema": {
-            "dependencies": {
-                "bar": {
-                    "properties": {
-                        "foo": {"type": "integer"},
-                        "bar": {"type": "integer"}
-                    }
-                }
-            }
-        },
-        "tests": [
-            {
-                "description": "valid",
-                "data": {"foo": 1, "bar": 2},
-                "valid": true
-            },
-            {
-                "description": "no dependency",
-                "data": {"foo": "quux"},
-                "valid": true
-            },
-            {
-                "description": "wrong type",
-                "data": {"foo": "quux", "bar": 2},
-                "valid": false
-            },
-            {
-                "description": "wrong type other",
-                "data": {"foo": 2, "bar": "quux"},
-                "valid": false
-            },
-            {
-                "description": "wrong type both",
-                "data": {"foo": "quux", "bar": "quux"},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "dependencies with boolean subschemas",
-        "schema": {
-            "dependencies": {
-                "foo": true,
-                "bar": false
-            }
-        },
-        "tests": [
-            {
-                "description": "object with property having schema true is valid",
-                "data": {"foo": 1},
-                "valid": true
-            },
-            {
-                "description": "object with property having schema false is invalid",
-                "data": {"bar": 2},
-                "valid": false
-            },
-            {
-                "description": "object with both properties is invalid",
-                "data": {"foo": 1, "bar": 2},
-                "valid": false
-            },
-            {
-                "description": "empty object is valid",
-                "data": {},
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "dependencies with escaped characters",
-        "schema": {
-            "dependencies": {
-                "foo\nbar": ["foo\rbar"],
-                "foo\tbar": {
-                    "minProperties": 4
-                },
-                "foo'bar": {"required": ["foo\"bar"]},
-                "foo\"bar": ["foo'bar"]
-            }
-        },
-        "tests": [
-            {
-                "description": "valid object 1",
-                "data": {
-                    "foo\nbar": 1,
-                    "foo\rbar": 2
-                },
-                "valid": true
-            },
-            {
-                "description": "valid object 2",
-                "data": {
-                    "foo\tbar": 1,
-                    "a": 2,
-                    "b": 3,
-                    "c": 4
-                },
-                "valid": true
-            },
-            {
-                "description": "valid object 3",
-                "data": {
-                    "foo'bar": 1,
-                    "foo\"bar": 2
-                },
-                "valid": true
-            },
-            {
-                "description": "invalid object 1",
-                "data": {
-                    "foo\nbar": 1,
-                    "foo": 2
-                },
-                "valid": false
-            },
-            {
-                "description": "invalid object 2",
-                "data": {
-                    "foo\tbar": 1,
-                    "a": 2
-                },
-                "valid": false
-            },
-            {
-                "description": "invalid object 3",
-                "data": {
-                    "foo'bar": 1
-                },
-                "valid": false
-            },
-            {
-                "description": "invalid object 4",
-                "data": {
-                    "foo\"bar": 2
-                },
-                "valid": false
-            }
-        ]
-    }
-]

test/JSON-Schema-Test-Suite/tests/draft7/enum.json

@@ -1,236 +0,0 @@
-[
-    {
-        "description": "simple enum validation",
-        "schema": {"enum": [1, 2, 3]},
-        "tests": [
-            {
-                "description": "one of the enum is valid",
-                "data": 1,
-                "valid": true
-            },
-            {
-                "description": "something else is invalid",
-                "data": 4,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "heterogeneous enum validation",
-        "schema": {"enum": [6, "foo", [], true, {"foo": 12}]},
-        "tests": [
-            {
-                "description": "one of the enum is valid",
-                "data": [],
-                "valid": true
-            },
-            {
-                "description": "something else is invalid",
-                "data": null,
-                "valid": false
-            },
-            {
-                "description": "objects are deep compared",
-                "data": {"foo": false},
-                "valid": false
-            },
-            {
-                "description": "valid object matches",
-                "data": {"foo": 12},
-                "valid": true
-            },
-            {
-                "description": "extra properties in object is invalid",
-                "data": {"foo": 12, "boo": 42},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "heterogeneous enum-with-null validation",
-        "schema": { "enum": [6, null] },
-        "tests": [
-            {
-                "description": "null is valid",
-                "data": null,
-                "valid": true
-            },
-            {
-                "description": "number is valid",
-                "data": 6,
-                "valid": true
-            },
-            {
-                "description": "something else is invalid",
-                "data": "test",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "enums in properties",
-        "schema": {
-            "type":"object",
-            "properties": {
-                "foo": {"enum":["foo"]},
-                "bar": {"enum":["bar"]}
-            },
-            "required": ["bar"]
-        },
-        "tests": [
-            {
-                "description": "both properties are valid",
-                "data": {"foo":"foo", "bar":"bar"},
-                "valid": true
-            },
-            {
-                "description": "wrong foo value",
-                "data": {"foo":"foot", "bar":"bar"},
-                "valid": false
-            },
-            {
-                "description": "wrong bar value",
-                "data": {"foo":"foo", "bar":"bart"},
-                "valid": false
-            },
-            {
-                "description": "missing optional property is valid",
-                "data": {"bar":"bar"},
-                "valid": true
-            },
-            {
-                "description": "missing required property is invalid",
-                "data": {"foo":"foo"},
-                "valid": false
-            },
-            {
-                "description": "missing all properties is invalid",
-                "data": {},
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "enum with escaped characters",
-        "schema": {
-            "enum": ["foo\nbar", "foo\rbar"]
-        },
-        "tests": [
-            {
-                "description": "member 1 is valid",
-                "data": "foo\nbar",
-                "valid": true
-            },
-            {
-                "description": "member 2 is valid",
-                "data": "foo\rbar",
-                "valid": true
-            },
-            {
-                "description": "another string is invalid",
-                "data": "abc",
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "enum with false does not match 0",
-        "schema": {"enum": [false]},
-        "tests": [
-            {
-                "description": "false is valid",
-                "data": false,
-                "valid": true
-            },
-            {
-                "description": "integer zero is invalid",
-                "data": 0,
-                "valid": false
-            },
-            {
-                "description": "float zero is invalid",
-                "data": 0.0,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "enum with true does not match 1",
-        "schema": {"enum": [true]},
-        "tests": [
-            {
-                "description": "true is valid",
-                "data": true,
-                "valid": true
-            },
-            {
-                "description": "integer one is invalid",
-                "data": 1,
-                "valid": false
-            },
-            {
-                "description": "float one is invalid",
-                "data": 1.0,
-                "valid": false
-            }
-        ]
-    },
-    {
-        "description": "enum with 0 does not match false",
-        "schema": {"enum": [0]},
-        "tests": [
-            {
-                "description": "false is invalid",
-                "data": false,
-                "valid": false
-            },
-            {
-                "description": "integer zero is valid",
-                "data": 0,
-                "valid": true
-            },
-            {
-                "description": "float zero is valid",
-                "data": 0.0,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "enum with 1 does not match true",
-        "schema": {"enum": [1]},
-        "tests": [
-            {
-                "description": "true is invalid",
-                "data": true,
-                "valid": false
-            },
-            {
-                "description": "integer one is valid",
-                "data": 1,
-                "valid": true
-            },
-            {
-                "description": "float one is valid",
-                "data": 1.0,
-                "valid": true
-            }
-        ]
-    },
-    {
-        "description": "nul characters in strings",
-        "schema": { "enum": [ "hello\u0000there" ] },
-        "tests": [
-            {
-                "description": "match string with nul",
-                "data": "hello\u0000there",
-                "valid": true
-            },
-            {
-                "description": "do not match string lacking nul",
-                "data": "hellothere",
-                "valid": false
-            }
-        ]
-    }
-]

test/JSON-Schema-Test-Suite/tests/draft7/exclusiveMaximum.json

@@ -1,30 +0,0 @@
-[
-    {
-        "description": "exclusiveMaximum validation",
-        "schema": {
-            "exclusiveMaximum": 3.0
-        },
-        "tests": [
-            {
-                "description": "below the exclusiveMaximum is valid",
-                "data": 2.2,
-                "valid": true
-            },
-            {
-                "description": "boundary point is invalid",
-                "data": 3.0,
-                "valid": false
-            },
-            {
-                "description": "above the exclusiveMaximum is invalid",
-                "data": 3.5,
-                "valid": false
-            },
-            {
-                "description": "ignores non-numbers",
-                "data": "x",
-                "valid": true
-            }
-        ]
-    }
-]