Function jsonpath_tests

test/jsonpath/src/jsonpath_test_suite.cpp:24–127

using namespace jsoncons;

void jsonpath_tests(const std::string& fpath)
{
    std::cout << "Test " << fpath << '\n';

    std::fstream is(fpath);
    if (!is)
    {
        std::cerr << "Cannot open " << fpath << "\n";
        exit(1);
    }

    json tests = json::parse(is);
    for (const auto& test_group : tests.array_range())
    {
        const json& instance = test_group["given"];

        for (const auto& test_case : test_group["cases"].array_range())
        {
            std::string expr = test_case["expression"].as<std::string>();
            try
            {
                jsonpath::result_options options = jsonpath::result_options();
                if (test_case.contains("nodups") && test_case.at("nodups").as<bool>())
                {
                    options |= jsonpath::result_options::nodups;
                }
                if (test_case.contains("sort") && test_case.at("sort").as<bool>())
                {
                    options |= jsonpath::result_options::sort;
                }
                auto expression = jsoncons::jsonpath::make_expression<json>(expr);
                if (test_case.contains("result"))
                {
                    jsonpath::result_options rflags = options;
                    json actual = expression.evaluate(instance, rflags);
                    const json& expected = test_case["result"];
                    //std::cout << "actual\n:" << actual << "\n";
                    if (actual != expected)
                    {
                        if (test_case.contains("comment"))
                        {
                            std::cout << "\n" << test_case["comment"] << "\n";
                        }
                        std::cout << "Input:\n" << pretty_print(instance) << "\n\n";
                        std::cout << "Expression: " << expr << "\n\n";
                        std::cout << "Actual: " << pretty_print(actual) << "\n\n";
                        std::cout << "Expected: " << pretty_print(expected) << "\n\n";
                    }
                    CHECK(expected == actual);
                }
                if (test_case.contains("path"))
                {
                    jsonpath::result_options pflags = options | jsonpath::result_options::path;
                    json actual = expression.evaluate(instance, pflags);
                    const json& expected = test_case["path"];
                    //std::cout << "actual\n:" << actual << "\n";
                    if (actual != expected)
                    {