JSON Schema Test Suite

https://github.com/json-schema-org/json-schema-test-suite
Admin
A comprehensive language-agnostic test suite that validates JSON Schema validator implementations...
Tokens:26,116
Snippets:377
Trust Score:9.2
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup the development environment

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Clone the repository and install necessary dependencies for running sanity checks.

```bash
# Clone the repository
git clone https://github.com/json-schema-org/JSON-Schema-Test-Suite.git
cd JSON-Schema-Test-Suite

# Install dependencies (for running sanity checks)
pip install jsonschema
python -m pip install tox
```

--------------------------------

### Compatibility String Examples

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

Examples of version constraints for the compatibility property.

```text
"compatibility": "7"              # draft-07 and later
"compatibility": "<=2019"         # 2019-09 and earlier
"compatibility": "6,<=2019"       # Between draft-06 and 2019-09
"compatibility": "=2020"          # 2020-12 only
"compatibility": "9999"           # Unreleased features
```

--------------------------------

### Save and Load Remote Schemas

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Practical examples for capturing remote schema output for use in validator setups.

```bash
# Get all remotes and save to file
bin/jsonschema_suite remotes > remotes.json

# Load remotes in a validator setup
REMOTES=$(bin/jsonschema_suite remotes)
```

--------------------------------

### Example Test Case

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-file-format.md

A concrete example of a test case object containing a schema and multiple validation tests.

```json
[
  {
    "description": "string type matches strings",
    "schema": {
      "type": "string"
    },
    "comment": "Basic type validation test",
    "tests": [
      {
        "description": "a string is a string",
        "data": "hello",
        "valid": true
      },
      {
        "description": "a number is not a string",
        "data": 123,
        "valid": false
      }
    ]
  }
]
```

--------------------------------

### Basic Format Output Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Provides a minimal structured response containing only the validation status.

```json
{
  "valid": true
}
```

--------------------------------

### Verbose Format Output Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Includes maximum detail, including schema context and evaluation traces for debugging.

```json
{
  "valid": false,
  "errors": [
    {
      "instanceLocation": "",
      "schemaLocation": "#",
      "keyword": "type",
      "absoluteKeywordLocation": "http://example.com/schema#",
      "error": "Instance is not of type \"string\"",
      "value": 123,
      "schema": { "type": "string" }
    }
  ],
  "annotations": [
    {
      "instanceLocation": "",
      "schemaLocation": "#",
      "keyword": "schema",
      "annotation": {}
    }
  ]
}
```

--------------------------------

### List Format Output Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Returns a flattened array of all individual validation results.

```json
[
  {
    "valid": true,
    "instanceLocation": "",
    "schemaLocation": "#",
    "keyword": "type",
    "annotation": "string"
  }
]
```

--------------------------------

### Fragment reference example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

References a specific anchor within a remote schema.

```json
{
  "$ref": "http://localhost:1234/integer.json#myAnchor"
}
```

--------------------------------

### Example Output Test Case

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-file-format.md

A sample JSON structure demonstrating a test case with a string schema and a corresponding test validating a string instance against flag and basic output formats.

```json
[
  {
    "description": "validates and produces correct output",
    "schema": {
      "type": "string"
    },
    "tests": [
      {
        "description": "valid string produces correct output",
        "data": "hello",
        "output": {
          "flag": true,
          "basic": {
            "valid": true
          }
        }
      }
    ]
  }
]
```

--------------------------------

### Dynamic reference example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Uses $dynamicRef for evaluation context-dependent resolution.

```json
{
  "$dynamicRef": "http://localhost:1234/dynamic-anchor.json#items"
}
```

--------------------------------

### Test Case Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Structure for adding a new test case within a pull request.

```json
{
  "description": "my test",
  "schema": { },
  "tests": [ ]
}
```

--------------------------------

### Relative reference example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Shows how a $ref resolves relative to the base URI defined in $id.

```json
{
  "$id": "http://localhost:1234/nested/",
  "$ref": "leaf.json"
}
```

--------------------------------

### Define an Annotation Test Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-file-format.md

A complete example of an annotation test case validating the 'type' keyword.

```json
{
  "description": "annotation tests for the type keyword",
  "schema": {
    "type": "string"
  },
  "suite": [
    {
      "description": "type annotation appears correctly",
      "schema": {
        "type": "string"
      },
      "tests": [
        {
          "instance": "hello",
          "assertions": [
            {
              "location": "",
              "keyword": "type",
              "expected": {
                "#": "string"
              }
            }
          ]
        }
      ]
    }
  ]
}
```

--------------------------------

### Relative Reference Resolution Path

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

The expected resolved URI for the relative reference example.

```text
http://localhost:1234/baseUriChange/folderInteger.json
```

--------------------------------

### Define schema with dynamic references

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Example of a remote schema utilizing dynamic anchors and references.

```json
{
  "$id": "http://localhost:1234/dynamic-anchor.json",
  "$dynamicAnchor": "items",
  "type": "array",
  "items": {
    "$dynamicRef": "#items"
  }
}
```

--------------------------------

### Flag Format Schema Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Represents the simplest validation result using a boolean flag.

```json
{
  "flag": true
}
```

--------------------------------

### Hierarchy Format Output Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Represents validation results as a nested tree structure corresponding to the schema hierarchy.

```json
{
  "valid": true,
  "instanceLocation": "",
  "schemaLocation": "#",
  "errors": [],
  "children": []
}
```

--------------------------------

### No Annotation Assertion Example

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

Demonstrates how to assert that no annotation should appear at a specific location using an empty expected object.

```json
{
  "location": "/properties/ignored",
  "keyword": "type",
  "expected": {}  // No annotation should appear here
}
```

--------------------------------

### Define schema with $id

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Example of a remote schema using the $id keyword to define its retrieval URI.

```json
{
  "$id": "http://localhost:1234/different-id-ref-string.json",
  "type": "string"
}
```

--------------------------------

### External Schemas Definition

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

Example of providing external schemas for reference resolution.

```json
{
  "schema": {
    "$ref": "http://example.com/foo.json"
  },
  "externalSchemas": {
    "http://example.com/foo.json": {
      "type": "string"
    }
  }
}
```

--------------------------------

### Remote Schema JSON Format

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Example structure of the JSON object returned by the remotes command.

```json
{
  "http://localhost:1234/integer.json": {
    "type": "integer"
  },
  "http://localhost:1234/baseUriChange/folderInteger.json": {
    "type": "integer"
  },
  ...
}
```

--------------------------------

### Create a proposal README

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

The standard format for documenting a new proposal within the test suite.

```markdown
# My Proposal

Brief description of the proposed feature.

## Specification Reference

Link to the proposal document or discussion.

## Test Coverage

Description of which aspects are tested.
```

--------------------------------

### List project documentation files

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/INDEX.md

Displays the directory structure of the generated documentation files.

```text
output/
├── INDEX.md (this file)
├── project-overview.md
├── test-file-format.md
├── specification-versions.md
├── test-execution-guide.md
├── cli-reference.md
├── annotation-tests-reference.md
├── output-tests-reference.md
├── remote-schemas.md
└── contributing-guide.md
```

--------------------------------

### General CLI Usage

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

The base command structure for executing the test suite tool.

```bash
bin/jsonschema_suite <command> [arguments]
```

--------------------------------

### Standard Git Workflow for Contributions

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Use this sequence to create a feature branch, commit changes, run local test checks, and push to your fork.

```bash
# Create feature branch
git checkout -b feature/my-contribution

# Make changes
# Edit test files
git add tests/draft2020-12/type.json

# Commit changes
git commit -m "Add tests for type keyword edge cases"

# Run checks
bin/jsonschema_suite check

# Push to your fork
git push origin feature/my-contribution

# Create pull request on GitHub
```

--------------------------------

### Implement a Custom Test Runner

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Demonstrates how to collect test files and validate them against a specific JSON Schema draft version.

```python
#!/usr/bin/env python3
from pathlib import Path
from bin.jsonschema_suite import tests, collect
import jsonschema

# Get all tests for draft2020-12
test_files = list(collect(Path('tests/draft2020-12')))

# Create a validator
validator_class = jsonschema.validators.Draft202012Validator

# Run each test
passed = 0
failed = 0

for test in tests(test_files):
    schema = test['schema']
    data = test['data']
    expected_valid = test['valid']
    
    validator = validator_class(schema)
    is_valid = validator.is_valid(data)
    
    if is_valid == expected_valid:
        passed += 1
    else:
        failed += 1
        print(f"FAILED: {test['description']}")

print(f"Passed: {passed}, Failed: {failed}")
```

--------------------------------

### Run Annotation Tests

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

Execute the validation script using the Deno runtime.

```bash
deno run bin/annotation-tests.ts
```

--------------------------------

### Dynamic Reference Test Case

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Illustrates dynamic reference behavior using $dynamicRef and $dynamicAnchor.

```json
{
  "schema": {
    "$id": "http://localhost:1234/dynamic-anchor.json",
    "$dynamicAnchor": "items",
    "type": "array",
    "items": {
      "$dynamicRef": "#items"
    }
  }
}
```

--------------------------------

### Discover and Run Optional Tests

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Use these functions to locate and execute tests stored in the optional/ subdirectory, supporting optional remote configurations.

```python
def discover_optional_tests(version):
    """Discover optional tests for a version."""
    version_dir = Path('tests') / version / 'optional'
    if not version_dir.exists():
        return []
    return sorted(version_dir.glob('**/*.json'))

def run_optional_tests(version, remotes=None):
    """Run optional tests if implementation supports them."""
    test_files = discover_optional_tests(version)
    
    if remotes:
        return test_suite_with_remotes(test_files, version, remotes)
    else:
        return test_suite(test_files, version)
```

--------------------------------

### Manage Proposal Test Suites

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Discover and execute tests organized by individual proposal directories within the proposals/ folder.

```python
def discover_proposals(version):
    """Discover proposal test directories."""
    version_dir = Path('tests') / version / 'proposals'
    if not version_dir.exists():
        return {}
    
    proposals = {}
    for proposal_dir in version_dir.iterdir():
        if proposal_dir.is_dir():
            test_files = sorted(proposal_dir.glob('*.json'))
            proposals[proposal_dir.name] = test_files
    
    return proposals

def run_proposal_tests(version, proposal_names=None):
    """Run tests for specific proposals."""
    proposals = discover_proposals(version)
    
    if proposal_names:
        proposals = {k: v for k, v in proposals.items() if k in proposal_names}
    
    results = {}
    for proposal_name, test_files in proposals.items():
        results[proposal_name] = test_suite(test_files, version)
    
    return results
```

--------------------------------

### Execute Multi-Version Testing in Python

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Iterates through all available specification versions to run tests and aggregate results into a final summary.

```python
def test_all_versions():
    """Run tests for all specification versions."""
    all_results = {}
    
    for version in discover_all_versions():
        print(f"Testing {version}...")
        test_files = discover_tests(version)
        remotes = load_remotes_from_filesystem(version)
        
        results = test_suite_with_remotes(test_files, version, remotes)
        all_results[version] = results
        
        print_summary(results, version)
    
    # Print overall summary
    total_passed = sum(r['passed'] for r in all_results.values())
    total_failed = sum(r['failed'] for r in all_results.values())
    total_tests = sum(r['total'] for r in all_results.values())
    
    print(f"\n\nOverall Results:")
    print(f"  Passed: {total_passed}")
    print(f"  Failed: {total_failed}")
    print(f"  Total:  {total_tests}")
    print(f"  Success Rate: {total_passed/total_tests*100:.1f}%")
    
    return all_results
```

--------------------------------

### Configure jsonschema registry for remotes

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Uses the referencing library to build a registry that maps remote URLs to local schema files for validation.

```python
from referencing import Registry, Resource
from referencing.jsonschema import DRAFT202012
import jsonschema
import json
from pathlib import Path

def create_registry_with_remotes():
    """Create referencing Registry with all remotes."""
    resources = {}
    
    for file_path in Path('remotes').rglob('*.json'):
        relative_path = file_path.relative_to('remotes')
        url = f'http://localhost:1234/{str(relative_path).replace(chr(92), "/")}'
        
        with open(file_path) as f:
            schema = json.load(f)
        
        resources[url] = Resource.from_contents(schema)
    
    return Registry(retrieve=lambda uri: resources.get(uri))

# Usage
registry = create_registry_with_remotes()
validator = jsonschema.Draft202012Validator(
    schema,
    registry=registry
)
```

--------------------------------

### View the remotes directory structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Displays the hierarchical organization of remote schemas categorized by draft version and specific testing scenarios.

```text
remotes/
├── integer.json                          # Root-level schema (shared)
├── nested/                               # Nested reference examples
│   └── leaf.json
├── baseUriChange/                        # Base URI change tests
│   └── folderInteger.json
├── baseUriChangeFolder/                  # Folder-based URI tests
│   └── folderInteger.json
├── baseUriChangeFolderInSubschema/       # URI change in subschema
│   └── folderInteger.json
├── draft-03/                             # Draft-03 specific remotes
├── draft-04/                             # Draft-04 specific remotes
├── draft-06/                             # Draft-06 specific remotes
├── draft-07/                             # Draft-07 specific remotes
├── draft2019-09/                         # Draft-2019-09 specific remotes
│   ├── baseUriChange/
│   ├── baseUriChangeFolder/
│   ├── baseUriChangeFolderInSubschema/
│   ├── dependentRequired.json
│   ├── detached-ref.json
│   ├── different-id-ref-string.json
│   ├── extendible-dynamic-ref.json
│   ├── recursive-ref.json
│   └── [other version-specific schemas]
├── draft2020-12/                         # Draft-2020-12 specific remotes
│   ├── baseUriChange/
│   ├── baseUriChangeFolder/
│   ├── baseUriChangeFolderInSubschema/
│   ├── dynamic-anchor-deep.json
│   ├── dynamic-anchor.json
│   ├── dynamic-ref-with-bool-schema.json
│   ├── false-schema.json
│   ├── https.json
│   ├── id-with-nested-object.json
│   ├── not-integer.json
│   └── [other version-specific schemas]
└── v1/                                   # v1 proposal specific remotes
```

--------------------------------

### Execute basic JSON Schema tests in Python

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Runs a suite of tests against a specified schema version. Requires a configured validator and test iteration logic.

```python
def run_test(schema, data, version):
    """Run a single test."""
    import jsonschema
    
    validator_class = configure_validator(version)
    validator = validator_class(schema)
    
    return validator.is_valid(data)

def test_suite(test_files, version):
    """Run all tests for a version."""
    passed = 0
    failed = 0
    errors = []
    
    for test_file in test_files:
        for test in iterate_tests(test_file):
            expected_valid = test['valid']
            actual_valid = run_test(test['schema'], test['data'], version)
            
            if actual_valid == expected_valid:
                passed += 1
            else:
                failed += 1
                errors.append({
                    'file': str(test_file),
                    'case': test['case_description'],
                    'test': test['test_description'],
                    'expected': expected_valid,
                    'actual': actual_valid
                })
    
    return {
        'passed': passed,
        'failed': failed,
        'total': passed + failed,
        'errors': errors
    }
```

--------------------------------

### Generating Remote Schema Registry via CLI and Python

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Commands to output remotes as JSON using the CLI tool or by invoking it via Python's subprocess module.

```bash
# Output all remotes as JSON
bin/jsonschema_suite remotes > remotes.json

# In Python
import subprocess
import json

result = subprocess.run(['bin/jsonschema_suite', 'remotes'], 
                       capture_output=True, text=True)
remotes = json.loads(result.stdout)
```

--------------------------------

### Project Directory Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/project-overview.md

The file system layout of the JSON Schema Test Suite repository, detailing the organization of test suites, schemas, and utility scripts.

```text
json-schema-test-suite/
├── bin/                          # Executable tools and utilities
│   ├── jsonschema_suite          # Python CLI for test suite operations
│   ├── annotation-tests.ts       # Deno script for validating annotation tests
│   └── specification_urls.json   # URLs for specification references
├── tests/                        # Main test suites organized by version
│   ├── draft2020-12/             # Latest specification tests
│   ├── draft2019-09/             # 2019-09 specification tests
│   ├── draft-07/                 # Draft-07 specification tests
│   ├── draft-06/                 # Draft-06 specification tests
│   ├── draft-04/                 # Draft-04 specification tests (frozen)
│   ├── draft-03/                 # Draft-03 specification tests (frozen)
│   ├── v1/                       # Proposals for v1 release
│   └── latest/                   # Symbolic link to draft2020-12
├── output-tests/                 # Output format validation tests
│   ├── draft2020-12/
│   └── draft2019-09/
├── annotations/                  # Annotation validation test suite
│   ├── tests/                    # Annotation test files
│   ├── test-suite.schema.json    # Schema for annotation test suites
│   ├── test-case.schema.json     # Schema for annotation test cases
│   ├── test.schema.json          # Schema for individual annotation tests
│   └── assertion.schema.json     # Schema for annotation assertions
├── remotes/                      # Remote schemas for $ref resolution testing
│   └── [version directories]     # Remote schemas organized by specification version
├── test-schema.json              # JSON Schema defining the structure of test files
├── output-test-schema.json       # JSON Schema defining output test file structure
├── package.json                  # NPM package metadata
└── README.md                     # Project documentation
```

--------------------------------

### Discover test files across multiple versions

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Iterates through specification version directories to organize test files by version.

```python
from pathlib import Path

def discover_all_versions():
    """Discover all specification version directories."""
    tests_dir = Path('tests')
    versions = [d.name for d in tests_dir.iterdir() if d.is_dir() and d.name != 'latest']
    return versions

def discover_tests_by_version():
    """Get test files organized by version."""
    by_version = {}
    for version in discover_all_versions():
        by_version[version] = discover_tests(version)
    return by_version
```

--------------------------------

### Test All Output Formats

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Iterates through test cases to generate and collect outputs for all supported formats.

```python
def test_all_output_formats(test_file, version='draft2020-12'):
    """Test all output format requirements."""
    with open(test_file) as f:
        test_cases = json.load(f)
    
    format_results = {
        'flag': [],
        'basic': [],
        'detailed': [],
        'verbose': [],
        'list': [],
        'hierarchy': []
    }
    
    for case in test_cases:
        schema = case['schema']
        
        for test in case['tests']:
            data = test['data']
            validator = get_validator(schema, version)
            
            # Test each format specified in the test
            for format_name in test['output']:
                output = generate_output(validator, data, format=format_name)
                format_results[format_name].append(output)
    
    return format_results
```

--------------------------------

### Create a remote schema file

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Define a JSON schema file to be used for $ref resolution testing.

```json
{
  "type": "object",
  "properties": {
    "name": { "type": "string" }
  },
  "required": ["name"]
}
```

--------------------------------

### Test schema validity using meta-schema

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/README.md

Demonstrates testing a schema's validity by using it as an instance against a meta-schema via the $ref keyword.

```json
{
    "description": "Test the \"type\" schema keyword",
    "schema": {
        "$ref": "https://json-schema.org/draft/2019-09/schema"
     },
    "tests": [
        {
            "description": "Valid: string",
            "data": {
                "type": "string"
            },
            "valid": true
        },
        {
            "description": "Invalid: null",
            "data": {
                "type": null
            },
            "valid": false
        }
    ]
}
```

--------------------------------

### JSON Test File Formatting

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Standard structure for test files, requiring 2-space indentation and alphabetical property ordering.

```json
[
  {
    "description": "test case",
    "schema": {
      "type": "string"
    },
    "tests": [
      {
        "description": "a string",
        "data": "hello",
        "valid": true
      }
    ]
  }
]
```

--------------------------------

### Load remote schemas from filesystem in Python

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Reads JSON files from a local remotes directory and maps them to localhost URLs for schema resolution.

```python
from pathlib import Path
import json

def load_remotes_from_filesystem(version='draft2020-12'):
    """Load remote schemas from remotes/ directory."""
    remotes = {}
    remotes_dir = Path('remotes')
    version_remotes = remotes_dir / version
    
    # Include version-specific remotes
    if version_remotes.exists():
        for file_path in version_remotes.rglob('*.json'):
            relative_path = file_path.relative_to(remotes_dir)
            url = f'http://localhost:1234/{relative_path}'
            with open(file_path) as f:
                remotes[url] = json.load(f)
    
    # Include root-level remotes (shared across versions)
    for file_path in remotes_dir.glob('*.json'):
        relative_path = file_path.relative_to(remotes_dir)
        url = f'http://localhost:1234/{relative_path}'
        with open(file_path) as f:
            remotes[url] = json.load(f)
    
    return remotes
```

--------------------------------

### Execute Output Format Tests

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Runs validation tests from a file and verifies generated output against expected schemas for specific formats.

```python
import json
from pathlib import Path

def test_output_format(test_file, version='draft2020-12'):
    """Run output tests from a file."""
    with open(test_file) as f:
        test_cases = json.load(f)
    
    results = []
    
    for case in test_cases:
        schema = case['schema']
        
        for test in case['tests']:
            data = test['data']
            expected_outputs = test['output']
            
            # Validate instance
            validator = get_validator(schema, version)
            
            # Generate output in each required format
            for format_name, expected_schema in expected_outputs.items():
                actual_output = generate_output(
                    validator,
                    data,
                    format=format_name
                )
                
                # Validate generated output
                format_validator = Draft7Validator(expected_schema)
                is_valid = format_validator.is_valid(actual_output)
                
                results.append({
                    'test': test['description'],
                    'format': format_name,
                    'valid': is_valid,
                    'output': actual_output
                })
    
    return results
```

--------------------------------

### Updating Contributions After Feedback

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Follow these steps to stage, commit, and push updates to an existing feature branch after receiving review feedback.

```bash
# Make requested changes
git add tests/...

# Commit with descriptive message
git commit -m "Address review feedback: clarify descriptions"

# Push updated commits
git push origin feature/my-contribution
```

--------------------------------

### Load and Iterate Test Files

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Provides utility functions to parse test files and yield individual test cases or specific test instances.

```python
import json
from pathlib import Path

def load_test_file(file_path):
    """Load and parse a test file."""
    with open(file_path) as f:
        return json.load(f)

def iterate_test_cases(file_path):
    """Iterate through test cases in a file."""
    test_cases = load_test_file(file_path)
    for test_case in test_cases:
        yield test_case

def iterate_tests(file_path):
    """Iterate through individual tests in a file."""
    for test_case in iterate_test_cases(file_path):
        schema = test_case['schema']
        for test in test_case['tests']:
            yield {
                'case_description': test_case['description'],
                'test_description': test['description'],
                'schema': schema,
                'data': test['data'],
                'valid': test['valid']
            }
```

--------------------------------

### Print Detailed Failure Report in Python

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Outputs granular information for each failed test case, including expected versus actual values and specific error messages.

```python
def print_failures(results):
    """Print detailed failure information."""
    print("\nFailures:")
    for i, error in enumerate(results['errors'], 1):
        print(f"\n{i}. {error['case']}")
        print(f"   Test: {error['test']}")
        if 'expected' in error:
            print(f"   Expected valid: {error['expected']}")
            print(f"   Actual valid: {error['actual']}")
        if 'error' in error:
            print(f"   Error: {error['error']}")
```

--------------------------------

### Implement a JSON Schema Test Runner in Python

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

This script iterates through test files, loads remote schemas, and validates test cases using the jsonschema library. Ensure the 'tests' and 'remotes' directories are present in the working directory.

```python
#!/usr/bin/env python3
"""Complete test runner implementation."""

import json
from pathlib import Path
import jsonschema

def main():
    version = 'draft2020-12'
    
    # Discover tests
    version_dir = Path('tests') / version
    test_files = sorted(version_dir.glob('*.json'))
    
    # Load remotes
    remotes_dir = Path('remotes')
    remotes = {}
    for file_path in remotes_dir.rglob('*.json'):
        relative_path = file_path.relative_to(remotes_dir)
        url = f'http://localhost:1234/{str(relative_path).replace(chr(92), "/")}'
        with open(file_path) as f:
            remotes[url] = json.load(f)
    
    # Run tests
    passed = 0
    failed = 0
    
    for test_file in test_files:
        with open(test_file) as f:
            test_cases = json.load(f)
        
        for test_case in test_cases:
            schema = test_case['schema']
            
            for test in test_case['tests']:
                expected = test['valid']
                data = test['data']
                
                validator = jsonschema.Draft202012Validator(schema)
                actual = validator.is_valid(data)
                
                if actual == expected:
                    passed += 1
                else:
                    failed += 1
                    print(f"FAIL: {test_case['description']} - {test['description']}")
    
    print(f"\nResults: {passed} passed, {failed} failed")

if __name__ == '__main__':
    main()
```

--------------------------------

### Resolve Remote Schemas via Filesystem

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Implementation for loading remote schemas directly from the local filesystem based on the URL path.

```python
import json
from pathlib import Path
from urllib.parse import urljoin

REMOTES_DIR = Path('remotes')
BASE_URL = 'http://localhost:1234/'

def resolve_ref(url):
    """Resolve a $ref URL by loading from filesystem."""
    # Extract relative path from URL
    relative_path = url.replace(BASE_URL, '')
    
    # Load from filesystem
    file_path = REMOTES_DIR / relative_path
    with open(file_path) as f:
        return json.load(f)
```

--------------------------------

### Define proposal directory structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

The required file structure for adding tests related to proposed specification features.

```text
tests/draft2020-12/proposals/my-proposal/
├── README.md
├── tests.json
└── optional/
    └── edge-cases.json
```

--------------------------------

### files(paths)

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Iterates through test files and yields file paths with their parsed JSON content.

```APIDOC
## files(paths)

### Description
Iterates through test files and yields file paths with their parsed JSON content.

### Signature
`def files(paths: List[Path]) -> Iterator[Tuple[Path, List[Dict]]]:`

### Parameters
- **paths** (List[Path]) - Required - Iterable of file paths to process.

### Return Value
Iterator yielding tuples of (file_path, parsed_content).
```

--------------------------------

### cases(paths)

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Extracts and yields each test case from the provided test files.

```APIDOC
## cases(paths)

### Description
Extracts and yields each test case from the provided test files.

### Signature
`def cases(paths: List[Path]) -> Iterator[Dict]:`

### Parameters
- **paths** (List[Path]) - Required - Iterable of file paths to process.

### Return Value
Iterator yielding individual test case objects.
```

--------------------------------

### Simple Remote Reference Test Case

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Defines a basic schema test case that resolves a remote integer schema via $ref.

```json
{
  "description": "reference to remote schema",
  "schema": {
    "$ref": "http://localhost:1234/integer.json"
  },
  "tests": [
    {
      "description": "integer is valid",
      "data": 42,
      "valid": true
    },
    {
      "description": "string is invalid",
      "data": "not an integer",
      "valid": false
    }
  ]
}
```

--------------------------------

### Iterate through test files with files()

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Processes a list of file paths and yields tuples containing the file path and its parsed JSON content.

```python
from pathlib import Path
from bin.jsonschema_suite import files

test_files = list(Path('tests/draft2020-12').rglob('*.json'))
for path, test_file in files(test_files):
    print(f"File: {path}, Cases: {len(test_file)}")
```

--------------------------------

### Export Remote Schemas to Registry

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Command to export all remote schemas into a single JSON file for registry-based resolution.

```bash
bin/jsonschema_suite remotes > remotes.json
```

--------------------------------

### Reference a remote schema

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-file-format.md

Use the $ref keyword to point to a remote schema hosted at the local test server.

```json
{
  "$ref": "http://localhost:1234/integer.json"
}
```

--------------------------------

### Define module constants

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Constants representing directory paths and configuration for the test suite.

```python
ROOT_DIR = Path(__file__).parent.parent
```

```python
SUITE_ROOT_DIR = ROOT_DIR / "tests"
```

```python
OUTPUT_ROOT_DIR = ROOT_DIR / "output-tests"
```

```python
REMOTES_DIR = ROOT_DIR / "remotes"
```

```python
REMOTES_BASE_URL = "http://localhost:1234/"
```

```python
TEST_SCHEMA = json.loads(ROOT_DIR.joinpath("test-schema.json").read_text())
```

```python
OUTPUT_TEST_SCHEMA = json.loads(ROOT_DIR.joinpath("output-test-schema.json").read_text())
```

```python
VALIDATORS = {
    "draft3": jsonschema.validators.Draft3Validator,
    "draft4": jsonschema.validators.Draft4Validator,
    "draft6": jsonschema.validators.Draft6Validator,
    "draft7": jsonschema.validators.Draft7Validator,
    "draft2019-09": jsonschema.validators.Draft201909Validator,
    "draft2020-12": jsonschema.validators.Draft202012Validator,
    "latest": jsonschema.validators.Draft202012Validator,
}
```

--------------------------------

### Format commit documentation

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Use this template in commit messages or pull requests to document changes and specification references.

```markdown
## Changes Made

1. Added tests for X behavior
   - Test case 1: ...
   - Test case 2: ...

2. Improved tests for Y behavior
   - Enhanced edge case coverage
   - Clarified descriptions

## Specification References

- [JSON Schema Draft 2020-12, section 6.1]
- [RFC 3339 Date and Time]
```

--------------------------------

### View Test Suite Directory Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/specification-versions.md

Displays the hierarchical organization of specification versions within the tests directory.

```text
tests/
├── draft2020-12/         # Latest release (v2020-12)
├── draft2019-09/         # Previous release (v2019-09)
├── draft-07/             # Draft-07
├── draft-06/             # Draft-06
├── draft-04/             # Draft-04 (frozen)
├── draft-03/             # Draft-03 (frozen)
├── v1/                   # Future v1 proposals
└── latest/               # Symbolic link → draft2020-12
```

--------------------------------

### Export remote schemas via command line

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Uses the jsonschema_suite binary to output remote schemas as JSON or assign them to a shell variable.

```bash
# Get all remotes as JSON
bin/jsonschema_suite remotes > remotes.json

# Load in implementation
REMOTES=$(bin/jsonschema_suite remotes)
```

--------------------------------

### URL Mapping for Remote Schemas

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Mapping of local file paths to their corresponding HTTP URLs for remote schema retrieval.

```text
File:                                     URL:
remotes/integer.json                      http://localhost:1234/integer.json
remotes/nested/leaf.json                  http://localhost:1234/nested/leaf.json
remotes/draft2020-12/integer.json         http://localhost:1234/draft2020-12/integer.json
```

--------------------------------

### Handle Missing Dependencies

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Graceful handling of missing jsonschema package imports to prevent runtime crashes.

```python
try:
    import jsonschema.validators
except ImportError:
    jsonschema = Unresolvable = None
    VALIDATORS = {}
```

--------------------------------

### Ambiguous 'basic' Output Structure (2019-09/2020-12)

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/output-tests/README.md

Illustrates two possible interpretations of the 'basic' output format when a list contains a single output node. The first shows a containing node with a 'valid' property, while the second shows a collapsed structure similar to 'detailed' output.

```json
{
    "valid": false,
    "errors": [
        {
            "valid": false,
            "keywordLocation": "",
            "absoluteKeywordLocation": "https://json-schema.org/tests/content/draft2019-09/general/0",
            "instanceLocation": ""
        }
    ]
}
```

```json
{
    "valid": false,
    "keywordLocation": "",
    "absoluteKeywordLocation": "https://json-schema.org/tests/content/draft2019-09/general/0",
    "instanceLocation": ""
}
```

--------------------------------

### Commit Message Format

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Follow a standard format with a concise summary, a blank line, and optional details or issue references.

```text
Add tests for the unevaluatedProperties keyword

- Add 15 new test cases covering basic functionality
- Include edge cases for empty objects and complex nesting
- All tests pass sanity checks
```

--------------------------------

### CI Invocation

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Common ways to trigger the sanity check process within a CI environment.

```bash
tox
# or
bin/jsonschema_suite check
```

--------------------------------

### Run comprehensive test suite

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Execute the full test suite or target specific test files using pytest.

```bash
# Run full test suite
bin/jsonschema_suite check

# Test with your implementation
pytest tests/draft2020-12/type.json
```

--------------------------------

### Filter Tests by Keyword

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Shows how to isolate specific test files and iterate through test cases based on keyword criteria.

```python
from pathlib import Path
from bin.jsonschema_suite import cases, collect

# Find all tests for the "type" keyword
test_files = [f for f in collect(Path('tests/draft2020-12')) if f.name == 'type.json']

for case in cases(test_files):
    print(f"Case: {case['description']}")
    for test in case['tests']:
        print(f"  - {test['description']}: {test['valid']}")
```

--------------------------------

### Standard Test File Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-file-format.md

The base structure for a JSON Schema test file, consisting of an array of test case objects.

```json
[
  {
    "description": "Test case description",
    "schema": { },
    "tests": [ ]
  }
]
```

--------------------------------

### Resolve Remote Schemas via Registry

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Implementation for resolving remote schemas from a pre-loaded JSON registry.

```python
import json

with open('remotes.json') as f:
    remotes = json.load(f)

def resolve_ref(url):
    """Resolve from pre-loaded registry."""
    return remotes.get(url)
```

--------------------------------

### Execute Sanity Tests via CLI

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Commands to run the suite's sanity tests using standard Python test runners.

```bash
# Run all sanity tests
python -m unittest discover bin/

# Run via tox
tox

# Run via pytest
pytest bin/jsonschema_suite
```

--------------------------------

### Output Tests Directory Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Visual representation of the file organization within the output-tests directory.

```text
output-tests/
├── draft2019-09/
│   ├── content/
│   │   ├── escape.json
│   │   ├── general.json
│   │   ├── readOnly.json
│   │   ├── writeOnly.json
│   │   └── type.json
│   └── [other test files]
├── draft2020-12/
│   ├── content/
│   │   ├── escape.json
│   │   ├── general.json
│   │   └── ...
│   └── [other test files]
└── output-schema.json         # Shared output test schema definition
```

--------------------------------

### Format remote schema URL references

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/specification-versions.md

The URL pattern used by tests to reference remote schemas during execution.

```text
http://localhost:1234/<version-relative-path>
```

--------------------------------

### Handle Windows path separators in URLs

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Ensures cross-platform compatibility by converting Windows backslashes to forward slashes when generating remote URLs.

```python
# Correct: Convert backslashes to forward slashes
relative_path = file_path.relative_to(remotes_dir)
url = f'http://localhost:1234/{str(relative_path).replace(chr(92), "/")}'

# Incorrect: Don't use raw path
# url = f'http://localhost:1234/{relative_path}'  # May have backslashes
```

--------------------------------

### Test Suite File Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

The top-level structure for an annotation test suite file.

```json
{
  "description": "Annotation tests for the type keyword",
  "suite": [
    { /* test case */ }
  ]
}
```

--------------------------------

### Test against specific validator

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Use this command to verify test cases within a specific JSON file using Python.

```bash
# Test against specific validator
python -c "
import json
with open('tests/draft2020-12/type.json') as f:
    tests = json.load(f)
print(f'Found {len(tests)} test cases')
"
```

--------------------------------

### Batch load remote schemas into memory

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/remote-schemas.md

Pre-loads all JSON files from the remotes directory into a global dictionary for faster resolution.

```python
def preload_all_remotes():
    """Load all remotes into memory once."""
    global REMOTE_CACHE
    REMOTE_CACHE = {}
    
    for file_path in Path('remotes').rglob('*.json'):
        relative_path = file_path.relative_to('remotes')
        url = f'http://localhost:1234/{str(relative_path).replace(chr(92), "/")}'
        
        with open(file_path) as f:
            REMOTE_CACHE[url] = json.load(f)
    
    return REMOTE_CACHE

def resolve_ref_cached(url):
    """Resolve using pre-loaded cache."""
    return REMOTE_CACHE.get(url)
```

--------------------------------

### Execute JSON Schema tests with remote support

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/test-execution-guide.md

Extends test execution to include remote schema resolution. Includes error handling for failed validation or resolution attempts.

```python
def test_suite_with_remotes(test_files, version, remotes):
    """Run all tests with remote schema support."""
    passed = 0
    failed = 0
    errors = []
    
    for test_file in test_files:
        for test in iterate_tests(test_file):
            expected_valid = test['valid']
            
            try:
                validator = create_validator_with_remotes(
                    test['schema'],
                    version,
                    remotes
                )
                actual_valid = validator.is_valid(test['data'])
                
                if actual_valid == expected_valid:
                    passed += 1
                else:
                    failed += 1
                    errors.append({
                        'file': str(test_file),
                        'case': test['case_description'],
                        'test': test['test_description'],
                        'expected': expected_valid,
                        'actual': actual_valid
                    })
            except Exception as e:
                failed += 1
                errors.append({
                    'file': str(test_file),
                    'case': test['case_description'],
                    'test': test['test_description'],
                    'error': str(e)
                })
    
    return {
        'passed': passed,
        'failed': failed,
        'total': passed + failed,
        'errors': errors
    }
```

--------------------------------

### Add Specification References

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/contributing-guide.md

Include a specification array within the test object to link test cases to relevant documentation sections.

```json
{
  "description": "my test case",
  "schema": { },
  "specification": [
    {
      "core": "6.1.1",
      "quote": "The value of 'type' must be an array..."
    }
  ],
  "tests": [ ]
}
```

--------------------------------

### tests(paths)

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Lowest-level iteration that yields each individual test with the parent schema attached.

```APIDOC
## tests(paths)

### Description
Lowest-level iteration that yields each individual test. The schema from the parent test case is attached to each test object as the "schema" key.

### Signature
`def tests(paths: List[Path]) -> Iterator[Dict]:`

### Parameters
- **paths** (List[Path]) - Required - Iterable of file paths to process.

### Return Value
Iterator yielding individual test objects.
```

--------------------------------

### Iterate individual tests with tests()

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/cli-reference.md

Yields individual test objects with the parent schema attached as a 'schema' key.

```python
from pathlib import Path
from bin.jsonschema_suite import tests

test_files = list(Path('tests/draft2020-12').rglob('*.json'))
for test in tests(test_files):
    print(f"Test: {test['description']}")
    print(f"  Expected valid: {test['valid']}")
    print(f"  Schema: {test['schema']}")
```

--------------------------------

### Execute Remote Reference Retrieval

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/README.md

Command to output a JSON object containing all remote references for testing $ref behavior.

```bash
$  bin/jsonschema_suite remotes
```

```json
{
    "http://localhost:1234/baseUriChange/folderInteger.json": {
        "type": "integer"
    },
    "http://localhost:1234/baseUriChangeFolder/folderInteger.json": {
        "type": "integer"
    }
}
```

--------------------------------

### Represent remote schema directory structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/specification-versions.md

The file system layout for remote schemas, organized by version and referenced via local URLs.

```text
remotes/
├── integer.json
├── draft2019-09/
│   ├── baseUriChange/
│   ├── dependentRequired.json
│   ├── different-id-ref-string.json
│   ├── extendible-dynamic-ref.json
│   ├── recursive-ref.json
│   └── ...
└── [other versions]/
```

--------------------------------

### Valid Instance Output Pattern

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

Represents the structure of a successful validation result across different reporting formats.

```json
{
  "flag": true,
  "basic": {
    "valid": true
  },
  "detailed": {
    "valid": true,
    "errors": []
  },
  "list": [
    {
      "valid": true,
      "instanceLocation": "",
      "schemaLocation": "#",
      "keyword": "schema"
    }
  ]
}
```

--------------------------------

### Annotation Test Suite Directory Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

Visual representation of the file hierarchy within the annotations directory.

```text
annotations/
├── README.md                    # Detailed guide to annotations tests
├── test-suite.schema.json       # Schema for test suite files
├── test-case.schema.json        # Schema for individual test cases
├── test.schema.json             # Schema for individual tests
├── assertion.schema.json        # Schema for assertions
└── tests/                       # Annotation test files
    ├── applicators.json         # Tests for allOf, anyOf, oneOf, not
    ├── content.json             # Tests for content* keywords
    ├── core.json                # Tests for core keywords
    ├── format.json              # Tests for format annotations
    ├── meta-data.json           # Tests for metadata keywords
    ├── unevaluated.json         # Tests for unevaluated* keywords
    └── unknown.json             # Tests for unknown keywords
```

--------------------------------

### Define Test File Structure

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/output-tests-reference.md

The root structure of an output test file is an array of test case objects.

```json
[
  {
    "description": "Test case description",
    "schema": { /* schema */ },
    "tests": [
      {
        "description": "Individual test description",
        "data": /* instance */,
        "output": { /* expected output formats */ }
      }
    ]
  }
]
```

--------------------------------

### Simple Type Annotation Test

Source: https://github.com/json-schema-org/json-schema-test-suite/blob/main/_autodocs/annotation-tests-reference.md

Verifies that the type keyword produces an annotation when the instance matches the schema.

```json
{
  "description": "Type keyword produces annotation",
  "schema": {
    "type": "string"
  },
  "tests": [
    {
      "instance": "hello",
      "assertions": [
        {
          "location": "",
          "keyword": "type",
          "expected": {
            "#": "string"
          }
        }
      ]
    }
  ]
}
```
Tokens:
Raw