From 03d1a04548eb26fa59fcd65a4925a87980cd39c0 Mon Sep 17 00:00:00 2001
From: u19809 <wim.delvaux@adaptiveplanet.com>
Date: Mon, 4 May 2026 21:20:39 +0200
Subject: [PATCH 1/7] Rename project to Qjsonata and update documentation

Updated README to reflect project name change and backend support details.
---
 README.md | 53 ++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 44 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 82db649..3b30919 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,24 @@
-# jsonata-cpp
+# Qjsonata
 
 [![Build Status][github-actions-shield]][github-actions-link]
 
 [github-actions-shield]: https://github.com/rayokota/jsonata-cpp/actions/workflows/cmake-multi-platform.yml/badge.svg?branch=master
 [github-actions-link]: https://github.com/rayokota/jsonata-cpp/actions
 
-C++ implementation of JSONata.
+C++ implementation of JSONata with support for abstract backend.
 
 This is a C++ port of the  [JSONata reference implementation](https://github.com/jsonata-js/jsonata), 
 and also borrows from the [Dashjoin Java port](https://github.com/dashjoin/jsonata-java).
 
-This implementation supports 100% of the language features of JSONata, using [nlohmann_json](https://github.com/nlohmann/json).
-The JSONata documentation can be found [here](https://jsonata.org).
+QJsonata it is based on the jsonata-cpp port.
+
+This implementation supports 100% of the language features of JSONata, with the exception that the ordering of keys of objects depend on the backend used. 
+When using nlohmann - which has support for unordered json objects, ordering is as read or generated.  When using a backend like QJson which only supports sorted objects, objects are sorted when readed (parsed) or printed (dumped).  This 'breaks' some tests as the expected result objects converted to string sometimes do not match the query result converted to string, although the content is compatible as a json object.
 
+In fact QJson supports any 'backend' that supports a certain API, whether it is a json object or not (e.g. a QVariant is also valid).  The API is defined
+using a c++ context (isCompatible<T>).
+
+The JSONata documentation can be found [here](https://jsonata.org).
 
 ## Installation
 
@@ -22,19 +28,19 @@ Installation uses CMake as follows:
 include(FetchContent)
 
 FetchContent_Declare(
-    jsonata
-    URL https://github.com/rayokota/jsonata-cpp/archive/refs/tags/v0.1.0.zip
+    qjsonata
+    URL https://github.com/u19809/QJsonata/archive/refs/tags/v0.1.0.zip
     URL_HASH SHA256=3ee1798f28a29d36ebbb273853979926716a384e4d491a6bd408e1f6de51760d  # Optional
 )
-FetchContent_MakeAvailable(jsonata)
+FetchContent_MakeAvailable(qjsonata)
 
 # Use the library
-target_link_libraries(your_target jsonata::jsonata)
+target_link_libraries(your_target qjsonata::qjsonata)
 ```
 
 ## Getting Started
 
-A very simple start:
+A very simple start (with nlohmann as backend:
 
 ```
 #include <iostream>
@@ -63,6 +69,35 @@ int main() {
     return 0;
 }
 ```
+the same test with QJson as backend
+
+```
+#include <iostream>
+#include <jsonata/Jsonata.h>
+#include <nlohmann/json.hpp>
+
+int main() {
+    // Create the JSON data
+    auto data = QJsonValue::fromJson(R"({
+        "example": [
+            {"value": 4}, 
+            {"value": 7}, 
+            {"value": 13}
+        ]
+    })");
+
+    // Create the JSONata expression
+    jsonata::Jsonata expr("$sum(example.value)");
+    
+    // Evaluate the expression with the data
+    auto result = expr.evaluate(data);
+    
+    // Print the result
+    std::cout << "Result: " << result << std::endl;
+    
+    return 0;
+}
+```
 
 ## Running Tests
 

From f2ffccc9b17ab01839c24ec5fe4e7fc4eb0423a1 Mon Sep 17 00:00:00 2001
From: wim delvaux <wim.delvaux@adaptiveplanet.com>
Date: Tue, 5 May 2026 03:51:27 +0200
Subject: [PATCH 2/7] first version with full template support

---
 CMakeLists.txt                      |  315 ++++---
 include/jsonata/Functions.h         |   10 +-
 include/jsonata/JException.h        |    3 -
 include/jsonata/Jsonata.h           | 1111 +++++++++++++---------
 src/jsonata/Functions.cpp           |  115 ++-
 src/jsonata/JException.cpp          |    3 +-
 src/jsonata/Jsonata.cpp             |  988 +++++++++++---------
 src/jsonata/Parser.cpp              |   14 +-
 src/jsonata/Tokenizer.cpp           |    5 +-
 src/jsonata/Utils.cpp               |    4 +-
 src/jsonata/utils/DateTimeUtils.cpp |    6 +-
 src/jsonata/utils/Signature.cpp     |    8 +-
 test/ArrayTest.cpp                  |   26 +-
 test/CustomFunctionTest.cpp         |   18 +-
 test/DateTimeTest.cpp               |    6 +-
 test/Generate.cpp                   |   10 +-
 test/JsonataTest.cpp                | 1322 +++++++++++++++------------
 test/JsonataTest.h                  |   18 +-
 test/NullSafetyTest.cpp             |   32 +-
 test/NumberTest.cpp                 |   12 +-
 test/NumberTestSimplified.cpp       |   12 +-
 test/ParseIntegerTest.cpp           |    6 +-
 test/SerializationTest.cpp          |   10 +-
 test/SignatureTest.cpp              |   12 +-
 test/StringTest.cpp                 |   72 +-
 test/ThreadTest.cpp                 |   16 +-
 test/TypesTest.cpp                  |   48 +-
 test/gen/function_lengthTest.cpp    |    2 +-
 28 files changed, 2378 insertions(+), 1826 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1032787..7eab829 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,28 +2,44 @@ cmake_minimum_required(VERSION 3.22)
 
 project(jsonata
     VERSION 0.1.1
-    DESCRIPTION "JSONata for C++"
+    DESCRIPTION "QJSONata for C++"
     LANGUAGES CXX
 )
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+option(JSONATA_NLOHMANN_BACKEND "Build qjsonata with nlohmann json backend" OFF)
+option(JSONATA_QT_BACKEND "Build qjsonata with Qt json backend" OFF)
+
 include(GNUInstallDirs)
 include(FetchContent)
 
-# Find nlohmann_json or fetch if not found
-find_package(nlohmann_json CONFIG QUIET)
-if(NOT nlohmann_json_FOUND)
-    FetchContent_Declare(
+set( JSONATA_ENABLED_BACKENDS )
+
+if( JSONATA_NLOHMANN_BACKEND )
+    # Find nlohmann_json or fetch if not found
+    find_package(nlohmann_json CONFIG QUIET)
+    if(NOT nlohmann_json_FOUND)
+        FetchContent_Declare(
             nlohmann_json
             GIT_REPOSITORY https://github.com/nlohmann/json.git
             GIT_TAG        v3.12.0
-    )
-    FetchContent_MakeAvailable(nlohmann_json)
-    # Mark that we used FetchContent
-    set(JSONATA_USED_FETCHCONTENT_JSON TRUE)
+        )
+        FetchContent_MakeAvailable(nlohmann_json)
+        # Mark that we used FetchContent
+        set(JSONATA_USED_FETCHCONTENT_JSON TRUE)
+    endif()
+    list( APPEND JSONATA_ENABLED_BACKENDS nlohmann::ordered_json nlohmann::json)
+endif()
+
+if( JSONATA_QT_BACKEND )
+    find_package(Qt6 REQUIRED COMPONENTS Core)
+    if(NOT Qt6_FOUND)
+        error( "Cannot find Qt >=6.10" )
+    endif()
+    list( APPEND JSONATA_ENABLED_BACKENDS jsonata::backend::json )
 endif()
 
 # Collect source files
@@ -31,75 +47,87 @@ file(GLOB_RECURSE HEADERS "include/*.h")
 file(GLOB_RECURSE SOURCES "src/*.cpp")
 
 # Library type option
-option(JSONATA_BUILD_SHARED "Build jsonata as a shared library" OFF)
+option(JSONATA_BUILD_SHARED "Build qjsonata as a shared library" OFF)
 set(JSONATA_LIB_TYPE STATIC)
 if(JSONATA_BUILD_SHARED)
     set(JSONATA_LIB_TYPE SHARED)
 endif()
 
 # Create the library
-add_library(jsonata ${JSONATA_LIB_TYPE} ${SOURCES} ${HEADERS})
+add_library(qjsonata ${JSONATA_LIB_TYPE} ${SOURCES} ${HEADERS})
 
-set_target_properties(jsonata PROPERTIES
+set_target_properties(qjsonata PROPERTIES
     VERSION ${PROJECT_VERSION}
     SOVERSION ${PROJECT_VERSION_MAJOR}
     POSITION_INDEPENDENT_CODE ON
 )
 
 # Provide a canonical alias for consumers who add_subdirectory()
-add_library(jsonata::jsonata ALIAS jsonata)
+add_library(qjsonata::qjsonata ALIAS qjsonata)
 
 # Compiler features
-target_compile_features(jsonata PUBLIC cxx_std_17)
+# target_compile_features(qjsonata PUBLIC cxx_std_17)
 
 # Compiler options
-target_compile_options(jsonata
-        PRIVATE
-        # Common warnings
-        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:-Wall -Wno-unused-variable>
-        # Clang-only suppression
-        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wno-unused-lambda-capture>
-        # MSVC: ensure source files are treated as UTF-8 to avoid codepage warnings
-        $<$<CXX_COMPILER_ID:MSVC>:/utf-8>
+target_compile_options(qjsonata
+    PRIVATE
+    # Common warnings
+    $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:-Wall -Wno-unused-variable>
+    # Clang-only suppression
+    $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wno-unused-lambda-capture>
+    # MSVC: ensure source files are treated as UTF-8 to avoid codepage warnings
+    $<$<CXX_COMPILER_ID:MSVC>:/utf-8>
 )
 
 # Set include directories for the library
-target_include_directories(jsonata PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/third_party/utfcpp>
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+target_include_directories(qjsonata PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/third_party/utfcpp>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-# nlohmann_json is used from public headers, so propagate it PUBLIC.
-# Ensure the exported target only records the imported name in the install
-# interface to avoid referencing non-exported build targets.
-if(TARGET nlohmann_json::nlohmann_json)
-    target_link_libraries(jsonata PUBLIC
-        $<BUILD_INTERFACE:nlohmann_json::nlohmann_json>
-        $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
-    )
-elseif(TARGET nlohmann_json)
-    target_link_libraries(jsonata PUBLIC
-        $<BUILD_INTERFACE:nlohmann_json>
-        $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
-    )
-else()
-    # Not present in the build; rely on the installed config to find it.
-    target_link_libraries(jsonata PUBLIC
-        $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
-    )
+if( JSONATA_NLOHMANN_BACKEND )
+    # tell sources to compile NLOHMANN backend
+    target_compile_definitions( qjsonata PUBLIC JSONATA_NLOHMANN_ENABLED )
+
+    # nlohmann_json is used from public headers, so propagate it PUBLIC.
+    # Ensure the exported target only records the imported name in the install
+    # interface to avoid referencing non-exported build targets.
+    if(TARGET nlohmann_json::nlohmann_json)
+        target_link_libraries(qjsonata PUBLIC
+            $<BUILD_INTERFACE:nlohmann_json::nlohmann_json>
+            $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
+        )
+    elseif(TARGET nlohmann_json)
+        target_link_libraries(qjsonata PUBLIC
+            $<BUILD_INTERFACE:nlohmann_json>
+            $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
+        )
+    else()
+        # Not present in the build; rely on the installed config to find it.
+        target_link_libraries(qjsonata PUBLIC
+            $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
+        )
+    endif()
+endif()
+
+if( JSONATA_QT_BACKEND )
+    # tell sources to compile NLOHMANN backend
+    target_compile_definitions( qjsonata PUBLIC JSONATA_QT_ENABLED )
+
+    target_link_libraries(qjsonata PUBLIC Qt6::Core)
 endif()
 
 # Optionally build tests
-option(JSONATA_BUILD_TESTS "Build JSONata C++ tests" OFF)
+option(JSONATA_BUILD_TESTS "Build QJSONata C++ tests" OFF)
 
 if(JSONATA_BUILD_TESTS)
     # Download GoogleTest if not already present
     # See https://google.github.io/googletest/quickstart-cmake.html
     FetchContent_Declare(
-            googletest
-            URL                    https://github.com/google/googletest/archive/refs/tags/v1.17.0.zip
-            DOWNLOAD_EXTRACT_TIMESTAMP true
+        googletest
+        URL https://github.com/google/googletest/archive/refs/tags/v1.17.0.zip
+        DOWNLOAD_EXTRACT_TIMESTAMP true
     )
     FetchContent_MakeAvailable(googletest)
 
@@ -121,100 +149,130 @@ if(JSONATA_BUILD_TESTS)
         test/TypesTest.cpp
     )
 
-    # Create main test executable
-    add_executable(
-      jsonata_tests
-      ${TEST_SOURCES}
-    )
-
-    target_link_libraries(
-      jsonata_tests
-      jsonata
-      gtest_main
-      gtest
-      Threads::Threads
-    )
+    # Create main test executables
+    foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
+        # 1. Strip the extension to create a clean executable name
+        string(REPLACE "::" "_" CLEAN_BE ${BE})
+        set(EXE_NAME qjsonata_tests_${CLEAN_BE})
+
+        # 2. Create the executable
+        add_executable(
+            ${EXE_NAME}
+            ${TEST_SOURCES}
+        )
+
+        target_compile_definitions(${EXE_NAME} PRIVATE
+            JSONATA_TEST_BACKEND=${BE}
+        )
+
+        target_link_libraries(
+            ${EXE_NAME}
+            qjsonata
+            gtest_main
+            gtest
+            Threads::Threads
+        )
+    endforeach()
 
     # Create test generator executable
-    add_executable(generate test/Generate.cpp)
-    target_link_libraries(generate jsonata)
+    add_executable(qgenerate test/Generate.cpp)
+    target_link_libraries(qgenerate qjsonata)
+    target_compile_definitions(qgenerate PRIVATE
+        JSONATA_TEST_BACKEND=${BE}
+    )
 
     # Custom command to generate test files
     add_custom_command(
         OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/test/gen/generated.stamp
-        COMMAND $<TARGET_FILE:generate>
+        COMMAND $<TARGET_FILE:qgenerate>
         COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_SOURCE_DIR}/test/gen/generated.stamp
-        DEPENDS generate
+        DEPENDS qgenerate
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        COMMENT "Generating JSONata test files from test suite"
+        COMMENT "Generating QJSONata test files from test suite"
     )
 
     # Custom target that depends on the generated files
-    add_custom_target(generate_tests 
+    add_custom_target(qgenerate_tests
         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/test/gen/generated.stamp
     )
 
-    # Make sure generated tests are created before building main tests
-    add_dependencies(jsonata_tests generate_tests)
+    foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
+        # 1. Strip the extension to create a clean executable name
+        string(REPLACE "::" "_" CLEAN_BE ${BE})
+        set(EXE_NAME qjsonata_tests_${CLEAN_BE})
+        # Make sure generated tests are created before building main tests
+        add_dependencies(${EXE_NAME} qgenerate_tests)
+    endforeach()
 
     # Convenience target to just run the generator
     add_custom_target(run_generator
-        COMMAND $<TARGET_FILE:generate>
-        DEPENDS generate
+        COMMAND $<TARGET_FILE:qgenerate>
+        DEPENDS qgenerate
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        COMMENT "Running JSONata test generator"
+        COMMENT "Running QJSONata test generator"
     )
 
     # Option to build generated tests as separate executables
-    option(BUILD_GENERATED_TESTS "Build generated JSONata test suites" ON)
+    option(BUILD_GENERATED_TESTS "Build generated QJSONata test suites" ON)
 
     if(BUILD_GENERATED_TESTS)
-        # Find all generated test files
-        file(GLOB GENERATED_TEST_FILES "${CMAKE_CURRENT_SOURCE_DIR}/test/gen/*Test.cpp")
+        foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
+            # 1. Strip the extension to create a clean executable name
+            string(REPLACE "::" "_" CLEAN_BE ${BE})
+            set(EXE_NAME qjsonata_generated_tests_${CLEAN_BE})
+
+            # Find all generated test files
+            file(GLOB GENERATED_TEST_FILES "${CMAKE_CURRENT_SOURCE_DIR}/test/gen/*Test.cpp")
         
-        if(GENERATED_TEST_FILES)
-            # Create executable for generated tests
-            add_executable(jsonata_generated_tests ${GENERATED_TEST_FILES} test/JsonataTest.cpp)
-            target_include_directories(jsonata_generated_tests PRIVATE test)
-            target_link_libraries(jsonata_generated_tests 
-                jsonata
-                gtest_main 
-                gtest 
-                Threads::Threads
-            )
-            # Windows-only: increase stack size to 8MB for generated tests
-            if(WIN32)
-                if(MSVC)
-                    target_link_options(jsonata_generated_tests PRIVATE /STACK:8388608)
-                else()
-                    target_link_options(jsonata_generated_tests PRIVATE -Wl,--stack,8388608)
-                endif()
-            endif()
-            add_dependencies(jsonata_generated_tests generate_tests)
-            
-            # Add to testing (only if Google Test is available)
-            if(TARGET gtest)
-                include(GoogleTest)
-                gtest_discover_tests(jsonata_generated_tests
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            if(GENERATED_TEST_FILES)
+                # Create executable for generated tests
+                add_executable(${EXE_NAME} ${GENERATED_TEST_FILES} test/JsonataTest.cpp)
+                target_compile_definitions(${EXE_NAME} PRIVATE
+                    JSONATA_TEST_BACKEND=${BE}
+                )
+                target_include_directories(${EXE_NAME} PRIVATE test)
+                target_link_libraries(${EXE_NAME}
+                    qjsonata
+                    gtest_main
+                    gtest
+                    Threads::Threads
                 )
+                # Windows-only: increase stack size to 8MB for generated tests
+                if(WIN32)
+                    if(MSVC)
+                        target_link_options(${EXE_NAME} PRIVATE /STACK:8388608)
+                    else()
+                        target_link_options(${EXE_NAME} PRIVATE -Wl,--stack,8388608)
+                    endif()
+                endif()
+                add_dependencies(${EXE_NAME} qgenerate_tests)
+
+                # Add to testing (only if Google Test is available)
+                if(TARGET gtest)
+                    include(GoogleTest)
+                    gtest_discover_tests(${EXE_NAME}
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                    )
+                endif()
             endif()
-        endif()
+        endforeach()
     endif()
 endif()
 
 # Installation rules
 if(JSONATA_USED_FETCHCONTENT_JSON)
-    install(TARGETS jsonata nlohmann_json
-        EXPORT jsonataTargets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-    )
+    if( JSONATA_NLOHMANN_BACKEND)
+        install(TARGETS qjsonata nlohmann_json
+            EXPORT qjsonataTargets
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+            INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        )
+endif()
 else()
-    install(TARGETS jsonata 
-        EXPORT jsonataTargets
+    install(TARGETS qjsonata
+        EXPORT qjsonataTargets
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
@@ -226,37 +284,42 @@ install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 install(DIRECTORY third_party/utfcpp/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
 # Export targets for the install-tree
-install(EXPORT jsonataTargets
-    FILE jsonataTargets.cmake
-    NAMESPACE jsonata::
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsonata
+install(EXPORT qjsonataTargets
+    FILE qjsonataTargets.cmake
+    NAMESPACE qjsonata::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/qjsonata
 )
 
 # Generate and install package config + version files
 include(CMakePackageConfigHelpers)
 write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/jsonataConfigVersion.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/qjsonataConfigVersion.cmake"
     VERSION ${PROJECT_VERSION}
     COMPATIBILITY SameMajorVersion
 )
 
 configure_package_config_file(
     cmake/jsonataConfig.cmake.in
-    "${CMAKE_CURRENT_BINARY_DIR}/jsonataConfig.cmake"
-    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsonata
+    "${CMAKE_CURRENT_BINARY_DIR}/qjsonataConfig.cmake"
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/qjsonata
 )
 
 install(FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/jsonataConfig.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/jsonataConfigVersion.cmake"
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsonata
+    "${CMAKE_CURRENT_BINARY_DIR}/qjsonataConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/qjsonataConfigVersion.cmake"
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/qjsonata
 )
 
 # Enable testing with Google Test
 if(JSONATA_BUILD_TESTS)
-    enable_testing()
-    include(GoogleTest)
-    gtest_discover_tests(jsonata_tests
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
+    foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
+        # 1. Strip the extension to create a clean executable name
+        string(REPLACE "::" "_" CLEAN_BE ${BE})
+        set(EXE_NAME qjsonata_tests_${CLEAN_BE})
+        enable_testing()
+        include(GoogleTest)
+        gtest_discover_tests(${EXE_NAME}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+    endforeach()
 endif()
diff --git a/include/jsonata/Functions.h b/include/jsonata/Functions.h
index f71bcd9..2687713 100644
--- a/include/jsonata/Functions.h
+++ b/include/jsonata/Functions.h
@@ -20,7 +20,7 @@
 
 #include <any>
 #include <functional>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <optional>
 #include <regex>
 #include <sstream>
@@ -133,7 +133,7 @@ class Functions {
                                           const std::string& char_ = " ");
     static std::optional<std::string> formatNumber(
         double value, const std::string& picture,
-        const nlohmann::ordered_map<std::string, std::any>& options = {});
+        const jsonata::backend::ordered_map<std::string, std::any>& options = {});
     static std::any shuffle(const Utils::JList& args);
     static std::any lookup(const std::any& input, const std::string& key);
     static void error(const std::string& message);
@@ -195,7 +195,7 @@ class Functions {
             : implementation(impl), signature(sig) {}
     };
 
-    static nlohmann::ordered_map<std::string, FunctionEntry>
+    static jsonata::backend::ordered_map<std::string, FunctionEntry>
     getFunctionRegistry();
     static std::any applyFunction(const std::string& name,
                                   const Utils::JList& args);
@@ -233,7 +233,7 @@ class Functions {
     static std::string safeReplaceAllFn(const std::string& str,
                                         const std::regex& pattern,
                                         const std::any& func);
-    static nlohmann::ordered_map<std::string, std::any> toJsonataMatch(
+    static jsonata::backend::ordered_map<std::string, std::any> toJsonataMatch(
         const std::smatch& match);
     static std::string encodeURI(const std::string& uri);
     static std::string leftPad(const std::string& str, int64_t size,
@@ -257,7 +257,7 @@ class Functions {
     };
 
     static FormatSymbols processOptionsArg(
-        const nlohmann::ordered_map<std::string, std::any>& options);
+        const jsonata::backend::ordered_map<std::string, std::any>& options);
     static std::string getFormattingCharacter(const std::string& value,
                                               const std::string& propertyName,
                                               bool isChar);
diff --git a/include/jsonata/JException.h b/include/jsonata/JException.h
index 3388573..2334a9a 100644
--- a/include/jsonata/JException.h
+++ b/include/jsonata/JException.h
@@ -19,11 +19,8 @@
 #pragma once
 
 #include <any>
-#include <nlohmann/json.hpp>
 #include <stdexcept>
 #include <string>
-#include <vector>
-
 // Include Utils for JList
 #include "Utils.h"
 
diff --git a/include/jsonata/Jsonata.h b/include/jsonata/Jsonata.h
index 68db659..5e8bf7f 100644
--- a/include/jsonata/Jsonata.h
+++ b/include/jsonata/Jsonata.h
@@ -25,11 +25,11 @@
  */
 #pragma once
 
+#include "jsonata/backends.h"
 #include <any>
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <nlohmann/json.hpp>
 #include <optional>
 #include <string>
 #include <vector>
@@ -37,477 +37,680 @@
 #include "jsonata/Parser.h"
 
 // Forward declarations
-namespace jsonata {
-class JException;
-namespace utils {
-class Signature;
-}
-namespace json {
-struct JsonValue;
-}
-}  // namespace jsonata
-
-namespace jsonata {
-
-// Forward declaration for callback types
-class Frame;
-using EntryCallback = std::function<void(
-    std::shared_ptr<Parser::Symbol>, const std::any&, std::shared_ptr<Frame>)>;
-using ExitCallback =
-    std::function<void(std::shared_ptr<Parser::Symbol>, const std::any&,
-                       std::shared_ptr<Frame>, const std::any&)>;
-
-/**
+namespace jsonata
+{
+    class JException;
+    namespace utils { class Signature; }
+    namespace json { struct JsonValue; }
+} // namespace jsonata
+
+namespace jsonata
+{
+    // Forward declaration for callback types
+    class Frame;
+    using EntryCallback = std::
+        function<void(std::shared_ptr<Parser::Symbol>, const std::any &, std::shared_ptr<Frame>)>;
+    using ExitCallback = std::function<void(
+        std::shared_ptr<Parser::Symbol>, const std::any &, std::shared_ptr<Frame>, const std::any &)>;
+
+    /**
  * Frame class for variable bindings and scope management
  */
-class Frame {
-  private:
-    std::shared_ptr<Frame> parent_;
-    nlohmann::ordered_map<std::string, std::any> bindings_;
-    std::chrono::time_point<std::chrono::steady_clock> timestamp_;
-    int64_t timeout_;
-    int64_t recursionDepth_;
-    EntryCallback entryCallback_;
-    ExitCallback exitCallback_;
-    std::unique_ptr<class Timebox> timebox_;
-
-  public:
-    bool isParallelCall = false;
-
-  public:
-    // Constructors
-    Frame();
-    Frame(std::shared_ptr<Frame> parent);
-
-    // Variable binding and lookup
-    void bind(const std::string& name, const std::any& value);
-    std::any lookup(const std::string& name) const;
-
-    // Runtime bounds
-    void setRuntimeBounds(int64_t timeout, int64_t maxRecursionDepth);
-
-    // Evaluation callbacks
-    void setEvaluateEntryCallback(EntryCallback callback);
-    void setEvaluateExitCallback(ExitCallback callback);
-
-    // Parent access
-    std::shared_ptr<Frame> getParent() const { return parent_; }
-
-    // Bindings access
-    const nlohmann::ordered_map<std::string, std::any>& getBindings() const {
-        return bindings_;
-    }
-};
+    class Frame
+    {
+        private:
+            std::shared_ptr<Frame> parent_;
+            jsonata::backend::ordered_map<std::string, std::any> bindings_;
+            std::chrono::time_point<std::chrono::steady_clock> timestamp_;
+            int64_t timeout_;
+            int64_t recursionDepth_;
+            EntryCallback entryCallback_;
+            ExitCallback exitCallback_;
+            std::unique_ptr<class Timebox> timebox_;
+
+        public:
+            bool isParallelCall = false;
+
+        public:
+            // Constructors
+            Frame();
+            Frame(std::shared_ptr<Frame> parent);
+
+            // Variable binding and lookup
+            void bind(const std::string &name, const std::any &value);
+            std::any lookup(const std::string &name) const;
+
+            // Runtime bounds
+            void setRuntimeBounds(int64_t timeout, int64_t maxRecursionDepth);
+
+            // Evaluation callbacks
+            void setEvaluateEntryCallback(EntryCallback callback);
+            void setEvaluateExitCallback(ExitCallback callback);
+
+            // Parent access
+            std::shared_ptr<Frame> getParent() const { return parent_; }
+
+            // Bindings access
+            const jsonata::backend::ordered_map<std::string, std::any> &getBindings() const
+            {
+                return bindings_;
+            }
+    };
 
-/**
+    /**
  * Function types for JSONata functions
  */
-class JFunction {
-  public:
-    std::function<std::any(const Utils::JList&, const std::any&,
-                           std::shared_ptr<Frame>)>
-        implementation;
-    std::shared_ptr<utils::Signature> signature;
-
-    JFunction() = default;
-    JFunction(std::function<std::any(const Utils::JList&, const std::any&,
-                                     std::shared_ptr<Frame>)>
-                  impl)
-        : implementation(impl) {}
-
-    virtual ~JFunction() = default;
-};
+    class JFunction
+    {
+        public:
+            std::function<std::any(const Utils::JList &, const std::any &, std::shared_ptr<Frame>)>
+                implementation;
+            std::shared_ptr<utils::Signature> signature;
+
+            JFunction() = default;
+            JFunction(std::function<std::any(
+                          const Utils::JList &, const std::any &, std::shared_ptr<Frame>)> impl)
+                : implementation(impl)
+            {}
+
+            virtual ~JFunction() = default;
+    };
 
-/**
+    /**
  * Main Jsonata evaluator class
  */
-class Jsonata {
-  public:
-    // Constructors
-    Jsonata();
-    Jsonata(const std::string& jsonataExpression);
-    Jsonata(const Jsonata& other);  // Copy constructor for per-thread instances
-
-    // Main evaluation methods (ordered JSON variants)
-    nlohmann::ordered_json evaluate(const nlohmann::ordered_json& input);
-    nlohmann::ordered_json evaluate(const nlohmann::ordered_json& input,
-                                    std::shared_ptr<Frame> bindings);
-    nlohmann::ordered_json evaluate(std::nullptr_t);
-    nlohmann::ordered_json evaluate(std::nullptr_t,
-                                    std::shared_ptr<Frame> bindings);
-
-    // Main evaluation methods (unordered nlohmann::json variants)
-    nlohmann::json evaluate(const nlohmann::json& input);
-    nlohmann::json evaluate(const nlohmann::json& input,
-                            std::shared_ptr<Frame> bindings);
-    nlohmann::json evaluateUnordered(std::nullptr_t);
-    nlohmann::json evaluateUnordered(std::nullptr_t,
-                                     std::shared_ptr<Frame> bindings);
-    std::any evaluate(std::shared_ptr<Parser::Symbol> expr,
-                      const std::any& input,
-                      std::shared_ptr<Frame> environment);
-
-    // Environment access
-    std::shared_ptr<Frame> getEnvironment() const;
-
-    // Factory methods
-    static Jsonata jsonata(const std::string& expression);
-
-    // Instance methods (matching Java reference)
-    std::shared_ptr<Frame> createFrame();
-    std::shared_ptr<Frame> createFrame(
-        std::shared_ptr<Frame> enclosingEnvironment);
-
-    // Parse expression
-    std::shared_ptr<Parser::Symbol> parse(const std::string& expression);
-
-    // Debug helper
-    std::shared_ptr<Parser::Symbol> getExpression() const {
-        return expression_;
-    }
-
-    // Lambda function application support
-    std::any apply(const std::any& lambda, const Utils::JList& args,
-                   const std::any& input, std::shared_ptr<Frame> environment);
-    std::any applyInner(const std::any& proc, const Utils::JList& args,
-                        const std::any& input,
-                        std::shared_ptr<Frame> environment);
-    std::any applyProcedure(const std::any& proc, const Utils::JList& args);
-    Utils::JList validateArguments(const std::any& signature,
-                                   const Utils::JList& args,
-                                   const std::any& context);
-
-    // Partial application support (matching Java implementation)
-    std::any partialApplyProcedure(std::shared_ptr<class Parser::Symbol> proc,
-                                   const Utils::JList& args);
-    std::any partialApplyNativeFunction(const std::any& native,
-                                        const Utils::JList& args,
-                                        const std::string& functionName);
-
-    // Thread-local instances (matching Java implementation)
-    static thread_local Jsonata* currentInstance_;
-    // Owns the per-thread clone created by getPerThreadInstance(); ensures
-    // deletion on thread exit and avoids manual cleanup.
-    static thread_local std::unique_ptr<Jsonata> ownedInstance_;
-    // Optional: explicitly clear the per-thread instance before thread exit.
-    static void clearPerThreadInstance();
-
-    std::shared_ptr<Frame> environment_;
-    static thread_local std::shared_ptr<class Parser> currentParser_;
-    static thread_local std::any tls_input_;
-    static thread_local std::shared_ptr<Frame> tls_environment_;
-    static Jsonata* getCurrentInstance();
-    static std::shared_ptr<class Parser> getCurrentParser();
-    Jsonata* getPerThreadInstance();
-
-    // Public accessors for thread-local context (used by Functions)
-    const std::any& getCurrentInput() const { return tls_input_; }
-    std::shared_ptr<Frame> getCurrentEnvironment() const {
-        return tls_environment_;
-    }
-
-    // Missing public API methods from Java
-    void assign(const std::string& name, const std::any& value);
-    void registerFunction(const std::string& name,
-                          const JFunction& implementation);
-    void registerFunction(
-        const std::string& name,
-        std::function<std::any(const Utils::JList&)> implementation);
-
-    // Type-safe function registration overloads (equivalent to Java's Fn0<R>,
-    // Fn1<A,R>, etc.)
-    template <typename R>
-    void registerFunction(const std::string& name,
-                          std::function<R()> implementation);
-
-    template <typename A, typename R>
-    void registerFunction(const std::string& name,
-                          std::function<R(A)> implementation);
-
-    template <typename A, typename B, typename R>
-    void registerFunction(const std::string& name,
-                          std::function<R(A, B)> implementation);
-
-    template <typename A, typename B, typename C, typename R>
-    void registerFunction(const std::string& name,
-                          std::function<R(A, B, C)> implementation);
-
-    template <typename A, typename B, typename C, typename D, typename R>
-    void registerFunction(const std::string& name,
-                          std::function<R(A, B, C, D)> implementation);
-
-  public:
-    // Function-like detection (Java reference: line 1551)
-    bool isFunctionLike(const std::any& o) const;
-
-    // Input validation control
-    bool isValidateInput() const;
-    void setValidateInput(bool validateInput);
-
-    // Error handling
-    std::vector<std::exception_ptr> getErrors() const;
-
-    // Utility methods
-    static bool boolize(const std::any& value);
-
-  public:
-    std::unique_ptr<Parser> parser_;
+    class Jsonata
+    {
+        public:
+            // Constructors
+            Jsonata();
+            Jsonata(const std::string &jsonataExpression);
+            Jsonata(const Jsonata &other); // Copy constructor for per-thread instances
+
+            template <typename T>
+                requires isCompatible<T>
+            static T parse( const std::string & s ) {
+                return T::parse( s );
+            }
+
+            // Main evaluation methods
+            template<typename T>
+                requires isCompatible<T>
+            T evaluate(const T &input, std::shared_ptr<Frame> bindings)
+            {
+                currentInstance_ = this;
+
+                // Check for syntax errors (equivalent to Java's check for errors != null)
+                if (!expression_) {
+                    throw JException("S0500", 0); // Expression compilation failed
+                }
+
+                // Convert JSON input to std::any domain for the evaluator
+                std::any result;
+                try {
+                    // Set thread-local input/environment for this evaluation
+                    std::any anyInput = toAny(input);
+                    result = evaluate(anyInput, bindings);
+                    return fromAny<T>(result);
+                } catch (const std::exception &err) {
+                    // TODO: populateMessage(err);
+                    throw;
+                }
+            }
+
+            template<typename T>
+                requires isCompatible<T>
+            inline T evaluate(const T &input)
+            {
+                return evaluate(input, nullptr);
+            }
+            template<typename T>
+                requires isCompatible<T>
+            T evaluate(std::nullptr_t)
+            {
+                return evaluate(T());
+            }
+            template<typename T>
+                requires isCompatible<T>
+            T evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings)
+            {
+                return evaluate(T(), bindings);
+            }
+
+            // Main evaluation methods (ordered JSON variants)
+            // jsonata::backend::ordered_json evaluate(const jsonata::backend::ordered_json &input);
+            // jsonata::backend::ordered_json evaluate(const jsonata::backend::ordered_json &input,
+            //                                         std::shared_ptr<Frame> bindings);
+            // jsonata::backend::ordered_json evaluate(std::nullptr_t);
+            // jsonata::backend::ordered_json evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings);
+
+            // // Main evaluation methods (unordered jsonata::backend::json variants)
+            // jsonata::backend::json evaluate(const jsonata::backend::json &input);
+            // jsonata::backend::json evaluate(const jsonata::backend::json &input,
+            //                                 std::shared_ptr<Frame> bindings);
+            // jsonata::backend::json evaluateUnordered(std::nullptr_t);
+            // jsonata::backend::json evaluateUnordered(std::nullptr_t,
+            //                                          std::shared_ptr<Frame> bindings);
+
+            std::any evaluate(std::shared_ptr<Parser::Symbol> expr,
+                              const std::any &input,
+                              std::shared_ptr<Frame> environment);
 
-    static std::shared_ptr<Frame> staticFrame_;
-    static std::shared_ptr<Frame> getStaticFrame();
-    static void initializeBuiltinFunctions(std::shared_ptr<Frame> frame);
+            // Environment access
+            std::shared_ptr<Frame> getEnvironment() const;
 
-    // New members for string constructor
-    std::shared_ptr<Parser::Symbol> expression_;
+            // Factory methods
+            static Jsonata jsonata(const std::string &expression);
 
-    bool validateInput_ = false;
-    std::vector<std::exception_ptr> errors_;
-    int64_t timestamp_ = 0;
+            // Instance methods (matching Java reference)
+            std::shared_ptr<Frame> createFrame();
+            std::shared_ptr<Frame> createFrame(std::shared_ptr<Frame> enclosingEnvironment);
 
-    // Current evaluation context is stored in thread-local variables
+            // Parse expression
+            std::shared_ptr<Parser::Symbol> parse(const std::string &expression);
 
-    // GroupEntry structure for object grouping (matches Java implementation)
-    struct GroupEntry {
-        std::any data;
-        size_t exprIndex;
-    };
+            // Debug helper
+            std::shared_ptr<Parser::Symbol> getExpression() const { return expression_; }
 
-    // Core evaluation method
-    std::any _evaluate(std::shared_ptr<Parser::Symbol> expr,
-                       const std::any& input,
-                       std::shared_ptr<Frame> environment);
-
-    // Expression evaluation methods
-    std::any evaluateLiteral(std::shared_ptr<Parser::Symbol> expr);
-    std::any evaluateName(std::shared_ptr<Parser::Symbol> expr,
-                          const std::any& input,
-                          std::shared_ptr<Frame> environment);
-    std::any evaluateVariable(std::shared_ptr<Parser::Symbol> expr,
-                              const std::any& input,
-                              std::shared_ptr<Frame> environment);
-    std::any evaluateBinary(std::shared_ptr<Parser::Symbol> expr,
-                            const std::any& input,
-                            std::shared_ptr<Frame> environment);
-    std::any evaluateUnary(std::shared_ptr<Parser::Symbol> expr,
-                           const std::any& input,
-                           std::shared_ptr<Frame> environment);
-    std::any evaluateFunction(std::shared_ptr<Parser::Symbol> expr,
-                              const std::any& input,
-                              std::shared_ptr<Frame> environment);
-    std::any evaluateFunctionWithContext(std::shared_ptr<Parser::Symbol> expr,
-                                         const std::any& input,
-                                         std::shared_ptr<Frame> environment,
-                                         const std::any& applytoContext);
-    std::any evaluateRegex(std::shared_ptr<Parser::Symbol> expr,
-                           const std::any& input,
+            // Lambda function application support
+            std::any apply(const std::any &lambda,
+                           const Utils::JList &args,
+                           const std::any &input,
                            std::shared_ptr<Frame> environment);
-    std::any evaluateWildcard(std::shared_ptr<Parser::Symbol> expr,
-                              const std::any& input);
-    std::any flatten(const std::any& arg, Utils::JList* flattened = nullptr);
-    std::any evaluateFilter(std::shared_ptr<Parser::Symbol> predicate,
-                            const std::any& input,
-                            std::shared_ptr<Frame> environment);
-    std::any evaluatePath(std::shared_ptr<Parser::Symbol> expr,
-                          const std::any& input,
-                          std::shared_ptr<Frame> environment);
-    std::any evaluateCondition(std::shared_ptr<Parser::Symbol> expr,
-                               const std::any& input,
-                               std::shared_ptr<Frame> environment);
-    std::any evaluateDescendant(std::shared_ptr<Parser::Symbol> expr,
-                                const std::any& input,
+            std::any applyInner(const std::any &proc,
+                                const Utils::JList &args,
+                                const std::any &input,
                                 std::shared_ptr<Frame> environment);
-    void recurseDescendants(const std::any& input,
-                            std::vector<std::any>& results);
-    std::any evaluateApply(std::shared_ptr<Parser::Symbol> expr,
-                           const std::any& input,
-                           std::shared_ptr<Frame> environment);
-    std::any evaluateRange(std::shared_ptr<Parser::Symbol> expr,
-                           const std::any& input,
-                           std::shared_ptr<Frame> environment);
-    std::any evaluateBind(std::shared_ptr<Parser::Symbol> expr,
-                          const std::any& input,
-                          std::shared_ptr<Frame> environment);
-    std::any evaluateLambda(std::shared_ptr<Parser::Symbol> expr,
-                            const std::any& input,
-                            std::shared_ptr<Frame> environment);
-    std::any evaluateSort(std::shared_ptr<Parser::Symbol> expr,
-                          const std::any& input,
-                          std::shared_ptr<Frame> environment);
-    std::any evaluateTransform(std::shared_ptr<Parser::Symbol> expr,
-                               const std::any& input,
+            std::any applyProcedure(const std::any &proc, const Utils::JList &args);
+            Utils::JList validateArguments(const std::any &signature,
+                                           const Utils::JList &args,
+                                           const std::any &context);
+
+            // Partial application support (matching Java implementation)
+            std::any partialApplyProcedure(std::shared_ptr<class Parser::Symbol> proc,
+                                           const Utils::JList &args);
+            std::any partialApplyNativeFunction(const std::any &native,
+                                                const Utils::JList &args,
+                                                const std::string &functionName);
+
+            // Thread-local instances (matching Java implementation)
+            static thread_local Jsonata *currentInstance_;
+            // Owns the per-thread clone created by getPerThreadInstance(); ensures
+            // deletion on thread exit and avoids manual cleanup.
+            static thread_local std::unique_ptr<Jsonata> ownedInstance_;
+            // Optional: explicitly clear the per-thread instance before thread exit.
+            static void clearPerThreadInstance();
+
+            std::shared_ptr<Frame> environment_;
+            static thread_local std::shared_ptr<class Parser> currentParser_;
+            static thread_local std::any tls_input_;
+            static thread_local std::shared_ptr<Frame> tls_environment_;
+            static Jsonata *getCurrentInstance();
+            static std::shared_ptr<class Parser> getCurrentParser();
+            Jsonata *getPerThreadInstance();
+
+            // Public accessors for thread-local context (used by Functions)
+            const std::any &getCurrentInput() const { return tls_input_; }
+            std::shared_ptr<Frame> getCurrentEnvironment() const { return tls_environment_; }
+
+            // Missing public API methods from Java
+            void assign(const std::string &name, const std::any &value);
+            void registerFunction(const std::string &name, const JFunction &implementation);
+            void registerFunction(const std::string &name,
+                                  std::function<std::any(const Utils::JList &)> implementation);
+
+            // Type-safe function registration overloads (equivalent to Java's Fn0<R>,
+            // Fn1<A,R>, etc.)
+            template<typename R>
+            void registerFunction(const std::string &name, std::function<R()> implementation);
+
+            template<typename A, typename R>
+            void registerFunction(const std::string &name, std::function<R(A)> implementation);
+
+            template<typename A, typename B, typename R>
+            void registerFunction(const std::string &name, std::function<R(A, B)> implementation);
+
+            template<typename A, typename B, typename C, typename R>
+            void registerFunction(const std::string &name, std::function<R(A, B, C)> implementation);
+
+            template<typename A, typename B, typename C, typename D, typename R>
+            void registerFunction(const std::string &name,
+                                  std::function<R(A, B, C, D)> implementation);
+
+        private :
+
+            // helper
+            std::any evaluate( const std::any input, std::shared_ptr<Frame> bindings );
+
+        public:
+            // Function-like detection (Java reference: line 1551)
+            bool isFunctionLike(const std::any &o) const;
+
+            // Input validation control
+            bool isValidateInput() const;
+            void setValidateInput(bool validateInput);
+
+            // Error handling
+            std::vector<std::exception_ptr> getErrors() const;
+
+            // Utility methods
+            static bool boolize(const std::any &value);
+
+        public:
+            std::unique_ptr<Parser> parser_;
+
+            static std::shared_ptr<Frame> staticFrame_;
+            static std::shared_ptr<Frame> getStaticFrame();
+            static void initializeBuiltinFunctions(std::shared_ptr<Frame> frame);
+
+            // New members for string constructor
+            std::shared_ptr<Parser::Symbol> expression_;
+
+            bool validateInput_ = false;
+            std::vector<std::exception_ptr> errors_;
+            int64_t timestamp_ = 0;
+
+            // Current evaluation context is stored in thread-local variables
+
+            // GroupEntry structure for object grouping (matches Java implementation)
+            struct GroupEntry
+            {
+                    std::any data;
+                    size_t exprIndex;
+            };
+
+            // Core evaluation method
+            std::any _evaluate(std::shared_ptr<Parser::Symbol> expr,
+                               const std::any &input,
                                std::shared_ptr<Frame> environment);
-    std::any evaluateParent(std::shared_ptr<Parser::Symbol> expr,
-                            const std::any& input,
-                            std::shared_ptr<Frame> environment);
-    std::any evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
-                           const std::any& input,
-                           std::shared_ptr<Frame> environment);
 
-    // Binary operation evaluators
-    std::any evaluateNumericExpression(const std::any& lhs, const std::any& rhs,
-                                       const std::string& op);
-    std::any evaluateComparisonExpression(const std::any& lhs,
-                                          const std::any& rhs,
-                                          const std::string& op);
-    bool deepEquals(const std::any& lhs, const std::any& rhs);
-    std::any evaluateEqualityExpression(const std::any& lhs,
-                                        const std::any& rhs,
-                                        const std::string& op);
-    std::any evaluateBooleanExpression(const std::any& lhs,
-                                       std::function<std::any()> rhs,
-                                       const std::string& op);
-    std::any evaluateStringConcat(const std::any& lhs, const std::any& rhs);
-    std::any evaluateRangeExpression(const std::any& lhs, const std::any& rhs);
-    std::any evaluateIncludesExpression(const std::any& lhs,
-                                        const std::any& rhs);
-
-    // Missing advanced evaluation methods from Java
-    std::any evaluateStages(
-        const std::vector<std::shared_ptr<Parser::Symbol>>& stages,
-        const std::any& input, std::shared_ptr<Frame> environment);
-    std::any evaluateStep(std::shared_ptr<Parser::Symbol> expr,
-                          const std::any& input,
-                          std::shared_ptr<Frame> environment,
-                          bool lastStep = false);
-    std::any evaluateTupleStep(std::shared_ptr<Parser::Symbol> expr,
-                               const Utils::JList& input,
-                               const std::optional<Utils::JList>& tupleBindings,
-                               std::shared_ptr<Frame> environment);
-    std::any evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
-                                     const std::any& input,
-                                     std::shared_ptr<Frame> environment);
-    std::any evaluateTransformExpression(std::shared_ptr<Parser::Symbol> expr,
-                                         const std::any& input,
-                                         std::shared_ptr<Frame> environment);
-    std::any evaluateApplyExpression(std::shared_ptr<Parser::Symbol> expr,
-                                     const std::any& input,
-                                     std::shared_ptr<Frame> environment);
-    std::any evaluatePartialApplication(std::shared_ptr<Parser::Symbol> expr,
-                                        const std::any& input,
+            // Expression evaluation methods
+            std::any evaluateLiteral(std::shared_ptr<Parser::Symbol> expr);
+            std::any evaluateName(std::shared_ptr<Parser::Symbol> expr,
+                                  const std::any &input,
+                                  std::shared_ptr<Frame> environment);
+            std::any evaluateVariable(std::shared_ptr<Parser::Symbol> expr,
+                                      const std::any &input,
+                                      std::shared_ptr<Frame> environment);
+            std::any evaluateBinary(std::shared_ptr<Parser::Symbol> expr,
+                                    const std::any &input,
+                                    std::shared_ptr<Frame> environment);
+            std::any evaluateUnary(std::shared_ptr<Parser::Symbol> expr,
+                                   const std::any &input,
+                                   std::shared_ptr<Frame> environment);
+            std::any evaluateFunction(std::shared_ptr<Parser::Symbol> expr,
+                                      const std::any &input,
+                                      std::shared_ptr<Frame> environment);
+            std::any evaluateFunctionWithContext(std::shared_ptr<Parser::Symbol> expr,
+                                                 const std::any &input,
+                                                 std::shared_ptr<Frame> environment,
+                                                 const std::any &applytoContext);
+            std::any evaluateRegex(std::shared_ptr<Parser::Symbol> expr,
+                                   const std::any &input,
+                                   std::shared_ptr<Frame> environment);
+            std::any evaluateWildcard(std::shared_ptr<Parser::Symbol> expr, const std::any &input);
+            std::any flatten(const std::any &arg, Utils::JList *flattened = nullptr);
+            std::any evaluateFilter(std::shared_ptr<Parser::Symbol> predicate,
+                                    const std::any &input,
+                                    std::shared_ptr<Frame> environment);
+            std::any evaluatePath(std::shared_ptr<Parser::Symbol> expr,
+                                  const std::any &input,
+                                  std::shared_ptr<Frame> environment);
+            std::any evaluateCondition(std::shared_ptr<Parser::Symbol> expr,
+                                       const std::any &input,
+                                       std::shared_ptr<Frame> environment);
+            std::any evaluateDescendant(std::shared_ptr<Parser::Symbol> expr,
+                                        const std::any &input,
                                         std::shared_ptr<Frame> environment);
-
-    std::shared_ptr<Frame> createFrameFromTuple(
-        std::shared_ptr<Frame> environment, const std::any& tupleAny);
-    std::any reduceTupleStream(const std::any& tupleStream);
-
-    // Conversion helpers between engine types and JSON
-    // Ordered variants preserve insertion order using nlohmann::ordered_json
-    static std::any orderedJsonToAny(const nlohmann::ordered_json& j);
-    static nlohmann::ordered_json anyToOrderedJson(const std::any& value);
-    // Unordered variants using nlohmann::json (key order may not be preserved)
-    static std::any jsonToAny(const nlohmann::json& j);
-    static nlohmann::json anyToJson(const std::any& value);
-
-    // Error code mappings
-    void initializeErrorCodes();
-};
-
-// Global static methods
-std::any jsonata_evaluate(const std::string& expression, const std::any& input);
-
-// Template implementations (must be in header for templates)
-
-template <typename R>
-void Jsonata::registerFunction(const std::string& name,
-                               std::function<R()> implementation) {
-    auto wrapper = [implementation](const std::vector<std::any>&) -> std::any {
-        if constexpr (std::is_void_v<R>) {
-            implementation();
-            return std::any{};
-        } else {
-            return std::any(implementation());
-        }
-    };
-    registerFunction(name, wrapper);
-}
-
-template <typename A, typename R>
-void Jsonata::registerFunction(const std::string& name,
-                               std::function<R(A)> implementation) {
-    auto wrapper = [implementation,
-                    name](const std::vector<std::any>& args) -> std::any {
-        if (args.empty()) {
-            throw JException("S0410", -1,
-                             "Function " + name + " expects 1 argument, got 0");
-        }
-        A arg = std::any_cast<A>(args[0]);
-        if constexpr (std::is_void_v<R>) {
-            implementation(arg);
-            return std::any{};
-        } else {
-            return std::any(implementation(arg));
-        }
-    };
-    registerFunction(name, wrapper);
-}
-
-template <typename A, typename B, typename R>
-void Jsonata::registerFunction(const std::string& name,
-                               std::function<R(A, B)> implementation) {
-    auto wrapper = [implementation,
-                    name](const std::vector<std::any>& args) -> std::any {
-        if (args.size() < 2) {
-            throw JException("S0410", -1,
-                             "Function " + name + " expects 2 arguments, got " +
-                                 std::to_string(args.size()));
-        }
-        A arg1 = std::any_cast<A>(args[0]);
-        B arg2 = std::any_cast<B>(args[1]);
-        if constexpr (std::is_void_v<R>) {
-            implementation(arg1, arg2);
-            return std::any{};
-        } else {
-            return std::any(implementation(arg1, arg2));
-        }
+            void recurseDescendants(const std::any &input, std::vector<std::any> &results);
+            std::any evaluateApply(std::shared_ptr<Parser::Symbol> expr,
+                                   const std::any &input,
+                                   std::shared_ptr<Frame> environment);
+            std::any evaluateRange(std::shared_ptr<Parser::Symbol> expr,
+                                   const std::any &input,
+                                   std::shared_ptr<Frame> environment);
+            std::any evaluateBind(std::shared_ptr<Parser::Symbol> expr,
+                                  const std::any &input,
+                                  std::shared_ptr<Frame> environment);
+            std::any evaluateLambda(std::shared_ptr<Parser::Symbol> expr,
+                                    const std::any &input,
+                                    std::shared_ptr<Frame> environment);
+            std::any evaluateSort(std::shared_ptr<Parser::Symbol> expr,
+                                  const std::any &input,
+                                  std::shared_ptr<Frame> environment);
+            std::any evaluateTransform(std::shared_ptr<Parser::Symbol> expr,
+                                       const std::any &input,
+                                       std::shared_ptr<Frame> environment);
+            std::any evaluateParent(std::shared_ptr<Parser::Symbol> expr,
+                                    const std::any &input,
+                                    std::shared_ptr<Frame> environment);
+            std::any evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
+                                   const std::any &input,
+                                   std::shared_ptr<Frame> environment);
+
+            // Binary operation evaluators
+            std::any evaluateNumericExpression(const std::any &lhs,
+                                               const std::any &rhs,
+                                               const std::string &op);
+            std::any evaluateComparisonExpression(const std::any &lhs,
+                                                  const std::any &rhs,
+                                                  const std::string &op);
+            bool deepEquals(const std::any &lhs, const std::any &rhs);
+            std::any evaluateEqualityExpression(const std::any &lhs,
+                                                const std::any &rhs,
+                                                const std::string &op);
+            std::any evaluateBooleanExpression(const std::any &lhs,
+                                               std::function<std::any()> rhs,
+                                               const std::string &op);
+            std::any evaluateStringConcat(const std::any &lhs, const std::any &rhs);
+            std::any evaluateRangeExpression(const std::any &lhs, const std::any &rhs);
+            std::any evaluateIncludesExpression(const std::any &lhs, const std::any &rhs);
+
+            // Missing advanced evaluation methods from Java
+            std::any evaluateStages(const std::vector<std::shared_ptr<Parser::Symbol>> &stages,
+                                    const std::any &input,
+                                    std::shared_ptr<Frame> environment);
+            std::any evaluateStep(std::shared_ptr<Parser::Symbol> expr,
+                                  const std::any &input,
+                                  std::shared_ptr<Frame> environment,
+                                  bool lastStep = false);
+            std::any evaluateTupleStep(std::shared_ptr<Parser::Symbol> expr,
+                                       const Utils::JList &input,
+                                       const std::optional<Utils::JList> &tupleBindings,
+                                       std::shared_ptr<Frame> environment);
+            std::any evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
+                                             const std::any &input,
+                                             std::shared_ptr<Frame> environment);
+            std::any evaluateTransformExpression(std::shared_ptr<Parser::Symbol> expr,
+                                                 const std::any &input,
+                                                 std::shared_ptr<Frame> environment);
+            std::any evaluateApplyExpression(std::shared_ptr<Parser::Symbol> expr,
+                                             const std::any &input,
+                                             std::shared_ptr<Frame> environment);
+            std::any evaluatePartialApplication(std::shared_ptr<Parser::Symbol> expr,
+                                                const std::any &input,
+                                                std::shared_ptr<Frame> environment);
+
+            std::shared_ptr<Frame> createFrameFromTuple(std::shared_ptr<Frame> environment,
+                                                        const std::any &tupleAny);
+            std::any reduceTupleStream(const std::any &tupleStream);
+
+            // Conversion helpers between engine types and JSON
+            // Ordered variants preserve insertion order using jsonata::backend::ordered_json
+            template<typename T>
+                requires isCompatible<T>
+            static std::any toAny(const T &j)
+            {
+                if (j.is_null())
+                    return std::any{};
+                if (j.is_boolean())
+                    return std::any(j.template get<bool>());
+                if (j.is_number_integer()) {
+                    // Preserve sign by using int64_t; for large unsigned, capture as
+                    // uint64_t
+                    int64_t si = 0;
+                    try {
+                        si = j.template get<int64_t>();
+                        return std::any(static_cast<int64_t>(si));
+                    } catch (...) {
+                    }
+                    uint64_t ui = j.template get<uint64_t>();
+                    return std::any(static_cast<uint64_t>(ui));
+                }
+                if (j.is_number_unsigned()) {
+                    uint64_t ui = j.template get<uint64_t>();
+                    return std::any(static_cast<uint64_t>(ui));
+                }
+                if (j.is_number_float())
+                    return std::any(j.template get<double>());
+                if (j.is_string())
+                    return std::any(j.template get<std::string>());
+                if (j.is_array()) {
+                    std::vector<std::any> out;
+                    out.reserve(j.size());
+                    jsonata::backend::copy(j, out, [](const T &el) { return toAny(el); });
+                    return out;
+                }
+                if (j.is_object()) {
+                    jsonata::backend::ordered_map<std::string, std::any> m;
+                    jsonata::backend::copy(j, m, [](const T &el) { return toAny(el); });
+                    return m;
+                }
+                return std::any{};
+            }
+
+            template<typename T>
+                requires isCompatible<T>
+            static T fromAny(const std::any &value)
+            {
+                if (!value.has_value())
+                    return T();
+
+                // Canonicalize numeric types: convert doubles with no fractional part to
+                // integer types
+                try {
+                    if (Utils::isNumeric(value)) {
+                        std::any canon = Utils::convertNumber(value);
+                        if (canon.type() != value.type()) {
+                            return fromAny<T>(canon);
+                        }
+                    }
+                } catch (...) {
+                    // Ignore conversion errors here; fall back to original value
+                }
+
+                const std::type_info &type = value.type();
+                if (type == typeid(bool))
+                    return T(std::any_cast<bool>(value));
+                if (type == typeid(double))
+                    return T(std::any_cast<double>(value));
+                if (type == typeid(int64_t))
+                    return T(std::any_cast<int64_t>(value));
+                if (type == typeid(uint64_t))
+                    return T(std::any_cast<uint64_t>(value));
+                // Cross-platform support for additional integral types (e.g., long/long long)
+                if (type == typeid(long long))
+                    return T(static_cast<int64_t>(std::any_cast<long long>(value)));
+                if (type == typeid(unsigned long long))
+                    return T(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
+                if (type == typeid(long))
+                    return T(static_cast<int64_t>(std::any_cast<long>(value)));
+                if (type == typeid(unsigned long))
+                    return T(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
+                if (type == typeid(int))
+                    return T(static_cast<int64_t>(std::any_cast<int>(value)));
+                if (type == typeid(unsigned int))
+                    return T(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
+                if (type == typeid(std::string))
+                    return T(std::any_cast<std::string>(value));
+                if (type == typeid(Utils::JList)) {
+                    auto arr = T::array();
+                    const auto &jlist = std::any_cast<const Utils::JList &>(value);
+                    jsonata::backend::copy(jlist, arr, [](const std::any &a) { return fromAny<T>(a); });
+                    return arr;
+                }
+                if (type == typeid(std::vector<std::any>)) {
+                    auto arr = T::array();
+                    const auto &vec = std::any_cast<const std::vector<std::any> &>(value);
+                    jsonata::backend::copy(vec, arr, [](const std::any &a) { return fromAny<T>(a); });
+                    return arr;
+                }
+                if (type == typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                    auto obj = T::object();
+                    const auto &map = std::
+                        any_cast<const jsonata::backend::ordered_map<std::string, std::any> &>(
+                            value);
+                    jsonata::backend::copy(map, obj, [](const std::any &a) { return fromAny<T>(a); });
+                    return obj;
+                }
+                if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
+                    return T();
+                }
+                // Directly handle jsonata::backend::ordered_json returned from custom functions
+                if (type == typeid(T)) {
+                    return std::any_cast<T>(value);
+                }
+
+                return T();
+            }
+
+            template<typename from, typename to >
+                requires isCompatible<from> && isCompatible<to>
+            static to convert( const from & oj ) {
+                // Recursive lambda to convert ordered_json to json
+                std::function<to(const from & )> convert = [&](const from & j) -> to {
+                    if (j.is_null()) return to();
+                    if (j.is_boolean()) return to(j.template get<bool>());
+                    if (j.is_number_integer()) {
+                        int64_t si = 0;
+                        try {
+                            si = j.template get<int64_t>();
+                            return to(static_cast<int64_t>(si));
+                        } catch (...) {
+                        }
+                        uint64_t ui = j.template get<uint64_t>();
+                        return to(static_cast<uint64_t>(ui));
+                    }
+                    if (j.is_number_unsigned())
+                        return to(j.template get<uint64_t>());
+                    if (j.is_number_float())
+                        return to(j.template get<double>());
+                    if (j.is_string())
+                        return to(j.template get<std::string>());
+                    if (j.is_array()) {
+                        to arr = to::array();
+                        jsonata::backend::copy( j, arr, [&convert]( const from& el ) {
+                            return convert(el );
+                        });
+                        return arr;
+                    }
+                    if (j.is_object()) {
+                        to obj = to::object();
+                        jsonata::backend::copy( j, obj, [&convert]( const from& el ) {
+                            return convert(el );
+                        });
+                        return obj;
+                    }
+                    return to();
+                };
+
+                return convert(oj);
+            }
+
+            // static std::any toAny(const jsonata::backend::ordered_json &j);
+            // static jsonata::backend::ordered_json fromAny(const std::any &value);
+            // // Unordered variants using jsonata::backend::json (key order may not be preserved)
+            // static std::any jsonToAny(const jsonata::backend::json &j);
+            // static jsonata::backend::json anyToJson(const std::any &value);
+
+            // Error code mappings
+            void initializeErrorCodes();
     };
-    registerFunction(name, wrapper);
-}
-
-template <typename A, typename B, typename C, typename R>
-void Jsonata::registerFunction(const std::string& name,
-                               std::function<R(A, B, C)> implementation) {
-    auto wrapper = [implementation,
-                    name](const std::vector<std::any>& args) -> std::any {
-        if (args.size() < 3) {
-            throw JException("S0410", -1,
-                             "Function " + name + " expects 3 arguments, got " +
-                                 std::to_string(args.size()));
-        }
-        A arg1 = std::any_cast<A>(args[0]);
-        B arg2 = std::any_cast<B>(args[1]);
-        C arg3 = std::any_cast<C>(args[2]);
-        if constexpr (std::is_void_v<R>) {
-            implementation(arg1, arg2, arg3);
-            return std::any{};
-        } else {
-            return std::any(implementation(arg1, arg2, arg3));
-        }
-    };
-    registerFunction(name, wrapper);
-}
-
-template <typename A, typename B, typename C, typename D, typename R>
-void Jsonata::registerFunction(const std::string& name,
-                               std::function<R(A, B, C, D)> implementation) {
-    auto wrapper = [implementation,
-                    name](const std::vector<std::any>& args) -> std::any {
-        if (args.size() < 4) {
-            throw JException("S0410", -1,
-                             "Function " + name + " expects 4 arguments, got " +
-                                 std::to_string(args.size()));
-        }
-        A arg1 = std::any_cast<A>(args[0]);
-        B arg2 = std::any_cast<B>(args[1]);
-        C arg3 = std::any_cast<C>(args[2]);
-        D arg4 = std::any_cast<D>(args[3]);
-        if constexpr (std::is_void_v<R>) {
-            implementation(arg1, arg2, arg3, arg4);
-            return std::any{};
-        } else {
-            return std::any(implementation(arg1, arg2, arg3, arg4));
-        }
-    };
-    registerFunction(name, wrapper);
-}
 
-}  // namespace jsonata
+    // Global static methods
+    std::any jsonata_evaluate(const std::string &expression, const std::any &input);
+
+    // Template implementations (must be in header for templates)
+
+    template<typename R>
+    void Jsonata::registerFunction(const std::string &name, std::function<R()> implementation)
+    {
+        auto wrapper = [implementation](const std::vector<std::any> &) -> std::any {
+            if constexpr (std::is_void_v<R>) {
+                implementation();
+                return std::any{};
+            } else {
+                return std::any(implementation());
+            }
+        };
+        registerFunction(name, wrapper);
+    }
+
+    template<typename A, typename R>
+    void Jsonata::registerFunction(const std::string &name, std::function<R(A)> implementation)
+    {
+        auto wrapper = [implementation, name](const std::vector<std::any> &args) -> std::any {
+            if (args.empty()) {
+                throw JException("S0410", -1, "Function " + name + " expects 1 argument, got 0");
+            }
+            A arg = std::any_cast<A>(args[0]);
+            if constexpr (std::is_void_v<R>) {
+                implementation(arg);
+                return std::any{};
+            } else {
+                return std::any(implementation(arg));
+            }
+        };
+        registerFunction(name, wrapper);
+    }
+
+    template<typename A, typename B, typename R>
+    void Jsonata::registerFunction(const std::string &name, std::function<R(A, B)> implementation)
+    {
+        auto wrapper = [implementation, name](const std::vector<std::any> &args) -> std::any {
+            if (args.size() < 2) {
+                throw JException("S0410",
+                                 -1,
+                                 "Function " + name + " expects 2 arguments, got "
+                                     + std::to_string(args.size()));
+            }
+            A arg1 = std::any_cast<A>(args[0]);
+            B arg2 = std::any_cast<B>(args[1]);
+            if constexpr (std::is_void_v<R>) {
+                implementation(arg1, arg2);
+                return std::any{};
+            } else {
+                return std::any(implementation(arg1, arg2));
+            }
+        };
+        registerFunction(name, wrapper);
+    }
+
+    template<typename A, typename B, typename C, typename R>
+    void Jsonata::registerFunction(const std::string &name, std::function<R(A, B, C)> implementation)
+    {
+        auto wrapper = [implementation, name](const std::vector<std::any> &args) -> std::any {
+            if (args.size() < 3) {
+                throw JException("S0410",
+                                 -1,
+                                 "Function " + name + " expects 3 arguments, got "
+                                     + std::to_string(args.size()));
+            }
+            A arg1 = std::any_cast<A>(args[0]);
+            B arg2 = std::any_cast<B>(args[1]);
+            C arg3 = std::any_cast<C>(args[2]);
+            if constexpr (std::is_void_v<R>) {
+                implementation(arg1, arg2, arg3);
+                return std::any{};
+            } else {
+                return std::any(implementation(arg1, arg2, arg3));
+            }
+        };
+        registerFunction(name, wrapper);
+    }
+
+    template<typename A, typename B, typename C, typename D, typename R>
+    void Jsonata::registerFunction(const std::string &name,
+                                   std::function<R(A, B, C, D)> implementation)
+    {
+        auto wrapper = [implementation, name](const std::vector<std::any> &args) -> std::any {
+            if (args.size() < 4) {
+                throw JException("S0410",
+                                 -1,
+                                 "Function " + name + " expects 4 arguments, got "
+                                     + std::to_string(args.size()));
+            }
+            A arg1 = std::any_cast<A>(args[0]);
+            B arg2 = std::any_cast<B>(args[1]);
+            C arg3 = std::any_cast<C>(args[2]);
+            D arg4 = std::any_cast<D>(args[3]);
+            if constexpr (std::is_void_v<R>) {
+                implementation(arg1, arg2, arg3, arg4);
+                return std::any{};
+            } else {
+                return std::any(implementation(arg1, arg2, arg3, arg4));
+            }
+        };
+        registerFunction(name, wrapper);
+    }
+} // namespace jsonata
diff --git a/src/jsonata/Functions.cpp b/src/jsonata/Functions.cpp
index 96e9342..cb7d641 100644
--- a/src/jsonata/Functions.cpp
+++ b/src/jsonata/Functions.cpp
@@ -464,12 +464,12 @@ static bool isDeepEqualForDistinct(const std::any& lhs, const std::any& rhs) {
 
         // Compare direct map objects
         if (lhs.type() ==
-            typeid(nlohmann::ordered_map<std::string, std::any>)) {
+            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             const auto& leftMap =
-                std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                     lhs);
             const auto& rightMap =
-                std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                     rhs);
 
             if (leftMap.size() != rightMap.size()) {
@@ -846,9 +846,9 @@ bool Functions::isLambda(const std::any& value) {
 
 // Deprecated: type-check helpers moved to Utils
 
-nlohmann::ordered_map<std::string, Functions::FunctionEntry>
+jsonata::backend::ordered_map<std::string, Functions::FunctionEntry>
 Functions::getFunctionRegistry() {
-    static nlohmann::ordered_map<std::string, FunctionEntry>
+    static jsonata::backend::ordered_map<std::string, FunctionEntry>
         registryWithSignatures = {
             // Aggregation functions
             {"sum", FunctionEntry(
@@ -1259,11 +1259,11 @@ Functions::getFunctionRegistry() {
                          (args.size() >= 2 && isString(args[1]))
                              ? std::any_cast<std::string>(args[1])
                              : "";
-                     nlohmann::ordered_map<std::string, std::any> options;
+                     jsonata::backend::ordered_map<std::string, std::any> options;
                      if (args.size() >= 3) {
                          try {
                              options = std::any_cast<
-                                 nlohmann::ordered_map<std::string, std::any>>(
+                                 jsonata::backend::ordered_map<std::string, std::any>>(
                                  args[2]);
                          } catch (const std::bad_any_cast&) {
                              // Ignore invalid options
@@ -1794,9 +1794,9 @@ std::optional<bool> Functions::toBoolean(const std::any& arg) {
             result = std::any_cast<bool>(arg);
             // Check for map/object
         } else if (arg.type() ==
-                   typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const nlohmann::ordered_map<std::string, std::any>&>(arg);
+                const jsonata::backend::ordered_map<std::string, std::any>&>(arg);
             result = !map.empty();
         }
         // Functions are falsy
@@ -2187,7 +2187,7 @@ std::any Functions::merge(const Utils::JList& args) {
     }
 
     try {
-        nlohmann::ordered_map<std::string, std::any> result;
+        jsonata::backend::ordered_map<std::string, std::any> result;
 
         // Convert to vector if needed
         Utils::JList inputArray;
@@ -2204,9 +2204,9 @@ std::any Functions::merge(const Utils::JList& args) {
                 try {
                     // Handle direct map
                     if (item.type() ==
-                        typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
                         const auto& map =
-                            std::any_cast<const nlohmann::ordered_map<
+                            std::any_cast<const jsonata::backend::ordered_map<
                                 std::string, std::any>&>(item);
                         for (const auto& entry : map) {
                             result[entry.first] = entry.second;
@@ -2312,11 +2312,11 @@ std::any Functions::spread(const Utils::JList& args) {
             // Handle object - create an array with one object per key-value
             // pair
         } else if (arg.type() ==
-                   typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const nlohmann::ordered_map<std::string, std::any>&>(arg);
+                const jsonata::backend::ordered_map<std::string, std::any>&>(arg);
             for (const auto& entry : map) {
-                nlohmann::ordered_map<std::string, std::any> obj;
+                jsonata::backend::ordered_map<std::string, std::any> obj;
                 obj[entry.first] = entry.second;
                 result.push_back(obj);
             }
@@ -2347,13 +2347,13 @@ std::any Functions::sift(const Utils::JList& args) {
     }
 
     try {
-        nlohmann::ordered_map<std::string, std::any> result;
+        jsonata::backend::ordered_map<std::string, std::any> result;
 
         // Handle direct map
         if (objectArg.type() ==
-            typeid(nlohmann::ordered_map<std::string, std::any>)) {
+            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const nlohmann::ordered_map<std::string, std::any>&>(objectArg);
+                const jsonata::backend::ordered_map<std::string, std::any>&>(objectArg);
             for (const auto& entry : map) {
                 // Prepare arguments for the predicate function
                 auto funcArgs = hofFuncArgs(predicateArg, entry.second,
@@ -2422,9 +2422,9 @@ void Functions::stringifyInternal(std::ostringstream& os, const std::any& arg,
             if (prettify && !vec.empty()) os << indent;
             os << "]";
         } else if (arg.type() ==
-                   typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             auto map =
-                std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                     arg);
             os << "{";
             if (prettify && !map.empty()) os << "\n";
@@ -3005,10 +3005,10 @@ Utils::JList Functions::keys(const std::any& arg) {
                 result.push_back(key);
             }
         } else if (arg.type() ==
-                   typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             // Java: if (arg instanceof Map) - return keySet
             const auto& map = std::any_cast<
-                const nlohmann::ordered_map<std::string, std::any>&>(arg);
+                const jsonata::backend::ordered_map<std::string, std::any>&>(arg);
             for (const auto& [key, value] : map) {
                 result.push_back(key);
             }
@@ -3038,9 +3038,9 @@ std::any Functions::each(const std::any& obj, const std::any& func) {
 
         // Handle direct map<string, any>
         if (obj.type() ==
-            typeid(nlohmann::ordered_map<std::string, std::any>)) {
+            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const nlohmann::ordered_map<std::string, std::any>&>(obj);
+                const jsonata::backend::ordered_map<std::string, std::any>&>(obj);
             // Java: for (var key : obj.keySet())
             for (const auto& entry : map) {
                 const std::string& key = entry.first;
@@ -3613,7 +3613,7 @@ std::string Functions::formatScientificNotation(double value,
 
 std::optional<std::string> Functions::formatNumber(
     double value, const std::string& picture,
-    const nlohmann::ordered_map<std::string, std::any>& options) {
+    const jsonata::backend::ordered_map<std::string, std::any>& options) {
     if (std::isnan(value) || std::isinf(value)) {
         return std::nullopt;
     }
@@ -3958,6 +3958,14 @@ std::any Functions::sortWithContext(const Utils::JList& args,
 
         // Sort with lambda comparator using stable_sort - Java reference uses
         // stable sort
+
+        // MAJOR CHANGED.  in MSVC the sort function checks that IF the comparator returns
+        // false for a > b then b > a must NOT also return false.  this is not the case when
+        // a == b.
+        // to keep compatibility with java sorting but not mess with c++ sorting we keep the
+        // c++ sorting convention.  so NOT reverse the result.  This yields an sorted
+        // array but in the reverted order as in java.  so we just reverse the array at the end
+
         std::stable_sort(
             result.begin(), result.end(),
             [&](const std::any& a, const std::any& b) {
@@ -3970,6 +3978,10 @@ std::any Functions::sortWithContext(const Utils::JList& args,
                     auto compareResult = instance->apply(
                         comparator, compareArgs, input, environment);
 
+                    // PROBLEM with MSVC
+                    // MSVC checks that if the comparator returns true for a>b then
+                    // b < a Must be false. So we must take are of == cases.
+
                     // Convert result to boolean for comparison
                     // Java reference: if swap=true, return 1 (a > b), else
                     // return -1 (a < b) In C++ std::sort: return true if a < b
@@ -3977,7 +3989,7 @@ std::any Functions::sortWithContext(const Utils::JList& args,
                     // a > b, so return false
                     auto boolResult = toBoolean(compareResult);
                     if (boolResult.has_value()) {
-                        return !boolResult.value();  // Invert the result to
+                        return boolResult.value();  // Invert the result to
                                                      // match Java logic
                     }
 
@@ -3989,6 +4001,45 @@ std::any Functions::sortWithContext(const Utils::JList& args,
                     return defaultComparator(a, b);
                 }
             });
+
+        // now revert the result
+        std::reverse( result.begin(), result.end() );
+
+        // std::stable_sort(
+        //     result.begin(), result.end(),
+        //     [&](const std::any& a, const std::any& b) {
+        //         try {
+        //             // Java reference lines 1955-1961: funcApply(comparator,
+        //             // Arrays.asList(o1, o2)) boolean swap = (boolean)
+        //             // funcApply(comparator, Arrays.asList(o1, o2)); if (swap)
+        //             // return 1; else return -1;
+        //             Utils::JList compareArgs = {a, b};
+        //             auto compareResult = instance->apply(
+        //                 comparator, compareArgs, input, environment);
+
+        //             // PROBLEM with MSVC
+        //             // MSVC checks that if the comparator returns true for a>b then
+        //             // b < a Must be false. So we must take are of == cases.
+
+        //             // Convert result to boolean for comparison
+        //             // Java reference: if swap=true, return 1 (a > b), else
+        //             // return -1 (a < b) In C++ std::sort: return true if a < b
+        //             // So we need to invert: if lambda returns true (swap), then
+        //             // a > b, so return false
+        //             auto boolResult = toBoolean(compareResult);
+        //             if (boolResult.has_value()) {
+        //                 return !boolResult.value();  // Invert the result to
+        //                                              // match Java logic
+        //             }
+
+        //             // Fallback to default comparison if lambda returns
+        //             // undefined
+        //             return defaultComparator(a, b);
+        //         } catch (...) {
+        //             // Fallback to default comparison on error
+        //             return defaultComparator(a, b);
+        //         }
+        //     });
     } else {
         // Natural ordering for homogeneous arrays - same logic as basic sort
         // function
@@ -4105,11 +4156,11 @@ std::any Functions::lookup(const std::any& input, const std::string& key) {
 
             return result.empty() ? std::any{} : std::any(result);
         } else if (input.type() ==
-                   typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             // Java: if (input instanceof Map) - get key and handle null
             // detection
             const auto& map = std::any_cast<
-                const nlohmann::ordered_map<std::string, std::any>&>(input);
+                const jsonata::backend::ordered_map<std::string, std::any>&>(input);
             auto it = map.find(key);
             if (it != map.end()) {
                 auto result = it->second;
@@ -5007,7 +5058,7 @@ Utils::JList Functions::evaluateMatcher(const std::regex& pattern,
 
     for (; iter != end; ++iter) {
         const std::smatch& smatch = *iter;
-        nlohmann::ordered_map<std::string, std::any> match;
+        jsonata::backend::ordered_map<std::string, std::any> match;
         match["match"] = smatch.str();
         match["index"] = static_cast<int64_t>(smatch.position());
 
@@ -5408,9 +5459,9 @@ std::string Functions::safeReplaceAllFn(const std::string& str,
     return finalResult;
 }
 
-nlohmann::ordered_map<std::string, std::any> Functions::toJsonataMatch(
+jsonata::backend::ordered_map<std::string, std::any> Functions::toJsonataMatch(
     const std::smatch& match) {
-    nlohmann::ordered_map<std::string, std::any> result;
+    jsonata::backend::ordered_map<std::string, std::any> result;
 
     result["match"] = match.str();
 
@@ -5514,7 +5565,7 @@ std::string Functions::rightPad(const std::string& str, int64_t size,
 // formatNumber options processing helper functions
 
 Functions::FormatSymbols Functions::processOptionsArg(
-    const nlohmann::ordered_map<std::string, std::any>& options) {
+    const jsonata::backend::ordered_map<std::string, std::any>& options) {
     FormatSymbols symbols;  // Use default values
 
     if (options.empty()) {
diff --git a/src/jsonata/JException.cpp b/src/jsonata/JException.cpp
index d44192d..e18b19f 100644
--- a/src/jsonata/JException.cpp
+++ b/src/jsonata/JException.cpp
@@ -17,8 +17,7 @@
  * limitations under the License.
  */
 #include "jsonata/JException.h"
-
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <regex>
 #include <sstream>
 
diff --git a/src/jsonata/Jsonata.cpp b/src/jsonata/Jsonata.cpp
index 8dc42c1..f25c46e 100644
--- a/src/jsonata/Jsonata.cpp
+++ b/src/jsonata/Jsonata.cpp
@@ -747,9 +747,9 @@ std::any Jsonata::evaluateWildcard(std::shared_ptr<Parser::Symbol> expr,
     try {
         // Handle map/object input
         if (_input.type() ==
-            typeid(nlohmann::ordered_map<std::string, std::any>)) {
+            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
             auto map =
-                std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                     _input);
             for (const auto& [key, value] : map) {
                 // Java reference line 713: if((value instanceof List))
@@ -867,7 +867,7 @@ std::any Jsonata::evaluatePath(std::shared_ptr<Parser::Symbol> expr,
             if (tupleBindings.has_value()) {
                 for (const auto& tupleAny : *tupleBindings) {
                     auto tuple = std::any_cast<
-                        nlohmann::ordered_map<std::string, std::any>>(tupleAny);
+                        jsonata::backend::ordered_map<std::string, std::any>>(tupleAny);
                     auto it = tuple.find("@");
                     if (it != tuple.end()) {
                         result.push_back(it->second);
@@ -1151,14 +1151,14 @@ bool Jsonata::deepEquals(const std::any& lhs, const std::any& rhs) {
     // Handle object comparison - Java uses Map.equals() which compares all
     // key-value pairs
     if (lhsConverted.type() ==
-            typeid(nlohmann::ordered_map<std::string, std::any>) &&
+            typeid(jsonata::backend::ordered_map<std::string, std::any>) &&
         rhsConverted.type() ==
-            typeid(nlohmann::ordered_map<std::string, std::any>)) {
+            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
         const auto& leftMap =
-            std::any_cast<const nlohmann::ordered_map<std::string, std::any>&>(
+            std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
                 lhsConverted);
         const auto& rightMap =
-            std::any_cast<const nlohmann::ordered_map<std::string, std::any>&>(
+            std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
                 rhsConverted);
 
         if (leftMap.size() != rightMap.size()) {
@@ -1356,7 +1356,7 @@ void Jsonata::recurseDescendants(const std::any& input,
         // in the codebase
         try {
             auto map =
-                std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                     input);
             for (const auto& [key, value] : map) {
                 recurseDescendants(value, results);
@@ -1548,9 +1548,9 @@ std::any Jsonata::evaluateSort(std::shared_ptr<Parser::Symbol> expr,
                 // Extract context from tuple map
                 try {
                     if (a.type() ==
-                        typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
                         auto tupleMap = std::any_cast<
-                            nlohmann::ordered_map<std::string, std::any>>(a);
+                            jsonata::backend::ordered_map<std::string, std::any>>(a);
                         auto it = tupleMap.find("@");
                         if (it != tupleMap.end()) {
                             contextA = it->second;
@@ -1573,9 +1573,9 @@ std::any Jsonata::evaluateSort(std::shared_ptr<Parser::Symbol> expr,
             if (isTupleSort) {
                 try {
                     if (b.type() ==
-                        typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
                         auto tupleMap = std::any_cast<
-                            nlohmann::ordered_map<std::string, std::any>>(b);
+                            jsonata::backend::ordered_map<std::string, std::any>>(b);
                         auto it = tupleMap.find("@");
                         if (it != tupleMap.end()) {
                             contextB = it->second;
@@ -1781,16 +1781,16 @@ std::any Jsonata::evaluateTransform(std::shared_ptr<Parser::Symbol> expr,
                 if (update.has_value()) {
                     if (update.type() ==
                             typeid(
-                                nlohmann::ordered_map<std::string, std::any>) &&
+                                jsonata::backend::ordered_map<std::string, std::any>) &&
                         match.type() ==
                             typeid(
-                                nlohmann::ordered_map<std::string, std::any>)) {
+                                jsonata::backend::ordered_map<std::string, std::any>)) {
                         // Java lines 1457-1459: merge the update
                         auto& matchMap = std::any_cast<
-                            nlohmann::ordered_map<std::string, std::any>&>(
+                            jsonata::backend::ordered_map<std::string, std::any>&>(
                             match);
                         const auto& updateMap =
-                            std::any_cast<const nlohmann::ordered_map<
+                            std::any_cast<const jsonata::backend::ordered_map<
                                 std::string, std::any>&>(update);
 
                         for (const auto& [prop, value] : updateMap) {
@@ -1921,9 +1921,9 @@ std::any Jsonata::evaluateFilter(std::shared_ptr<Parser::Symbol> predicate,
             }
             if (isTupleStream &&
                 item.type() ==
-                    typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                    typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
                 auto tupleMap =
-                    std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                    std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                         item);
                 auto it = tupleMap.find("@");
                 if (it != tupleMap.end()) {
@@ -1998,267 +1998,285 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
     return result.has_value() ? result.value() : false;
 }
 
-/* static */ std::any Jsonata::orderedJsonToAny(
-    const nlohmann::ordered_json& j) {
-    if (j.is_null()) return std::any{};
-    if (j.is_boolean()) return std::any(j.get<bool>());
-    if (j.is_number_integer()) {
-        // Preserve sign by using int64_t; for large unsigned, capture as
-        // uint64_t
-        int64_t si = 0;
-        try {
-            si = j.get<int64_t>();
-            return std::any(static_cast<int64_t>(si));
-        } catch (...) {
-        }
-        uint64_t ui = j.get<uint64_t>();
-        return std::any(static_cast<uint64_t>(ui));
-    }
-    if (j.is_number_unsigned()) {
-        uint64_t ui = j.get<uint64_t>();
-        return std::any(static_cast<uint64_t>(ui));
-    }
-    if (j.is_number_float()) return std::any(j.get<double>());
-    if (j.is_string()) return std::any(j.get<std::string>());
-    if (j.is_array()) {
-        std::vector<std::any> out;
-        out.reserve(j.size());
-        for (const auto& el : j) out.push_back(orderedJsonToAny(el));
-        return out;
-    }
-    if (j.is_object()) {
-        nlohmann::ordered_map<std::string, std::any> m;
-        for (auto it = j.begin(); it != j.end(); ++it) {
-            m[it.key()] = orderedJsonToAny(it.value());
-        }
-        return m;
-    }
-    return std::any{};
-}
-
-/* static */ nlohmann::ordered_json Jsonata::anyToOrderedJson(
-    const std::any& value) {
-    if (!value.has_value()) return nlohmann::ordered_json();
-
-    // Canonicalize numeric types: convert doubles with no fractional part to
-    // integer types
-    try {
-        if (Utils::isNumeric(value)) {
-            std::any canon = Utils::convertNumber(value);
-            if (canon.type() != value.type()) {
-                return anyToOrderedJson(canon);
-            }
-        }
-    } catch (...) {
-        // Ignore conversion errors here; fall back to original value
-    }
-
-    const std::type_info& type = value.type();
-    if (type == typeid(bool))
-        return nlohmann::ordered_json(std::any_cast<bool>(value));
-    if (type == typeid(double))
-        return nlohmann::ordered_json(std::any_cast<double>(value));
-    if (type == typeid(int64_t))
-        return nlohmann::ordered_json(std::any_cast<int64_t>(value));
-    if (type == typeid(uint64_t))
-        return nlohmann::ordered_json(std::any_cast<uint64_t>(value));
-    // Cross-platform support for additional integral types (e.g., long/long long)
-    if (type == typeid(long long))
-        return nlohmann::ordered_json(static_cast<int64_t>(std::any_cast<long long>(value)));
-    if (type == typeid(unsigned long long))
-        return nlohmann::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
-    if (type == typeid(long))
-        return nlohmann::ordered_json(static_cast<int64_t>(std::any_cast<long>(value)));
-    if (type == typeid(unsigned long))
-        return nlohmann::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
-    if (type == typeid(int))
-        return nlohmann::ordered_json(static_cast<int64_t>(std::any_cast<int>(value)));
-    if (type == typeid(unsigned int))
-        return nlohmann::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
-    if (type == typeid(std::string))
-        return nlohmann::ordered_json(std::any_cast<std::string>(value));
-    if (type == typeid(Utils::JList)) {
-        nlohmann::ordered_json arr = nlohmann::ordered_json::array();
-        const auto& jlist = std::any_cast<const Utils::JList&>(value);
-        for (const auto& item : jlist) arr.push_back(anyToOrderedJson(item));
-        return arr;
-    }
-    if (type == typeid(std::vector<std::any>)) {
-        nlohmann::ordered_json arr = nlohmann::ordered_json::array();
-        const auto& vec = std::any_cast<const std::vector<std::any>&>(value);
-        for (const auto& item : vec) arr.push_back(anyToOrderedJson(item));
-        return arr;
-    }
-    if (type == typeid(nlohmann::ordered_map<std::string, std::any>)) {
-        nlohmann::ordered_json obj = nlohmann::ordered_json::object();
-        const auto& map =
-            std::any_cast<const nlohmann::ordered_map<std::string, std::any>&>(
-                value);
-        for (const auto& [k, v] : map) obj[k] = anyToOrderedJson(v);
-        return obj;
-    }
-    if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
-        return nlohmann::ordered_json();
-    }
-    // Directly handle nlohmann::ordered_json returned from custom functions
-    if (type == typeid(nlohmann::ordered_json)) {
-        return std::any_cast<nlohmann::ordered_json>(value);
-    }
-    return nlohmann::ordered_json();
-}
-
-// Unordered JSON helpers (nlohmann::json)
-/* static */ std::any Jsonata::jsonToAny(const nlohmann::json& j) {
-    if (j.is_null()) return std::any{};
-    if (j.is_boolean()) return std::any(j.get<bool>());
-    if (j.is_number_integer()) {
-        int64_t si = 0;
-        try {
-            si = j.get<int64_t>();
-            return std::any(static_cast<int64_t>(si));
-        } catch (...) {
-        }
-        uint64_t ui = j.get<uint64_t>();
-        return std::any(static_cast<uint64_t>(ui));
-    }
-    if (j.is_number_unsigned()) {
-        uint64_t ui = j.get<uint64_t>();
-        return std::any(static_cast<uint64_t>(ui));
-    }
-    if (j.is_number_float()) return std::any(j.get<double>());
-    if (j.is_string()) return std::any(j.get<std::string>());
-    if (j.is_array()) {
-        std::vector<std::any> out;
-        out.reserve(j.size());
-        for (const auto& el : j) out.push_back(jsonToAny(el));
-        return out;
-    }
-    if (j.is_object()) {
-        nlohmann::ordered_map<std::string, std::any> m;
-        for (auto it = j.begin(); it != j.end(); ++it) {
-            m[it.key()] = jsonToAny(it.value());
-        }
-        return m;
-    }
-    return std::any{};
-}
-
-/* static */ nlohmann::json Jsonata::anyToJson(const std::any& value) {
-    if (!value.has_value()) return nlohmann::json();
-
-    // Canonicalize numeric types similar to anyToOrderedJson
-    try {
-        if (Utils::isNumeric(value)) {
-            std::any canon = Utils::convertNumber(value);
-            if (canon.type() != value.type()) {
-                return anyToJson(canon);
-            }
-        }
-    } catch (...) {
-        // Ignore conversion errors here; fall back to original value
-    }
-
-    const std::type_info& type = value.type();
-    if (type == typeid(bool))
-        return nlohmann::json(std::any_cast<bool>(value));
-    if (type == typeid(double))
-        return nlohmann::json(std::any_cast<double>(value));
-    if (type == typeid(int64_t))
-        return nlohmann::json(std::any_cast<int64_t>(value));
-    if (type == typeid(uint64_t))
-        return nlohmann::json(std::any_cast<uint64_t>(value));
-    // Cross-platform support for additional integral types (e.g., long/long long)
-    if (type == typeid(long long))
-        return nlohmann::json(static_cast<int64_t>(std::any_cast<long long>(value)));
-    if (type == typeid(unsigned long long))
-        return nlohmann::json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
-    if (type == typeid(long))
-        return nlohmann::json(static_cast<int64_t>(std::any_cast<long>(value)));
-    if (type == typeid(unsigned long))
-        return nlohmann::json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
-    if (type == typeid(int))
-        return nlohmann::json(static_cast<int64_t>(std::any_cast<int>(value)));
-    if (type == typeid(unsigned int))
-        return nlohmann::json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
-    if (type == typeid(std::string))
-        return nlohmann::json(std::any_cast<std::string>(value));
-
-    if (type == typeid(Utils::JList)) {
-        nlohmann::json arr = nlohmann::json::array();
-        const auto& jlist = std::any_cast<const Utils::JList&>(value);
-        for (const auto& item : jlist) arr.push_back(anyToJson(item));
-        return arr;
-    }
-    if (type == typeid(std::vector<std::any>)) {
-        nlohmann::json arr = nlohmann::json::array();
-        const auto& vec = std::any_cast<const std::vector<std::any>&>(value);
-        for (const auto& item : vec) arr.push_back(anyToJson(item));
-        return arr;
-    }
-    if (type == typeid(nlohmann::ordered_map<std::string, std::any>)) {
-        nlohmann::json obj = nlohmann::json::object();
-        const auto& map =
-            std::any_cast<const nlohmann::ordered_map<std::string, std::any>&>(
-                value);
-        for (const auto& [k, v] : map) obj[k] = anyToJson(v);
-        return obj;
-    }
-
-    // Ignore function symbols
-    if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
-        return nlohmann::json();
-    }
-
-    // Directly handle nlohmann::json returned from custom functions
-    if (type == typeid(nlohmann::json)) {
-        return std::any_cast<nlohmann::json>(value);
-    }
-
-    // Handle nlohmann::ordered_json without dump/parse by converting
-    if (type == typeid(nlohmann::ordered_json)) {
-        const auto& oj = std::any_cast<const nlohmann::ordered_json&>(value);
-
-        // Recursive lambda to convert ordered_json to json
-        std::function<nlohmann::json(const nlohmann::ordered_json&)> convert =
-            [&](const nlohmann::ordered_json& j) -> nlohmann::json {
-            if (j.is_null()) return nlohmann::json();
-            if (j.is_boolean()) return nlohmann::json(j.get<bool>());
-            if (j.is_number_integer()) {
-                int64_t si = 0;
-                try {
-                    si = j.get<int64_t>();
-                    return nlohmann::json(static_cast<int64_t>(si));
-                } catch (...) {
-                }
-                uint64_t ui = j.get<uint64_t>();
-                return nlohmann::json(static_cast<uint64_t>(ui));
-            }
-            if (j.is_number_unsigned())
-                return nlohmann::json(j.get<uint64_t>());
-            if (j.is_number_float())
-                return nlohmann::json(j.get<double>());
-            if (j.is_string())
-                return nlohmann::json(j.get<std::string>());
-            if (j.is_array()) {
-                nlohmann::json arr = nlohmann::json::array();
-                for (const auto& el : j) arr.push_back(convert(el));
-                return arr;
-            }
-            if (j.is_object()) {
-                nlohmann::json obj = nlohmann::json::object();
-                for (auto it = j.begin(); it != j.end(); ++it) {
-                    obj[it.key()] = convert(it.value());
-                }
-                return obj;
-            }
-            return nlohmann::json();
-        };
-
-        return convert(oj);
-    }
-
-    return nlohmann::json();
-}
+// std::any Jsonata::toAny(
+//     const jsonata::backend::ordered_json& j) {
+//     if (j.is_null()) return std::any{};
+//     if (j.is_boolean()) return std::any(j.get<bool>());
+//     if (j.is_number_integer()) {
+//         // Preserve sign by using int64_t; for large unsigned, capture as
+//         // uint64_t
+//         int64_t si = 0;
+//         try {
+//             si = j.get<int64_t>();
+//             return std::any(static_cast<int64_t>(si));
+//         } catch (...) {
+//         }
+//         uint64_t ui = j.get<uint64_t>();
+//         return std::any(static_cast<uint64_t>(ui));
+//     }
+//     if (j.is_number_unsigned()) {
+//         uint64_t ui = j.get<uint64_t>();
+//         return std::any(static_cast<uint64_t>(ui));
+//     }
+//     if (j.is_number_float()) return std::any(j.get<double>());
+//     if (j.is_string()) return std::any(j.get<std::string>());
+//     if (j.is_array()) {
+//         std::vector<std::any> out;
+//         out.reserve(j.size());
+//         jsonata::backend::copy( j, out, [](const jsonata::backend::ordered_json&el){
+//             return toAny(el);
+//         });
+//         return out;
+//     }
+//     if (j.is_object()) {
+//         jsonata::backend::ordered_map<std::string, std::any> m;
+//         jsonata::backend::copy( j, m, [](const jsonata::backend::ordered_json&el){
+//             return toAny(el);
+//         });
+//         return m;
+//     }
+//     return std::any{};
+// }
+
+// jsonata::backend::ordered_json Jsonata::fromAny(
+//     const std::any& value) {
+//     if (!value.has_value()) return jsonata::backend::ordered_json();
+
+//     // Canonicalize numeric types: convert doubles with no fractional part to
+//     // integer types
+//     try {
+//         if (Utils::isNumeric(value)) {
+//             std::any canon = Utils::convertNumber(value);
+//             if (canon.type() != value.type()) {
+//                 return fromAny(canon);
+//             }
+//         }
+//     } catch (...) {
+//         // Ignore conversion errors here; fall back to original value
+//     }
+
+//     const std::type_info& type = value.type();
+//     if (type == typeid(bool))
+//         return jsonata::backend::ordered_json(std::any_cast<bool>(value));
+//     if (type == typeid(double))
+//         return jsonata::backend::ordered_json(std::any_cast<double>(value));
+//     if (type == typeid(int64_t))
+//         return jsonata::backend::ordered_json(std::any_cast<int64_t>(value));
+//     if (type == typeid(uint64_t))
+//         return jsonata::backend::ordered_json(std::any_cast<uint64_t>(value));
+//     // Cross-platform support for additional integral types (e.g., long/long long)
+//     if (type == typeid(long long))
+//         return jsonata::backend::ordered_json(static_cast<int64_t>(std::any_cast<long long>(value)));
+//     if (type == typeid(unsigned long long))
+//         return jsonata::backend::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
+//     if (type == typeid(long))
+//         return jsonata::backend::ordered_json(static_cast<int64_t>(std::any_cast<long>(value)));
+//     if (type == typeid(unsigned long))
+//         return jsonata::backend::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
+//     if (type == typeid(int))
+//         return jsonata::backend::ordered_json(static_cast<int64_t>(std::any_cast<int>(value)));
+//     if (type == typeid(unsigned int))
+//         return jsonata::backend::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
+//     if (type == typeid(std::string))
+//         return jsonata::backend::ordered_json(std::any_cast<std::string>(value));
+//     if (type == typeid(Utils::JList)) {
+//         jsonata::backend::ordered_json arr = jsonata::backend::ordered_json::array();
+//         const auto& jlist = std::any_cast<const Utils::JList&>(value);
+//         jsonata::backend::copy( jlist, arr, []( const std::any & a ) {
+//             return fromAny( a );
+//         });
+//         return arr;
+//     }
+//     if (type == typeid(std::vector<std::any>)) {
+//         jsonata::backend::ordered_json arr = jsonata::backend::ordered_json::array();
+//         const auto& vec = std::any_cast<const std::vector<std::any>&>(value);
+//         jsonata::backend::copy( vec, arr, []( const std::any & a ) {
+//             return fromAny( a );
+//         });
+//         return arr;
+//     }
+//     if (type == typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+//         jsonata::backend::ordered_json obj = jsonata::backend::ordered_json::object();
+//         const auto& map =
+//             std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
+//                 value);
+//         jsonata::backend::copy( map, obj, []( const std::any & a ) {
+//             return fromAny(a);
+//         });
+//         return obj;
+//     }
+//     if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
+//         return jsonata::backend::ordered_json();
+//     }
+//     // Directly handle jsonata::backend::ordered_json returned from custom functions
+//     if (type == typeid(jsonata::backend::ordered_json)) {
+//         return std::any_cast<jsonata::backend::ordered_json>(value);
+//     }
+//     return jsonata::backend::ordered_json();
+// }
+
+// // Unordered JSON helpers (jsonata::backend::json)
+// std::any Jsonata::jsonToAny(const jsonata::backend::json& j) {
+//     if (j.is_null()) return std::any{};
+//     if (j.is_boolean()) return std::any(j.get<bool>());
+//     if (j.is_number_integer()) {
+//         int64_t si = 0;
+//         try {
+//             si = j.get<int64_t>();
+//             return std::any(static_cast<int64_t>(si));
+//         } catch (...) {
+//         }
+//         uint64_t ui = j.get<uint64_t>();
+//         return std::any(static_cast<uint64_t>(ui));
+//     }
+//     if (j.is_number_unsigned()) {
+//         uint64_t ui = j.get<uint64_t>();
+//         return std::any(static_cast<uint64_t>(ui));
+//     }
+//     if (j.is_number_float()) return std::any(j.get<double>());
+//     if (j.is_string()) return std::any(j.get<std::string>());
+//     if (j.is_array()) {
+//         std::vector<std::any> out;
+//         out.reserve(j.size());
+//         jsonata::backend::copy( j, out, []( const jsonata::backend::json & el ) {
+//             return jsonToAny(el);
+//         });
+//         return out;
+//     }
+//     if (j.is_object()) {
+//         jsonata::backend::ordered_map<std::string, std::any> m;
+//         jsonata::backend::copy( j, m, []( const jsonata::backend::json & el ) {
+//             return jsonToAny(el);
+//         });
+//         return m;
+//     }
+//     return std::any{};
+// }
+
+// jsonata::backend::json Jsonata::anyToJson(const std::any& value) {
+//     if (!value.has_value()) return jsonata::backend::json();
+
+//     // Canonicalize numeric types similar to fromAny
+//     try {
+//         if (Utils::isNumeric(value)) {
+//             std::any canon = Utils::convertNumber(value);
+//             if (canon.type() != value.type()) {
+//                 return anyToJson(canon);
+//             }
+//         }
+//     } catch (...) {
+//         // Ignore conversion errors here; fall back to original value
+//     }
+
+//     const std::type_info& type = value.type();
+//     if (type == typeid(bool))
+//         return jsonata::backend::json(std::any_cast<bool>(value));
+//     if (type == typeid(double))
+//         return jsonata::backend::json(std::any_cast<double>(value));
+//     if (type == typeid(int64_t))
+//         return jsonata::backend::json(std::any_cast<int64_t>(value));
+//     if (type == typeid(uint64_t))
+//         return jsonata::backend::json(std::any_cast<uint64_t>(value));
+//     // Cross-platform support for additional integral types (e.g., long/long long)
+//     if (type == typeid(long long))
+//         return jsonata::backend::json(static_cast<int64_t>(std::any_cast<long long>(value)));
+//     if (type == typeid(unsigned long long))
+//         return jsonata::backend::json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
+//     if (type == typeid(long))
+//         return jsonata::backend::json(static_cast<int64_t>(std::any_cast<long>(value)));
+//     if (type == typeid(unsigned long))
+//         return jsonata::backend::json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
+//     if (type == typeid(int))
+//         return jsonata::backend::json(static_cast<int64_t>(std::any_cast<int>(value)));
+//     if (type == typeid(unsigned int))
+//         return jsonata::backend::json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
+//     if (type == typeid(std::string))
+//         return jsonata::backend::json(std::any_cast<std::string>(value));
+
+//     if (type == typeid(Utils::JList)) {
+//         jsonata::backend::json arr = jsonata::backend::json::array();
+//         const auto& jlist = std::any_cast<const Utils::JList&>(value);
+//         jsonata::backend::copy( jlist, arr, []( const std::any & a ) {
+//             return anyToJson(a);
+//         });
+//         return arr;
+//     }
+//     if (type == typeid(std::vector<std::any>)) {
+//         jsonata::backend::json arr = jsonata::backend::json::array();
+//         const auto& vec = std::any_cast<const std::vector<std::any>&>(value);
+//         jsonata::backend::copy( vec, arr, []( const std::any & a ) {
+//             return anyToJson(a);
+//         });
+//         return arr;
+//     }
+//     if (type == typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+//         jsonata::backend::json obj = jsonata::backend::json::object();
+//         const auto& map =
+//             std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
+//                 value);
+//         jsonata::backend::copy( map, obj, []( const std::any & a ) {
+//             return anyToJson(a);
+//         });
+//         return obj;
+//     }
+
+//     // Ignore function symbols
+//     if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
+//         return jsonata::backend::json();
+//     }
+
+//     // Directly handle jsonata::backend::json returned from custom functions
+//     if (type == typeid(jsonata::backend::json)) {
+//         return std::any_cast<jsonata::backend::json>(value);
+//     }
+
+//     // Handle jsonata::backend::ordered_json without dump/parse by converting
+//     if (type == typeid(jsonata::backend::ordered_json)) {
+//         const auto& oj = std::any_cast<const jsonata::backend::ordered_json&>(value);
+
+//         // Recursive lambda to convert ordered_json to json
+//         std::function<jsonata::backend::json(const jsonata::backend::ordered_json&)> convert =
+//             [&](const jsonata::backend::ordered_json& j) -> jsonata::backend::json {
+//             if (j.is_null()) return jsonata::backend::json();
+//             if (j.is_boolean()) return jsonata::backend::json(j.get<bool>());
+//             if (j.is_number_integer()) {
+//                 int64_t si = 0;
+//                 try {
+//                     si = j.get<int64_t>();
+//                     return jsonata::backend::json(static_cast<int64_t>(si));
+//                 } catch (...) {
+//                 }
+//                 uint64_t ui = j.get<uint64_t>();
+//                 return jsonata::backend::json(static_cast<uint64_t>(ui));
+//             }
+//             if (j.is_number_unsigned())
+//                 return jsonata::backend::json(j.get<uint64_t>());
+//             if (j.is_number_float())
+//                 return jsonata::backend::json(j.get<double>());
+//             if (j.is_string())
+//                 return jsonata::backend::json(j.get<std::string>());
+//             if (j.is_array()) {
+//                 jsonata::backend::json arr = jsonata::backend::json::array();
+//                 jsonata::backend::copy( j, arr, [&convert]( const jsonata::backend::ordered_json& el ) {
+//                     return convert(el );
+//                 });
+//                 return arr;
+//             }
+//             if (j.is_object()) {
+//                 jsonata::backend::json obj = jsonata::backend::json::object();
+//                 jsonata::backend::copy( j, obj, [&convert]( const jsonata::backend::ordered_json& el ) {
+//                     return convert(el );
+//                 });
+//                 return obj;
+//             }
+//             return jsonata::backend::json();
+//         };
+
+//         return convert(oj);
+//     }
+
+//     return jsonata::backend::json();
+// }
 
 // Missing public API methods from Java
 
@@ -2300,7 +2318,7 @@ std::shared_ptr<Frame> Jsonata::createFrameFromTuple(
     // Java reference lines 324-329: createFrameFromTuple implementation
     auto frame = createFrame(environment);
     auto tuple =
-        std::any_cast<nlohmann::ordered_map<std::string, std::any>>(tupleAny);
+        std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(tupleAny);
     for (const auto& [key, value] : tuple) {
         frame->bind(key, value);
     }
@@ -2319,15 +2337,15 @@ std::any Jsonata::reduceTupleStream(const std::any& tupleStream) {
         return std::any{};
     }
 
-    nlohmann::ordered_map<std::string, std::any> result;
+    jsonata::backend::ordered_map<std::string, std::any> result;
     // Java line 1144: result.putAll(tupleStream.get(0));
     result =
-        std::any_cast<nlohmann::ordered_map<std::string, std::any>>(tuples[0]);
+        std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(tuples[0]);
 
     // Java lines 1147-1158: merge remaining tuples
     for (size_t i = 1; i < tuples.size(); i++) {
         const auto& el =
-            std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+            std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                 tuples[i]);
         for (const auto& [prop, value] : el) {
             // Java line 1154: result.put(prop,
@@ -2432,145 +2450,201 @@ Jsonata::Jsonata(const Jsonata& other) {
     timestamp_ = other.timestamp_;
 }
 
-nlohmann::ordered_json Jsonata::evaluate(const nlohmann::ordered_json& input) {
-    return evaluate(input, nullptr);
-}
-
-nlohmann::ordered_json Jsonata::evaluate(const nlohmann::ordered_json& input,
-                                         std::shared_ptr<Frame> bindings) {
-    currentInstance_ = this;
-
-    // Check for syntax errors (equivalent to Java's check for errors != null)
-    if (!expression_) {
-        throw JException("S0500", 0);  // Expression compilation failed
-    }
-
-    // Convert JSON input to std::any domain for the evaluator
-    std::any anyInput = orderedJsonToAny(input);
-
-    // Always evaluate in a fresh child frame of the shared environment,
-    // then (optionally) copy provided bindings into it. This avoids
-    // concurrent mutations of the shared environment.
-    std::shared_ptr<Frame> exec_env = createFrame(environment_);
-    if (bindings != nullptr) {
-        for (const auto& [key, value] : bindings->getBindings()) {
-            exec_env->bind(key, value);
-        }
-    }
-
-    // TODO: capture timestamp for $now() and $millis() functions
-    // timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
-    //     std::chrono::system_clock::now().time_since_epoch()).count();
-
-    // CRITICAL: if the input is a JSON array, wrap it in a singleton sequence
-    // Java reference lines 2575-2579:
-    // if((input instanceof List) && !Utils.isSequence(input)) {
-    //     input = Utils.createSequence(input);
-    //     ((JList)input).outerWrapper = true;
-    // }
-    std::any processedInput = anyInput;
-    if (anyInput.has_value() && Utils::isArray(anyInput) &&
-        !Utils::isSequence(anyInput)) {
-        auto sequence = Utils::createSequence(anyInput);
-        sequence.outerWrapper = true;
-        processedInput = sequence;
-    }
-
-    // CRITICAL: put the processed input (which may be wrapped) into the
-    // fresh execution environment as the root object "$"
-    exec_env->bind("$", processedInput);
-
-    if (validateInput_) {
-        Functions::validateInput(processedInput);
-    }
-
-    std::any result;
-    try {
-        // Set thread-local input/environment for this evaluation
-        tls_input_ = processedInput;
-        tls_environment_ = exec_env;
-        result = evaluate(expression_, processedInput, exec_env);
-        // Clear TLS after evaluation to avoid dangling references
-        tls_input_.reset();
-        tls_environment_.reset();
-        result = Utils::convertNulls(result);
-        // Convert result back to nlohmann::ordered_json
-        return anyToOrderedJson(result);
-    } catch (const std::exception& err) {
-        // TODO: populateMessage(err);
-        throw;
-    }
-}
-
-nlohmann::ordered_json Jsonata::evaluate(std::nullptr_t) {
-    return evaluate(nlohmann::ordered_json());
-}
-
-nlohmann::ordered_json Jsonata::evaluate(std::nullptr_t,
-                                         std::shared_ptr<Frame> bindings) {
-    return evaluate(nlohmann::ordered_json(), bindings);
-}
-
-// Unordered nlohmann::json variants
-nlohmann::json Jsonata::evaluate(const nlohmann::json& input) {
-    return evaluate(input, nullptr);
-}
-
-nlohmann::json Jsonata::evaluate(const nlohmann::json& input,
-                                 std::shared_ptr<Frame> bindings) {
-    currentInstance_ = this;
-
-    if (!expression_) {
-        throw JException("S0500", 0);
-    }
-
-    // Convert JSON input to std::any domain for the evaluator
-    std::any anyInput = jsonToAny(input);
-
-    std::shared_ptr<Frame> exec_env = createFrame(environment_);
-    if (bindings != nullptr) {
-        for (const auto& [key, value] : bindings->getBindings()) {
-            exec_env->bind(key, value);
-        }
-    }
-
-    std::any processedInput = anyInput;
-    if (anyInput.has_value() && Utils::isArray(anyInput) &&
-        !Utils::isSequence(anyInput)) {
-        auto sequence = Utils::createSequence(anyInput);
-        sequence.outerWrapper = true;
-        processedInput = sequence;
-    }
-
-    exec_env->bind("$", processedInput);
-
-    if (validateInput_) {
-        Functions::validateInput(processedInput);
-    }
-
-    std::any result;
-    try {
-        tls_input_ = processedInput;
-        tls_environment_ = exec_env;
-        result = evaluate(expression_, processedInput, exec_env);
-        tls_input_.reset();
-        tls_environment_.reset();
-        result = Utils::convertNulls(result);
-        // Convert result to nlohmann::json
-        return anyToJson(result);
-    } catch (const std::exception& err) {
-        throw;
-    }
-}
-
-nlohmann::json Jsonata::evaluateUnordered(std::nullptr_t) {
-    return evaluate(nlohmann::json());
-}
-
-nlohmann::json Jsonata::evaluateUnordered(std::nullptr_t,
-                                          std::shared_ptr<Frame> bindings) {
-    return evaluate(nlohmann::json(), bindings);
-}
+// std::any Jsonata::evaluate(const std::any anyInput,
+//                                                  std::shared_ptr<Frame> bindings) {
+//     // Always evaluate in a fresh child frame of the shared environment,
+//     // then (optionally) copy provided bindings into it. This avoids
+//     // concurrent mutations of the shared environment.
+//     std::shared_ptr<Frame> exec_env = createFrame(environment_);
+//     if (bindings != nullptr) {
+//         for (const auto& [key, value] : bindings->getBindings()) {
+//             exec_env->bind(key, value);
+//         }
+//     }
+
+//     // TODO: capture timestamp for $now() and $millis() functions
+//     // timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
+//     //     std::chrono::system_clock::now().time_since_epoch()).count();
+
+//     // CRITICAL: if the input is a JSON array, wrap it in a singleton sequence
+//     // Java reference lines 2575-2579:
+//     // if((input instanceof List) && !Utils.isSequence(input)) {
+//     //     input = Utils.createSequence(input);
+//     //     ((JList)input).outerWrapper = true;
+//     // }
+//     std::any processedInput = anyInput;
+//     if (anyInput.has_value() && Utils::isArray(anyInput) &&
+//         !Utils::isSequence(anyInput)) {
+//         auto sequence = Utils::createSequence(anyInput);
+//         sequence.outerWrapper = true;
+//         processedInput = sequence;
+//     }
+
+//     // CRITICAL: put the processed input (which may be wrapped) into the
+//     // fresh execution environment as the root object "$"
+//     exec_env->bind("$", processedInput);
+
+//     if (validateInput_) {
+//         Functions::validateInput(processedInput);
+//     }
+
+//     std::any result;
+//     try {
+//         // Set thread-local input/environment for this evaluation
+//         tls_input_ = processedInput;
+//         tls_environment_ = exec_env;
+//         result = evaluate(expression_, processedInput, exec_env);
+//         // Clear TLS after evaluation to avoid dangling references
+//         tls_input_.reset();
+//         tls_environment_.reset();
+//         result = Utils::convertNulls(result);
+//         // Convert result back to jsonata::backend::ordered_json
+//         return fromAny(result);
+//     } catch (const std::exception& err) {
+//         // TODO: populateMessage(err);
+//         throw;
+//     }
+// }
+
+// jsonata::backend::ordered_json Jsonata::evaluate(const jsonata::backend::ordered_json& input) {
+//     return evaluate(input, nullptr);
+// }
+
+// jsonata::backend::ordered_json Jsonata::evaluate(const jsonata::backend::ordered_json& input,
+//                                          std::shared_ptr<Frame> bindings) {
+//     currentInstance_ = this;
+
+//     // Check for syntax errors (equivalent to Java's check for errors != null)
+//     if (!expression_) {
+//         throw JException("S0500", 0);  // Expression compilation failed
+//     }
+
+//     // Convert JSON input to std::any domain for the evaluator
+//     std::any anyInput = toAny(input);
+
+//     // Always evaluate in a fresh child frame of the shared environment,
+//     // then (optionally) copy provided bindings into it. This avoids
+//     // concurrent mutations of the shared environment.
+//     std::shared_ptr<Frame> exec_env = createFrame(environment_);
+//     if (bindings != nullptr) {
+//         for (const auto& [key, value] : bindings->getBindings()) {
+//             exec_env->bind(key, value);
+//         }
+//     }
+
+//     // TODO: capture timestamp for $now() and $millis() functions
+//     // timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
+//     //     std::chrono::system_clock::now().time_since_epoch()).count();
+
+//     // CRITICAL: if the input is a JSON array, wrap it in a singleton sequence
+//     // Java reference lines 2575-2579:
+//     // if((input instanceof List) && !Utils.isSequence(input)) {
+//     //     input = Utils.createSequence(input);
+//     //     ((JList)input).outerWrapper = true;
+//     // }
+//     std::any processedInput = anyInput;
+//     if (anyInput.has_value() && Utils::isArray(anyInput) &&
+//         !Utils::isSequence(anyInput)) {
+//         auto sequence = Utils::createSequence(anyInput);
+//         sequence.outerWrapper = true;
+//         processedInput = sequence;
+//     }
+
+//     // CRITICAL: put the processed input (which may be wrapped) into the
+//     // fresh execution environment as the root object "$"
+//     exec_env->bind("$", processedInput);
+
+//     if (validateInput_) {
+//         Functions::validateInput(processedInput);
+//     }
+
+//     std::any result;
+//     try {
+//         // Set thread-local input/environment for this evaluation
+//         tls_input_ = processedInput;
+//         tls_environment_ = exec_env;
+//         result = evaluate(expression_, processedInput, exec_env);
+//         // Clear TLS after evaluation to avoid dangling references
+//         tls_input_.reset();
+//         tls_environment_.reset();
+//         result = Utils::convertNulls(result);
+//         // Convert result back to jsonata::backend::ordered_json
+//         return fromAny(result);
+//     } catch (const std::exception& err) {
+//         // TODO: populateMessage(err);
+//         throw;
+//     }
+// }
+
+// jsonata::backend::ordered_json Jsonata::evaluate(std::nullptr_t) {
+//     return evaluate(jsonata::backend::ordered_json());
+// }
+
+// jsonata::backend::ordered_json Jsonata::evaluate(std::nullptr_t,
+//                                          std::shared_ptr<Frame> bindings) {
+//     return evaluate(jsonata::backend::ordered_json(), bindings);
+// }
+
+// // Unordered jsonata::backend::json variants
+// jsonata::backend::json Jsonata::evaluate(const jsonata::backend::json& input) {
+//     return evaluate(input, nullptr);
+// }
+
+// jsonata::backend::json Jsonata::evaluate(const jsonata::backend::json& input,
+//                                  std::shared_ptr<Frame> bindings) {
+//     currentInstance_ = this;
+
+//     if (!expression_) {
+//         throw JException("S0500", 0);
+//     }
+
+//     // Convert JSON input to std::any domain for the evaluator
+//     std::any anyInput = jsonToAny(input);
+
+//     std::shared_ptr<Frame> exec_env = createFrame(environment_);
+//     if (bindings != nullptr) {
+//         for (const auto& [key, value] : bindings->getBindings()) {
+//             exec_env->bind(key, value);
+//         }
+//     }
+
+//     std::any processedInput = anyInput;
+//     if (anyInput.has_value() && Utils::isArray(anyInput) &&
+//         !Utils::isSequence(anyInput)) {
+//         auto sequence = Utils::createSequence(anyInput);
+//         sequence.outerWrapper = true;
+//         processedInput = sequence;
+//     }
+
+//     exec_env->bind("$", processedInput);
+
+//     if (validateInput_) {
+//         Functions::validateInput(processedInput);
+//     }
+
+//     std::any result;
+//     try {
+//         tls_input_ = processedInput;
+//         tls_environment_ = exec_env;
+//         result = evaluate(expression_, processedInput, exec_env);
+//         tls_input_.reset();
+//         tls_environment_.reset();
+//         result = Utils::convertNulls(result);
+//         // Convert result to jsonata::backend::json
+//         return anyToJson(result);
+//     } catch (const std::exception& err) {
+//         throw;
+//     }
+// }
+
+// jsonata::backend::json Jsonata::evaluateUnordered(std::nullptr_t) {
+//     return evaluate(jsonata::backend::json());
+// }
+
+// jsonata::backend::json Jsonata::evaluateUnordered(std::nullptr_t,
+//                                           std::shared_ptr<Frame> bindings) {
+//     return evaluate(jsonata::backend::json(), bindings);
+// }
 
 std::any Jsonata::apply(const std::any& proc, const Utils::JList& args,
                         const std::any& input,
@@ -2657,7 +2731,7 @@ static std::any regexClosure(std::shared_ptr<RegexState> state) {
     if (state->it == state->end) return std::any{};
     auto match = *state->it;
     ++(state->it);
-    nlohmann::ordered_map<std::string, std::any> result;
+    jsonata::backend::ordered_map<std::string, std::any> result;
     result["match"] = std::string(match.str());
     result["start"] = static_cast<long long>(match.position());
     result["end"] = static_cast<long long>(match.position() + match.length());
@@ -2841,9 +2915,9 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                 std::shared_ptr<Frame> environment;
                 if (symbol->value.has_value() &&
                     symbol->value.type() ==
-                        typeid(nlohmann::ordered_map<std::string, std::any>)) {
+                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
                     auto closureMap = std::any_cast<
-                        nlohmann::ordered_map<std::string, std::any>>(
+                        jsonata::backend::ordered_map<std::string, std::any>>(
                         symbol->value);
                     if (closureMap.find("environment") != closureMap.end()) {
                         try {
@@ -2907,16 +2981,16 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             return std::any_cast<bool>(a) ==
                                    std::any_cast<bool>(b);
                         if (a.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>) &&
                             b.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>)) {
                             const auto& ma =
-                                std::any_cast<const nlohmann::ordered_map<
+                                std::any_cast<const jsonata::backend::ordered_map<
                                     std::string, std::any>&>(a);
                             const auto& mb =
-                                std::any_cast<const nlohmann::ordered_map<
+                                std::any_cast<const jsonata::backend::ordered_map<
                                     std::string, std::any>&>(b);
                             if (ma.size() != mb.size()) return false;
                             for (const auto& [k, va] : ma) {
@@ -2958,19 +3032,19 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
 
                     std::function<bool(
                         std::any&, const std::any&,
-                        const nlohmann::ordered_map<std::string, std::any>&)>
+                        const jsonata::backend::ordered_map<std::string, std::any>&)>
                         applyUpdateToFirstMatch =
                             [&](std::any& node, const std::any& target,
-                                const nlohmann::ordered_map<
+                                const jsonata::backend::ordered_map<
                                     std::string, std::any>& updateMap) -> bool {
                         if (node.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>) &&
                             target.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>)) {
                             if (deepEqualsAny(node, target)) {
-                                auto& m = std::any_cast<nlohmann::ordered_map<
+                                auto& m = std::any_cast<jsonata::backend::ordered_map<
                                     std::string, std::any>&>(node);
                                 for (const auto& [k, v] : updateMap) {
                                     m[k] = v;
@@ -2978,7 +3052,7 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 return true;
                             }
                             auto& m = std::any_cast<
-                                nlohmann::ordered_map<std::string, std::any>&>(
+                                jsonata::backend::ordered_map<std::string, std::any>&>(
                                 node);
                             for (auto it = m.begin(); it != m.end(); ++it) {
                                 if (applyUpdateToFirstMatch(it->second, target,
@@ -3017,13 +3091,13 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 const std::vector<std::string>& deletions)
                         -> bool {
                         if (node.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>) &&
                             target.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>)) {
                             if (deepEqualsAny(node, target)) {
-                                auto& m = std::any_cast<nlohmann::ordered_map<
+                                auto& m = std::any_cast<jsonata::backend::ordered_map<
                                     std::string, std::any>&>(node);
                                 for (const auto& key : deletions) {
                                     m.erase(key);
@@ -3031,7 +3105,7 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 return true;
                             }
                             auto& m = std::any_cast<
-                                nlohmann::ordered_map<std::string, std::any>&>(
+                                jsonata::backend::ordered_map<std::string, std::any>&>(
                                 node);
                             for (auto it = m.begin(); it != m.end(); ++it) {
                                 if (applyDeleteToFirstMatch(it->second, target,
@@ -3070,13 +3144,13 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             instance->evaluate(update, match, environment);
                         if (updateValue.has_value()) {
                             if (updateValue.type() !=
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>)) {
                                 throw JException("T2011", update->position,
                                                  updateValue);
                             }
                             const auto& updateMap =
-                                std::any_cast<const nlohmann::ordered_map<
+                                std::any_cast<const jsonata::backend::ordered_map<
                                     std::string, std::any>&>(updateValue);
                             // Apply update to the first occurrence of match
                             // within result
@@ -3088,10 +3162,10 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             // delete uses a structure that deep-equals the
                             // updated node in 'result'.
                             if (match.type() ==
-                                typeid(nlohmann::ordered_map<std::string,
+                                typeid(jsonata::backend::ordered_map<std::string,
                                                              std::any>)) {
                                 auto& matchMap =
-                                    std::any_cast<nlohmann::ordered_map<
+                                    std::any_cast<jsonata::backend::ordered_map<
                                         std::string, std::any>&>(match);
                                 for (const auto& [k, v] : updateMap) {
                                     matchMap[k] = v;
@@ -3220,7 +3294,7 @@ std::any Jsonata::evaluateStages(
                             std::string stageValue =
                                 std::any_cast<std::string>(stage->value);
                             auto tuple = std::any_cast<
-                                nlohmann::ordered_map<std::string, std::any>>(
+                                jsonata::backend::ordered_map<std::string, std::any>>(
                                 tupleList[ee]);
                             tuple[stageValue] = static_cast<int64_t>(ee);
                             tupleList[ee] = std::any(tuple);
@@ -3233,9 +3307,9 @@ std::any Jsonata::evaluateStages(
                     for (size_t ee = 0; ee < resultList.size(); ee++) {
                         if (resultList[ee].type() ==
                             typeid(
-                                nlohmann::ordered_map<std::string, std::any>)) {
+                                jsonata::backend::ordered_map<std::string, std::any>)) {
                             auto tuple = std::any_cast<
-                                nlohmann::ordered_map<std::string, std::any>>(
+                                jsonata::backend::ordered_map<std::string, std::any>>(
                                 resultList[ee]);
                             if (stage->value.has_value()) {
                                 std::string stageValue =
@@ -3373,7 +3447,7 @@ std::any Jsonata::evaluateTupleStep(
             if (sorted.has_value() && Utils::isArray(sorted)) {
                 auto sortedVec = Utils::arrayify(sorted);
                 for (size_t i = 0; i < sortedVec.size(); ++i) {
-                    nlohmann::ordered_map<std::string, std::any> tuple;
+                    jsonata::backend::ordered_map<std::string, std::any> tuple;
                     tuple["@"] = sortedVec[i];
                     if (expr->index.has_value()) {
                         try {
@@ -3412,7 +3486,7 @@ std::any Jsonata::evaluateTupleStep(
         // Java line 435: create initial tuple bindings (only when tupleBindings
         // is null, not just empty)
         for (const auto& item : input) {
-            nlohmann::ordered_map<std::string, std::any> tuple;
+            jsonata::backend::ordered_map<std::string, std::any> tuple;
             tuple["@"] = item;
             bindings.push_back(std::any(tuple));
         }
@@ -3421,7 +3495,7 @@ std::any Jsonata::evaluateTupleStep(
     // Java reference lines 438-472: process each tuple binding
     for (const auto& bindingAny : bindings) {
         auto binding =
-            std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+            std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                 bindingAny);
         // Create frame from tuple - Java line 439
         auto stepEnv = createFrameFromTuple(environment, bindingAny);
@@ -3445,14 +3519,14 @@ std::any Jsonata::evaluateTupleStep(
 
             // Java lines 449-469: create output tuples
             for (size_t i = 0; i < resVec.size(); ++i) {
-                nlohmann::ordered_map<std::string, std::any> tuple(
+                jsonata::backend::ordered_map<std::string, std::any> tuple(
                     binding);  // Copy existing bindings
 
                 if (resVec.tupleStream) {
                     // cast resVec[i] to a map and overwrite existing keys
                     // (match Java Map.putAll semantics)
                     auto resTuple = std::any_cast<
-                        nlohmann::ordered_map<std::string, std::any>>(
+                        jsonata::backend::ordered_map<std::string, std::any>>(
                         resVec[i]);
                     for (const auto& kv : resTuple) {
                         tuple[kv.first] = kv.second;
@@ -3514,14 +3588,14 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
     if (!expr) return std::any{};
 
     // Port exact Java implementation: Jsonata.java lines 1051-1134
-    nlohmann::ordered_map<std::string, std::any> result;
+    jsonata::backend::ordered_map<std::string, std::any> result;
 
     // C++ equivalent of Java's LinkedHashMap<Object,GroupEntry>
     struct GroupEntry {
         std::any data;
         int64_t exprIndex;
     };
-    nlohmann::ordered_map<std::string, GroupEntry> groups;
+    jsonata::backend::ordered_map<std::string, GroupEntry> groups;
 
     // Java line 1054: var reduce = (_input instanceof JList) &&
     // ((JList)_input).tupleStream ? true : false; For now, simplify this - the
@@ -3559,7 +3633,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
                 ? createFrameFromTuple(
                       environment,
                       std::any_cast<
-                          nlohmann::ordered_map<std::string, std::any>>(item))
+                          jsonata::backend::ordered_map<std::string, std::any>>(item))
                 : environment;
 
         for (size_t pairIndex = 0; pairIndex < expr->lhsObject.size();
@@ -3571,7 +3645,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
             std::any keyContext = item;
             if (reduce) {
                 auto itemMap =
-                    std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                    std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                         item);
                 auto atIt = itemMap.find("@");
                 keyContext =
@@ -3638,7 +3712,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
         if (reduce) {
             auto tuple = reduceTupleStream(entry.data);
             auto tupleMap =
-                std::any_cast<nlohmann::ordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
                     tuple);
             auto atIt = tupleMap.find("@");
             context = (atIt != tupleMap.end()) ? atIt->second : std::any{};
@@ -3684,7 +3758,7 @@ std::any Jsonata::evaluateTransformExpression(
     transformer->arguments.push_back(dummyArg);
 
     // Store the closure environment
-    transformer->value = nlohmann::ordered_map<std::string, std::any>{
+    transformer->value = jsonata::backend::ordered_map<std::string, std::any>{
         {"input", input}, {"environment", environment}};
 
     return transformer;
diff --git a/src/jsonata/Parser.cpp b/src/jsonata/Parser.cpp
index c85c977..9f85633 100644
--- a/src/jsonata/Parser.cpp
+++ b/src/jsonata/Parser.cpp
@@ -1559,7 +1559,7 @@ void Parser::pushAncestry(std::shared_ptr<Symbol> result,
     if (!value || !result) return;
 
     if (!value->seekingParentList.empty() || value->type == "parent") {
-        auto slots = value->seekingParentList;
+        auto slotList = value->seekingParentList;
         if (value->type == "parent") {
             // Add parent slot if available
             if (value->slot.has_value()) {
@@ -1567,7 +1567,7 @@ void Parser::pushAncestry(std::shared_ptr<Symbol> result,
                     auto parentSlot =
                         std::any_cast<std::shared_ptr<Symbol>>(value->slot);
                     if (parentSlot) {
-                        slots.push_back(parentSlot);
+                        slotList.push_back(parentSlot);
                     }
                 } catch (const std::bad_any_cast&) {
                     // Handle conversion error
@@ -1576,10 +1576,10 @@ void Parser::pushAncestry(std::shared_ptr<Symbol> result,
         }
 
         if (result->seekingParentList.empty()) {
-            result->seekingParentList = slots;
+            result->seekingParentList = slotList;
         } else {
             result->seekingParentList.insert(result->seekingParentList.end(),
-                                             slots.begin(), slots.end());
+                                             slotList.begin(), slotList.end());
         }
     }
 }
@@ -1591,7 +1591,7 @@ void Parser::resolveAncestry(std::shared_ptr<Symbol> path) {
     auto lastStep = path->steps[index];
     if (!lastStep) return;
 
-    auto slots = lastStep->seekingParentList;
+    auto slotList = lastStep->seekingParentList;
 
     if (lastStep->type == "parent") {
         // Add parent slot if available
@@ -1600,7 +1600,7 @@ void Parser::resolveAncestry(std::shared_ptr<Symbol> path) {
                 auto parentSlot =
                     std::any_cast<std::shared_ptr<Symbol>>(lastStep->slot);
                 if (parentSlot) {
-                    slots.push_back(parentSlot);
+                    slotList.push_back(parentSlot);
                 }
             } catch (const std::bad_any_cast&) {
                 // Handle conversion error
@@ -1608,7 +1608,7 @@ void Parser::resolveAncestry(std::shared_ptr<Symbol> path) {
         }
     }
 
-    for (auto slot : slots) {
+    for (auto slot : slotList) {
         if (!slot) continue;
         index = path->steps.size() - 2;
         while (slot && slot->level > 0) {
diff --git a/src/jsonata/Tokenizer.cpp b/src/jsonata/Tokenizer.cpp
index 066e2ad..4c71ec8 100644
--- a/src/jsonata/Tokenizer.cpp
+++ b/src/jsonata/Tokenizer.cpp
@@ -25,6 +25,7 @@
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include <array>
 
 #include "jsonata/JException.h"
 #include "jsonata/Utils.h"
@@ -375,8 +376,8 @@ std::unique_ptr<Tokenizer::Token> Tokenizer::next(bool prefix) {
         // Use byte offsets to get iterators into the original string without copying
         auto byteStart = path_.cbegin() + static_cast<std::string::difference_type>(byte_offsets_[position_]);
         auto byteEnd = path_.cend();
-        std::cmatch match;
-        if (std::regex_search(&*byteStart, &*byteEnd, match, numregex) &&
+        std::smatch match;
+        if (std::regex_search(byteStart, byteEnd, match, numregex) &&
             match.position() == 0) {
             std::string numStr = match.str(0);
             double num = std::stod(numStr);
diff --git a/src/jsonata/Utils.cpp b/src/jsonata/Utils.cpp
index af969c3..b9cd425 100644
--- a/src/jsonata/Utils.cpp
+++ b/src/jsonata/Utils.cpp
@@ -172,7 +172,7 @@ bool Utils::isArray(const std::any& value) {
 
 bool Utils::isObject(const std::any& value) {
     if (!value.has_value()) return false;
-    return value.type() == typeid(nlohmann::ordered_map<std::string, std::any>);
+    return value.type() == typeid(jsonata::backend::ordered_map<std::string, std::any>);
 }
 
 std::optional<std::string> Utils::type(const std::any& value) {
@@ -401,7 +401,7 @@ std::any Utils::convertNulls(const std::any& res) {
 void Utils::convertNullsMap(std::any& res) {
     try {
         auto& map =
-            std::any_cast<nlohmann::ordered_map<std::string, std::any>&>(res);
+            std::any_cast<jsonata::backend::ordered_map<std::string, std::any>&>(res);
         for (auto it = map.begin(); it != map.end(); ++it) {
             std::any& valRef = it->second;
             std::any converted = convertValue(valRef);
diff --git a/src/jsonata/utils/DateTimeUtils.cpp b/src/jsonata/utils/DateTimeUtils.cpp
index ac0f60f..3ad4b58 100644
--- a/src/jsonata/utils/DateTimeUtils.cpp
+++ b/src/jsonata/utils/DateTimeUtils.cpp
@@ -205,6 +205,10 @@ std::string DateTimeUtils::numberToWords(int64_t value, bool ordinal) {
 
 std::string DateTimeUtils::lookup(int64_t num, bool prev, bool ord) {
     std::string words = "";
+    if( num < 0 ) {
+        // negative numbers trigger 'out of range' exception in windows
+        num = 0;
+    }
     if (num <= 19) {
         words = (prev ? " and " : "") + (ord ? ordinals[num] : few[num]);
     } else if (num < 100) {
@@ -672,7 +676,7 @@ std::string DateTimeUtils::formatDateTime(int64_t millis,
     int64_t offsetHours = 0;
     int64_t offsetMinutes = 0;
 
-    if (!timezone.empty()) {
+    if (!timezone.empty() && timezone != "UTC") {
         try {
             int64_t offset = std::stoi(timezone);
             offsetHours = offset / 100;
diff --git a/src/jsonata/utils/Signature.cpp b/src/jsonata/utils/Signature.cpp
index 711c0d8..efcd5f4 100644
--- a/src/jsonata/utils/Signature.cpp
+++ b/src/jsonata/utils/Signature.cpp
@@ -21,7 +21,7 @@
 #include <algorithm>
 #include <functional>
 #include <iostream>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <sstream>
 #include <stdexcept>
 
@@ -131,7 +131,7 @@ bool Signature::isArrayType(const std::any &value) {
 std::string Signature::checkObjectType(const std::any &value) {
     // Try map (object)
     try {
-        std::any_cast<nlohmann::ordered_map<std::string, std::any>>(value);
+        auto r = std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(value);
         return "o";
     } catch (const std::bad_any_cast &) {
         // Try shared_ptr<map> - check if it's a regex object
@@ -148,12 +148,12 @@ bool Signature::isFunctionType(const std::any &value) {
     // Check for JFunction (native functions like $sum, $map, etc.) - Java
     // reference equivalent
     try {
-        std::any_cast<JFunction>(value);
+        auto r = std::any_cast<JFunction>(value);
         return true;
     } catch (const std::bad_any_cast &) {
         // Check for std::function (generic function objects)
         try {
-            std::any_cast<std::function<std::any()>>(value);
+            auto r = std::any_cast<std::function<std::any()>>(value);
             return true;
         } catch (const std::bad_any_cast &) {
             return false;
diff --git a/test/ArrayTest.cpp b/test/ArrayTest.cpp
index 0ec2713..b938d71 100644
--- a/test/ArrayTest.cpp
+++ b/test/ArrayTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 
 namespace jsonata {
@@ -18,18 +18,18 @@ class ArrayTest : public ::testing::Test {
 
 TEST_F(ArrayTest, testNegativeIndex) {
     Jsonata expr1("item[-1]");
-    auto input1 = nlohmann::ordered_json::parse(R"({"item": []})");
+    auto input1 = JSONATA_TEST_BACKEND::parse(R"({"item": []})");
     auto result1 = expr1.evaluate(input1);
     EXPECT_TRUE(result1.is_null());
 
     Jsonata expr2("$[-1]");
-    auto result2 = expr2.evaluate(nlohmann::ordered_json::array());
+    auto result2 = expr2.evaluate(JSONATA_TEST_BACKEND::array());
     EXPECT_TRUE(result2.is_null());
 }
 
 TEST_F(ArrayTest, testArray) {
     // Create test data equivalent to Java: Map.of("key", Arrays.asList(Map.of("x", "y"), Map.of("a", "b")))
-    auto data = nlohmann::ordered_json::parse(R"({"key": [{"x": "y"}, {"a": "b"}]})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"key": [{"x": "y"}, {"a": "b"}]})");
 
     // Test first expression: {'key': $append($.[{'x': 'y'}],$.[{'a': 'b'}])}
     Jsonata expr1("{'key': $append($.[{'x': 'y'}],$.[{'a': 'b'}])}");
@@ -48,7 +48,7 @@ TEST_F(ArrayTest, DISABLED_filterTest) {
     // This test is disabled as in the Java version
     Jsonata expr("($arr := [{'x':1}, {'x':2}];$arr[x=$number(variable.field)])");
 
-    auto inputData = nlohmann::ordered_json::parse(R"({"variable": {"field": "1"}})");
+    auto inputData = JSONATA_TEST_BACKEND::parse(R"({"variable": {"field": "1"}})");
 
     auto result = expr.evaluate(inputData);
     EXPECT_TRUE(result != nullptr);
@@ -56,29 +56,29 @@ TEST_F(ArrayTest, DISABLED_filterTest) {
 
 TEST_F(ArrayTest, testIndex) {
     Jsonata expr("($x:=['a','b']; $x#$i.$i)");
-    auto result1 = expr.evaluate(nlohmann::ordered_json(1));
-    auto expected = nlohmann::ordered_json::parse("[0, 1]");
+    auto result1 = expr.evaluate(JSONATA_TEST_BACKEND(1));
+    auto expected = JSONATA_TEST_BACKEND::parse("[0, 1]");
     EXPECT_EQ(result1.dump(), expected.dump());
 
-    auto result2 = expr.evaluate(nlohmann::ordered_json(nullptr));
+    auto result2 = expr.evaluate(JSONATA_TEST_BACKEND(nullptr));
     EXPECT_EQ(result2.dump(), expected.dump());
 }
 
 TEST_F(ArrayTest, testWildcard) {
     Jsonata expr("*");
-    auto input = nlohmann::ordered_json::parse(R"([{"x": 1}])");
+    auto input = JSONATA_TEST_BACKEND::parse(R"([{"x": 1}])");
     auto result = expr.evaluate(input);
-    auto expected = nlohmann::ordered_json::parse(R"({"x": 1})");
+    auto expected = JSONATA_TEST_BACKEND::parse(R"({"x": 1})");
     EXPECT_EQ(result.dump(), expected.dump());
 }
 
 TEST_F(ArrayTest, testWildcardFilter) {
-    auto data = nlohmann::ordered_json::parse(
+    auto data = JSONATA_TEST_BACKEND::parse(
         R"([{"value": {"Name": "Cell1", "Product": "Product1"}}, {"value": {"Name": "Cell2", "Product": "Product2"}}])");
 
     Jsonata expression("*[value.Product = 'Product1']");
     auto result1 = expression.evaluate(data);
-    auto expected = nlohmann::ordered_json::parse(
+    auto expected = JSONATA_TEST_BACKEND::parse(
         R"({"value": {"Name": "Cell1", "Product": "Product1"}})");
     EXPECT_EQ(result1.dump(), expected.dump());
 
@@ -90,7 +90,7 @@ TEST_F(ArrayTest, testWildcardFilter) {
 TEST_F(ArrayTest, testAssertCustomMessage) {
     Jsonata expr("$assert(false, 'custom error')");
     try {
-        expr.evaluate(nullptr);
+        expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
         FAIL() << "Expected JException";
     } catch (const JException& e) {
         std::string msg = e.what();
diff --git a/test/CustomFunctionTest.cpp b/test/CustomFunctionTest.cpp
index a1c0fcf..708293e 100644
--- a/test/CustomFunctionTest.cpp
+++ b/test/CustomFunctionTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <jsonata/Functions.h>
 #include <vector>
@@ -19,7 +19,7 @@ TEST_F(CustomFunctionTest, testSupplier) {
     Jsonata expression("$greet()");
     // Register zero-arg function via typed overload
     expression.registerFunction<std::string>("greet", []() { return std::string("Hello world"); });
-    auto result = expression.evaluate(nullptr);
+    auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "Hello world");
 }
@@ -27,7 +27,7 @@ TEST_F(CustomFunctionTest, testSupplier) {
 TEST_F(CustomFunctionTest, testEval) {
     Jsonata expression("$eval('$greet()')");
     expression.registerFunction<std::string>("greet", []() { return std::string("Hello world"); });
-    auto result = expression.evaluate(nullptr);
+    auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "Hello world");
 }
@@ -35,7 +35,7 @@ TEST_F(CustomFunctionTest, testEval) {
 TEST_F(CustomFunctionTest, testEvalWithParams) {
     Jsonata expression("($eval('$greet()'))");
     expression.registerFunction<std::string>("greet", []() { return std::string("Hello world"); });
-    auto result = expression.evaluate(nullptr);
+    auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "Hello world");
 }
@@ -43,7 +43,7 @@ TEST_F(CustomFunctionTest, testEvalWithParams) {
 TEST_F(CustomFunctionTest, testUnary) {
     Jsonata expression("$echo(123)");
     expression.registerFunction<int64_t,int64_t>("echo", [](int64_t x) { return x; });
-    auto result = expression.evaluate(nullptr);
+    auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_number());
     EXPECT_EQ(result.get<int>(), 123);
 }
@@ -51,7 +51,7 @@ TEST_F(CustomFunctionTest, testUnary) {
 TEST_F(CustomFunctionTest, testBinary) {
     Jsonata expression("$add(21, 21)");
     expression.registerFunction<int64_t,int64_t,int64_t>("add", [](int64_t a, int64_t b) { return a + b; });
-    auto result = expression.evaluate(nullptr);
+    auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_number());
     EXPECT_EQ(result.get<int>(), 42);
 }
@@ -68,7 +68,7 @@ TEST_F(CustomFunctionTest, testTernary) {
     };
     expression.registerFunction("abc", abc);
 
-    nlohmann::ordered_json data = {{"a","a"},{"b","b"},{"c","c"}};
+    JSONATA_TEST_BACKEND data= JSONATA_TEST_BACKEND::object({{"a","a"},{"b","b"},{"c","c"}});
     auto result = expression.evaluate(data);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "abc");
@@ -91,7 +91,7 @@ TEST_F(CustomFunctionTest, testLambdaSignatureError) {
         return std::to_string(a) + (b ? "true" : "false");
     };
     expression.registerFunction("append", append);
-    EXPECT_THROW(expression.evaluate(nullptr), std::runtime_error);
+    EXPECT_THROW(expression.evaluate<JSONATA_TEST_BACKEND>(nullptr), std::runtime_error);
 }
 
 TEST_F(CustomFunctionTest, testJFunctionSignatureError) {
@@ -104,7 +104,7 @@ TEST_F(CustomFunctionTest, testJFunctionSignatureError) {
     expression.registerFunction("append", append);
 
     try {
-        expression.evaluate(nullptr);
+        expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
         FAIL() << "Expected JException";
     } catch (const JException& ex) {
         EXPECT_EQ(ex.getError(), "T0410");
diff --git a/test/DateTimeTest.cpp b/test/DateTimeTest.cpp
index 8b05791..185491d 100644
--- a/test/DateTimeTest.cpp
+++ b/test/DateTimeTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -20,7 +20,7 @@ class DateTimeTest : public ::testing::Test {
 
 TEST_F(DateTimeTest, testFormatInteger) {
     Jsonata expr("$toMillis('2018th', '[Y0001;o]')");
-    auto result = expr.evaluate(nullptr);
+    auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_number_integer());
     EXPECT_EQ(result.get<long long>(), 1514764800000LL);
 }
@@ -29,7 +29,7 @@ TEST_F(DateTimeTest, testToMillis) {
     std::string noZoneTooPrecise = "2024-08-27T22:43:15.78133";
     Jsonata expr("$fromMillis($toMillis($))");
     
-    auto inputData = nlohmann::ordered_json(noZoneTooPrecise);
+    auto inputData = JSONATA_TEST_BACKEND(noZoneTooPrecise);
     auto result = expr.evaluate(inputData);
     
     // Debug: Print what we actually got
diff --git a/test/Generate.cpp b/test/Generate.cpp
index 6dd3a73..25e4676 100644
--- a/test/Generate.cpp
+++ b/test/Generate.cpp
@@ -13,9 +13,9 @@
 #include <vector>
 #include <algorithm>
 #include <sstream>
-#include <nlohmann/json.hpp>
+#include <any>
+#include "jsonata/backends.h"
 
-using nlohmann::ordered_json;
 namespace fs = std::filesystem;
 
 class JsonataTestGenerator {
@@ -112,7 +112,7 @@ class JsonataTestGenerator {
     }
 
     // Extract expression from test case for comment
-    static std::string getExpressionComment(const ordered_json& testCase) {
+    static std::string getExpressionComment(const JSONATA_TEST_BACKEND& testCase) {
         if (testCase.is_object() && testCase.contains("expr") && testCase["expr"].is_string())
             return escapeString(testCase["expr"].get<std::string>());
         return "";
@@ -235,7 +235,7 @@ class JsonataTestGenerator {
         
         try {
             // First try parsing the content as-is
-            auto jsonValue = ordered_json::parse(content);
+            auto jsonValue = JSONATA_TEST_BACKEND::parse(content);
 
             int testCount = 0;
 
@@ -259,7 +259,7 @@ class JsonataTestGenerator {
             
             try {
                 std::string processedContent = preprocessJsonContent(content);
-                auto jsonValue = ordered_json::parse(processedContent);
+                auto jsonValue = JSONATA_TEST_BACKEND::parse(processedContent);
                 int testCount = 0;
                 if (jsonValue.is_array()) {
                     for (size_t i = 0; i < jsonValue.size(); ++i) {
diff --git a/test/JsonataTest.cpp b/test/JsonataTest.cpp
index 9ce148e..c821d43 100644
--- a/test/JsonataTest.cpp
+++ b/test/JsonataTest.cpp
@@ -1,671 +1,829 @@
 #include "JsonataTest.h"
-#include <jsonata/Utils.h>
-#include <iostream>
-#include <fstream>
-#include <filesystem>
-#include <sstream>
 #include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <jsonata/Utils.h>
 #include <set>
+#include <sstream>
 
-namespace jsonata {
-
-// Static member initialization
-JsonataTest::TestOverrides* JsonataTest::testOverrides = nullptr;
-
-JsonataTest::JsonataTest() {
-    // Initialize debug based on environment or other factors
-    // For now, default to false
-    debug = false;
-    ignoreOverrides = false;
-    testFiles = 0;
-    testCases = 0;
-}
-
-bool JsonataTest::testExpr(const std::string& expr, 
-                          nlohmann::ordered_json data, 
-                          const std::map<std::string, nlohmann::ordered_json>& bindings,
-                          nlohmann::ordered_json expected, 
-                          const std::optional<std::string>& code,
-                          const std::optional<long>& timelimit,
-                          const std::optional<int>& depth,
-                          bool unordered) {
-    bool success = true;
-    try {
-
-        
-        if (debug) {
-            std::cout << "DEBUG: Full expression=[" << expr << "] Length=" << expr.length() << std::endl;
-            std::cout << "Expr=" << expr << " Expected=";
-            std::cout << expected.dump();
-            std::cout << " ErrorCode=" << (code ? *code : "null") << std::endl;
-            std::cout << "Data=" << data.dump() << std::endl;
-        }
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace jsonata
+{
+    // Static member initialization
+    JsonataTest::TestOverrides *JsonataTest::testOverrides = nullptr;
+
+    JsonataTest::JsonataTest()
+    {
+        // Initialize debug based on environment or other factors
+        // For now, default to false
+        debug = true;
+        ignoreOverrides = false;
+        testFiles = 0;
+        testCases = 0;
+    }
 
+    bool JsonataTest::testExpr(const std::string &expr,
+                               JSONATA_TEST_BACKEND data,
+                               const std::map<std::string, JSONATA_TEST_BACKEND> &bindings,
+                               JSONATA_TEST_BACKEND expected,
+                               const std::optional<std::string> &code,
+                               const std::optional<long> &timelimit,
+                               const std::optional<int> &depth,
+                               bool unordered)
+    {
+        bool success = true;
+        try {
+            if (debug) {
+                std::cout << "DEBUG: Full expression=[" << expr << "] Length=" << expr.length()
+                          << std::endl;
+                std::cout << "Expr=" << expr << " Expected=";
+                std::cout << expected.dump();
+                std::cout << " ErrorCode=" << (code ? *code : "null") << std::endl;
+                std::cout << "Data=" << data.dump() << std::endl;
+            }
 
-        // Create Jsonata instance with parsed expression, like Java does
-        Jsonata jsonata(expr);
-        
-        std::shared_ptr<Frame> bindingFrame = nullptr;
-        // Java reference: if (bindings!=null) - in C++, bindings is always valid, so always create frame
-        // This matches Java logic exactly: create binding frame even for empty bindings map
-        bindingFrame = jsonata.createFrame();
-        for (const auto& [key, value] : bindings) {
-            bindingFrame->bind(key, Jsonata::orderedJsonToAny(value));
-        }
-        
-        // Java reference: set runtime bounds only when explicitly specified in test JSON
-        // This matches the exact Java logic where tests like performance tests have no bounds
-        if (timelimit.has_value() && depth.has_value()) {
-            // Test specifies explicit runtime bounds (like tail_recursionTest.case005) - use them
-            if (bindingFrame) {
-                bindingFrame->setRuntimeBounds(*timelimit, *depth);
+            // Create Jsonata instance with parsed expression, like Java does
+            Jsonata jsonata(expr);
+
+            std::shared_ptr<Frame> bindingFrame = nullptr;
+            // Java reference: if (bindings!=null) - in C++, bindings is always valid, so always create frame
+            // This matches Java logic exactly: create binding frame even for empty bindings map
+            bindingFrame = jsonata.createFrame();
+            for (const auto &[key, value] : bindings) {
+                bindingFrame->bind(key, Jsonata::toAny(value));
             }
-        }
-        // Note: If no timelimit/depth specified (like performanceTest.case000), NO runtime bounds are set
-        // This allows performance tests to run without artificial limits, matching Java behavior
-        
-        // Use data directly as JsonValue for the evaluate call
-        auto result = jsonata.evaluate(data, bindingFrame);
-        
-        if (code.has_value()) {
-            success = false;  // Expected an error but didn't get one
-        }
 
-        bool expectedIsNull = expected.is_null();
-        bool resultIsNull = result.is_null();
-
-        if (!expectedIsNull) {
-            // Compare using canonical nlohmann::json (unordered object semantics)
-            nlohmann::json exp = nlohmann::json::parse(expected.dump());
-            nlohmann::json res = nlohmann::json::parse(result.dump());
-            
-            if (unordered && exp.is_array() && res.is_array()) {
-                // Simple unordered compare via multiset of dumps
-                if (exp.size() != res.size()) success = false;
-                else {
-                    std::multiset<std::string> a, b;
-                    for (const auto& el : exp) a.insert(el.dump());
-                    for (const auto& el : res) b.insert(el.dump());
-                    if (a != b) success = false;
-                }
-            } else {
-                if (exp != res) {
-                    success = false;
+            // Java reference: set runtime bounds only when explicitly specified in test JSON
+            // This matches the exact Java logic where tests like performance tests have no bounds
+            if (timelimit.has_value() && depth.has_value()) {
+                // Test specifies explicit runtime bounds (like tail_recursionTest.case005) - use them
+                if (bindingFrame) {
+                    bindingFrame->setRuntimeBounds(*timelimit, *depth);
                 }
             }
-        }
+            // Note: If no timelimit/depth specified (like performanceTest.case000), NO runtime bounds are set
+            // This allows performance tests to run without artificial limits, matching Java behavior
 
-        if (expectedIsNull && !resultIsNull) {
-            success = false;
-        }
+            // Use data directly as JsonValue for the evaluate call
+            auto result = jsonata.evaluate(data, bindingFrame);
 
-        if (debug && success) {
-            std::cout << "--Result = " << result.dump() << std::endl;
-        }
+            if (code.has_value()) {
+                success = false; // Expected an error but didn't get one
+            }
 
-        if (!success) {
-            std::cout << "--Expr=" << expr << std::endl;
-            std::cout << "--Expected=";
-            std::cout << expected.dump() << std::endl;
-            std::cout << " ErrorCode=" << (code ? *code : "null") << std::endl;
-            std::cout << "--Data=" << data.dump() << std::endl;
-            std::cout << "--Result = " << result.dump() << std::endl;
-            std::cout << "WRONG RESULT" << std::endl;
-        }
+            bool expectedIsNull = expected.is_null();
+            bool resultIsNull = result.is_null();
+
+            if (!expectedIsNull) {
+                // Compare using canonical jsonata::backend::json (unordered object semantics)
+                jsonata::backend::json exp = jsonata::backend::json::parse(expected.dump());
+                jsonata::backend::json res = jsonata::backend::json::parse(result.dump());
+
+                if (unordered && exp.is_array() && res.is_array()) {
+                    // Simple unordered compare via multiset of dumps
+                    if (exp.size() != res.size())
+                        success = false;
+                    else {
+                        std::multiset<std::string> a, b;
+                        jsonata::backend::forAll(exp, [&a](auto k, auto v) {
+                            jsonata::backend::dump( v );
+                        });
+                        jsonata::backend::forAll(res, [&b](auto k, auto v) {
+                            jsonata::backend::dump( v );
+                        });
+                        // for (const auto& el : exp) a.insert(el.dump());
+                        // for (const auto& el : res) b.insert(el.dump());
+                        if (a != b)
+                            success = false;
+                    }
+                } else {
+                    if (exp != res) {
+                        success = false;
+                    }
+                }
+            }
 
-    } catch (const std::exception& e) {
-        if (!code.has_value()) {
-            std::cout << "--Expr=" << expr << " Expected=";
-            std::cout << expected.dump();
-            std::cout << " ErrorCode=" << (code ? *code : "null") << std::endl;
-            std::cout << "--Data=" << data.dump() << std::endl;
+            if (expectedIsNull && !resultIsNull) {
+                success = false;
+            }
 
-            if (auto* je = dynamic_cast<const JException*>(&e)) {
-                std::cout << "--Exception     = " << je->getError() << "  --> " << e.what() << std::endl;
-            } else {
-                std::cout << "--Exception     = " << e.what() << std::endl;
+            if (debug && success) {
+                std::cout << "--Result = " << result.dump() << std::endl;
             }
 
-            std::cout << "--ExpectedError = " << (code ? *code : "null") << " Expected=" << expected.dump() << std::endl;
-            std::cout << "WRONG RESULT (exception)" << std::endl;
-            success = false;
-        }
-        if (debug && success) {
-            std::cout << "--Exception = " << e.what() << std::endl;
-        }
-    }
-    return success;
-}
-
-nlohmann::ordered_json JsonataTest::toJson(const std::string& jsonStr) {
-    return nlohmann::ordered_json::parse(jsonStr);
-}
-
-// Helper function to preprocess JSON content to fix common issues
-std::string JsonataTest::preprocessJsonContent(const std::string& content) {
-    // Check if content contains UTF-8 sequences (high bit set)
-    // If so, skip preprocessing to avoid corrupting Unicode characters
-    for (unsigned char c : content) {
-        if (c > 127) {
-            // Contains UTF-8, return original content unchanged
-            return content;
-        }
-    }
-    
-    std::string result = content;
-    
-    // Replace unescaped control characters in strings
-    // This is a simple approach - replace unescaped newlines, tabs, etc.
-    bool inString = false;
-    bool escaped = false;
-    
-    for (size_t i = 0; i < result.length(); ++i) {
-        char c = result[i];
-        
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        
-        if (c == '\\' && inString) {
-            escaped = true;
-            continue;
-        }
-        
-        if (c == '"') {
-            inString = !inString;
-            continue;
-        }
-        
-        // If we're in a string and encounter control characters, escape them
-        if (inString && c < 0x20) {
-            switch (c) {
-                case '\n':
-                    result[i] = 'n';
-                    result.insert(i, "\\");
-                    i++; // Skip the inserted backslash
-                    break;
-                case '\r':
-                    result[i] = 'r';
-                    result.insert(i, "\\");
-                    i++;
-                    break;
-                case '\t':
-                    result[i] = 't';
-                    result.insert(i, "\\");
-                    i++;
-                    break;
-                default:
-                    result[i] = ' '; // Replace with space
-                    break;
+            if (!success) {
+                std::cout << "--Expr=" << expr << std::endl;
+                std::cout << "--Expected=";
+                std::cout << expected.dump() << std::endl;
+                std::cout << " ErrorCode=" << (code ? *code : "null") << std::endl;
+                std::cout << "--Data=" << data.dump() << std::endl;
+                std::cout << "--Result = " << result.dump() << std::endl;
+                std::cout << "WRONG RESULT" << std::endl;
             }
-        }
-    }
-    
-    return result;
-}
-
-  nlohmann::ordered_json JsonataTest::readJson(const std::string& name) {
-    std::ifstream file(name);
-    if (!file.is_open()) {
-        throw std::runtime_error("Cannot open file: " + name);
-    }
-    
-    std::stringstream buffer;
-    buffer << file.rdbuf();
-    std::string content = buffer.str();
-    
-    try {
-        return nlohmann::ordered_json::parse(content);
-    } catch (const std::exception&) {
-        // Try a light preprocessing pass
-        try {
-            std::string processedContent = preprocessJsonContent(content);
-            return nlohmann::ordered_json::parse(processedContent);
-        } catch (const std::exception&) {
-            // Fallback: salvage minimal fields from malformed JSON (e.g., invalid \u surrogates)
-            // Extract expr
-            auto findValueString = [](const std::string& src, const std::string& key) -> std::optional<std::string> {
-                std::string needle = "\"" + key + "\"";
-                size_t pos = src.find(needle);
-                if (pos == std::string::npos) return std::nullopt;
-                pos = src.find('"', pos + needle.size());
-                if (pos == std::string::npos) return std::nullopt;
-                size_t start = pos + 1;
-                size_t end = src.find('"', start);
-                if (end == std::string::npos) return std::nullopt;
-                return src.substr(start, end - start);
-            };
-
-            nlohmann::ordered_json fallback;
-            if (auto exprStr = findValueString(content, "expr")) {
-                // Keep raw expression including escapes (Jsonata parser will handle \u escapes)
-                fallback["expr"] = *exprStr;
-            }
-            if (auto datasetStr = findValueString(content, "dataset")) {
-                fallback["dataset"] = *datasetStr;
-            }
-            if (auto codeStr = findValueString(content, "code")) {
-                nlohmann::ordered_json err;
-                err["code"] = *codeStr;
-                fallback["error"] = err;
-            }
-            if (fallback.empty()) {
-                // As a last resort, rethrow original error
-                throw;
-            }
-            return fallback;
-        }
-    }
-}
 
-void JsonataTest::runCase(const std::string& name) {
-    try {
-        if (!runTestSuite(name)) {
-            throw std::runtime_error("Test case failed: " + name);
-        }
-    } catch (const std::exception& e) {
-        std::cerr << "Error in runCase(" << name << "): " << e.what() << std::endl;
-        throw;
-    }
-}
+        } catch (const std::exception &e) {
+            if (!code.has_value()) {
+                std::cout << "--Expr=" << expr << " Expected=";
+                std::cout << expected.dump();
+                std::cout << " ErrorCode=" << (code ? *code : "null") << std::endl;
+                std::cout << "--Data=" << data.dump() << std::endl;
+
+                if (auto *je = dynamic_cast<const JException *>(&e)) {
+                    std::cout << "--Exception     = " << je->getError() << "  --> " << e.what()
+                              << std::endl;
+                } else {
+                    std::cout << "--Exception     = " << e.what() << std::endl;
+                }
 
-void JsonataTest::runSubCase(const std::string& name, int subNr) {
-    try {
-        auto cases = readJson(name);
-        if (!cases.is_array()) {
-            throw std::runtime_error("Test file does not contain array: " + name);
-        }
-        
-        const auto& caseArray = cases;
-        if (subNr < 0 || subNr >= static_cast<int>(caseArray.size())) {
-            throw std::runtime_error("Invalid subcase index: " + std::to_string(subNr));
-        }
-        
-        auto testCase = caseArray[subNr];
-        if (!testCase.is_object()) {
-            throw std::runtime_error("Test case is not an object");
-        }
-        
-        const auto& testObj = testCase;
-        std::map<std::string, nlohmann::ordered_json> testDef;
-        for (auto it = testObj.begin(); it != testObj.end(); ++it) testDef[it.key()] = it.value();
-        
-        if (!runTestCase(name + "_" + std::to_string(subNr), testDef)) {
-            throw std::runtime_error("Test subcase failed: " + name + "_" + std::to_string(subNr));
+                std::cout << "--ExpectedError = " << (code ? *code : "null")
+                          << " Expected=" << expected.dump() << std::endl;
+                std::cout << "WRONG RESULT (exception)" << std::endl;
+                success = false;
+            }
+            if (debug && success) {
+                std::cout << "--Exception = " << e.what() << std::endl;
+            }
         }
-    } catch (const std::exception& e) {
-        std::cerr << "Error in runSubCase(" << name << ", " << subNr << "): " << e.what() << std::endl;
-        throw;
+        return success;
     }
-}
 
-bool JsonataTest::runTestSuite(const std::string& name) {
-    try {
-        testFiles++;
-        bool success = true;
+    JSONATA_TEST_BACKEND JsonataTest::toJson(const std::string &jsonStr)
+    {
+        return JSONATA_TEST_BACKEND::parse(jsonStr);
+    }
 
-        auto testCase = readJson(name);
-        if (testCase.is_null()) {
-            return false;
-        }
-        
-        if (testCase.is_array()) {
-            // Some cases contain a list of test cases
-            const auto& testArray = testCase;
-            for (const auto& testDef : testArray) {
-                if (testDef.is_object()) {
-                    std::map<std::string, nlohmann::ordered_json> testDefMap;
-                    for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
-                    std::cout << "Running sub-test" << std::endl;
-                    success &= runTestCase(name, testDefMap);
-                }
+    // Helper function to preprocess JSON content to fix common issues
+    std::string JsonataTest::preprocessJsonContent(const std::string &content)
+    {
+        // Check if content contains UTF-8 sequences (high bit set)
+        // If so, skip preprocessing to avoid corrupting Unicode characters
+        for (unsigned char c : content) {
+            if (c > 127) {
+                // Contains UTF-8, return original content unchanged
+                return content;
             }
-        } else if (testCase.is_object()) {
-            const auto& testObj = testCase;
-            std::map<std::string, nlohmann::ordered_json> testDefMap;
-            for (auto it = testObj.begin(); it != testObj.end(); ++it) testDefMap[it.key()] = it.value();
-            success &= runTestCase(name, testDefMap);
         }
-        
-        return success;
-    } catch (const std::exception& e) {
-        std::cerr << "Error in runTestSuite(" << name << "): " << e.what() << std::endl;
-        return false;
-    }
-}
-
-void JsonataTest::replaceNulls(nlohmann::ordered_json& o) {
-    if (o.is_array()) {
-        for (auto& item : o) replaceNulls(item);
-    } else if (o.is_object()) {
-        for (auto it = o.begin(); it != o.end(); ++it) replaceNulls(it.value());
-    } else if (o.is_null()) {
-        o = "__JSON_NULL_VALUE__";
-    }
-}
 
-JsonataTest::TestOverrides* JsonataTest::getTestOverrides() {
-    if (testOverrides != nullptr) {
-        return testOverrides;
-    }
+        std::string result = content;
+
+        // Replace unescaped control characters in strings
+        // This is a simple approach - replace unescaped newlines, tabs, etc.
+        bool inString = false;
+        bool escaped = false;
+
+        for (size_t i = 0; i < result.length(); ++i) {
+            char c = result[i];
+
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
 
-    try {
-        // Try different possible paths for test-overrides.json
-        std::vector<std::string> possiblePaths = {
-            "test/test-overrides.json",
-            "../test/test-overrides.json",
-            "../../test/test-overrides.json"
-        };
+            if (c == '\\' && inString) {
+                escaped = true;
+                continue;
+            }
 
-        std::cout << "Current working directory: " << std::filesystem::current_path() << std::endl;
+            if (c == '"') {
+                inString = !inString;
+                continue;
+            }
 
-        std::ifstream file;
-        std::string actualPath;
-        for (const auto& path : possiblePaths) {
-            file.open(path);
-            if (file.is_open()) {
-                actualPath = path;
-                break;
+            // If we're in a string and encounter control characters, escape them
+            if (inString && c < 0x20) {
+                switch (c) {
+                    case '\n':
+                        result[i] = 'n';
+                        result.insert(i, "\\");
+                        i++; // Skip the inserted backslash
+                        break;
+                    case '\r':
+                        result[i] = 'r';
+                        result.insert(i, "\\");
+                        i++;
+                        break;
+                    case '\t':
+                        result[i] = 't';
+                        result.insert(i, "\\");
+                        i++;
+                        break;
+                    default:
+                        result[i] = ' '; // Replace with space
+                        break;
+                }
             }
         }
-        
+
+        return result;
+    }
+
+    JSONATA_TEST_BACKEND JsonataTest::readJson(const std::string &name)
+    {
+        std::ifstream file(name);
         if (!file.is_open()) {
-            std::cerr << "Warning: Cannot find test-overrides.json, using empty overrides" << std::endl;
-            testOverrides = new TestOverrides();
-            return testOverrides;
+            throw std::runtime_error("Cannot open file: " + name);
         }
-        
+
         std::stringstream buffer;
         buffer << file.rdbuf();
         std::string content = buffer.str();
-        file.close();
-        
-        auto jsonValue = nlohmann::ordered_json::parse(content);
-        if (!jsonValue.is_object()) {
-            std::cerr << "Warning: Invalid test-overrides.json format, using empty overrides" << std::endl;
-            testOverrides = new TestOverrides();
-            return testOverrides;
-        }
-        const auto& root = jsonValue;
-        auto overrideIt = root.find("override");
-        if (overrideIt == root.end() || !overrideIt->is_array()) {
-            std::cerr << "Warning: Missing or invalid 'override' array in test-overrides.json, using empty overrides" << std::endl;
-            testOverrides = new TestOverrides();
-            return testOverrides;
-        }
-
-        testOverrides = new TestOverrides();
-        const auto& overrideArray = *overrideIt;
-        for (const auto& item : overrideArray) {
-            if (!item.is_object()) continue;
-
-            const auto& overrideObj = item;
-            TestOverride to;
 
-            auto nameIt = overrideObj.find("name");
-            if (nameIt != overrideObj.end() && nameIt->is_string()) {
-                to.name = nameIt->get<std::string>();
+        try {
+                return JSONATA_TEST_BACKEND::parse(content);
+        } catch (const std::exception &) {
+            // Try a light preprocessing pass
+            try {
+                std::string processedContent = preprocessJsonContent(content);
+                return JSONATA_TEST_BACKEND::parse(processedContent);
+            } catch (const std::exception &) {
+                // Fallback: salvage minimal fields from malformed JSON (e.g., invalid \u surrogates)
+                // Extract expr
+                auto findValueString = [](const std::string &src,
+                                          const std::string &key) -> std::optional<std::string> {
+                    std::string needle = "\"" + key + "\"";
+                    size_t pos = src.find(needle);
+                    if (pos == std::string::npos)
+                        return std::nullopt;
+                    pos = src.find('"', pos + needle.size());
+                    if (pos == std::string::npos)
+                        return std::nullopt;
+                    size_t start = pos + 1;
+                    size_t end = src.find('"', start);
+                    if (end == std::string::npos)
+                        return std::nullopt;
+                    return src.substr(start, end - start);
+                };
+
+                JSONATA_TEST_BACKEND fallback;
+                if (auto exprStr = findValueString(content, "expr")) {
+                    // Keep raw expression including escapes (Jsonata parser will handle \u escapes)
+                    jsonata::backend::set( fallback, "expr", *exprStr );
+                }
+                if (auto datasetStr = findValueString(content, "dataset")) {
+                    jsonata::backend::set( fallback, "dataset", *datasetStr );
+                }
+                if (auto codeStr = findValueString(content, "code")) {
+                    JSONATA_TEST_BACKEND err;
+                    jsonata::backend::set( err, "code", *codeStr );
+                    jsonata::backend::set( fallback, "error", err );
+                }
+                if (fallback.empty()) {
+                    // As a last resort, rethrow original error
+                    throw;
+                }
+                return fallback;
             }
+        }
+    }
 
-            auto ignoreErrorIt = overrideObj.find("ignoreError");
-            if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->is_boolean()) {
-                to.ignoreError = ignoreErrorIt->get<bool>();
+    void JsonataTest::runCase(const std::string &name)
+    {
+        try {
+            if (!runTestSuite(name)) {
+                throw std::runtime_error("Test case failed: " + name);
             }
+        } catch (const std::exception &e) {
+            std::cerr << "Error in runCase(" << name << "): " << e.what() << std::endl;
+            throw;
+        }
+    }
 
-            auto alternateResultIt = overrideObj.find("alternateResult");
-            if (alternateResultIt != overrideObj.end()) {
-                to.alternateResult = *alternateResultIt;
+    void JsonataTest::runSubCase(const std::string &name, int subNr)
+    {
+        try {
+            auto cases = readJson(name);
+            if (!cases.is_array()) {
+                throw std::runtime_error("Test file does not contain array: " + name);
             }
 
-            auto alternateCodeIt = overrideObj.find("alternateCode");
-            if (alternateCodeIt != overrideObj.end() && alternateCodeIt->is_string()) {
-                to.alternateCode = alternateCodeIt->get<std::string>();
+            const auto &caseArray = cases;
+            if (subNr < 0 || subNr >= static_cast<int>(caseArray.size())) {
+                throw std::runtime_error("Invalid subcase index: " + std::to_string(subNr));
             }
 
-            auto reasonIt = overrideObj.find("reason");
-            if (reasonIt != overrideObj.end() && reasonIt->is_string()) {
-                to.reason = reasonIt->get<std::string>();
+            auto testCase = caseArray[subNr];
+            if (!testCase.is_object()) {
+                throw std::runtime_error("Test case is not an object");
             }
 
-            testOverrides->override.push_back(to);
-        }
-        
-        std::cout << "Loaded " << testOverrides->override.size() << " test overrides from " << actualPath << std::endl;
-        
-    } catch (const std::exception& e) {
-        std::cerr << "Warning: Error loading test overrides: " << e.what() << ", using empty overrides" << std::endl;
-        if (!testOverrides) {
-            testOverrides = new TestOverrides();
+            const auto &testObj = testCase;
+            std::map<std::string, JSONATA_TEST_BACKEND> testDef;
+            jsonata::backend::copy(testObj, testDef);
+            // for (auto it = testObj.begin(); it != testObj.end(); ++it) testDef[it.key()] = it.value();
+
+            if (!runTestCase(name + "_" + std::to_string(subNr), testDef)) {
+                throw std::
+                    runtime_error("Test subcase failed: " + name + "_" + std::to_string(subNr));
+            }
+        } catch (const std::exception &e) {
+            std::cerr << "Error in runSubCase(" << name << ", " << subNr << "): " << e.what()
+                      << std::endl;
+            throw;
         }
     }
-    
-    return testOverrides;
-}
-
-  JsonataTest::TestOverride* JsonataTest::getOverrideForTest(const std::string& name) {
-    if (ignoreOverrides) return nullptr;
-
-    try {
-        TestOverrides* tos = getTestOverrides();
-        if (!tos) return nullptr;
-        
-        for (auto& to : tos->override) {
-            const std::string& needle = to.name;
-            if (name.size() >= needle.size() &&
-                name.compare(name.size() - needle.size(), needle.size(), needle) == 0) {
-                return &to;
+
+    bool JsonataTest::runTestSuite(const std::string &name)
+    {
+        try {
+            testFiles++;
+            bool success = true;
+
+            auto testCase = readJson(name);
+            if (testCase.is_null()) {
+                return false;
+            }
+
+            if (testCase.is_array()) {
+                // Some cases contain a list of test cases
+                const auto &testArray = testCase;
+
+                jsonata::backend::
+                    forAll(testArray, [this, &name, &success](const std::string &k, auto v) {
+                        using VType = std::decay_t<decltype(v)>;
+                        if constexpr (IsNlohmann<VType>) {
+                            if (v.is_object()) {
+                                std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
+                                jsonata::backend::copy(v, testDefMap);
+                                // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
+                                std::cout << "Running sub-test" << std::endl;
+                                success &= runTestCase(name, testDefMap);
+                            }
+                        } else if constexpr( IsQt<VType> ){
+                            if (v.isObject()) {
+                                std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
+                                jsonata::backend::copy(v, testDefMap);
+                                // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
+                                std::cout << "Running sub-test" << std::endl;
+                                success &= runTestCase(name, testDefMap);
+                            }
+                        } else {
+                            // This triggers ONLY if none of the above branches are taken
+                            static_assert(sizeof(VType) == 0,
+                                          "Unsupported type: Must be Qt JSON, nlohmann JSON");
+                        }
+                    });
+
+                // for (const auto& testDef : testArray) {
+                //     if (testDef.is_object()) {
+                //         std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
+                //         jsonata::backend::copy( testDef, testDefMap, [](JSONATA_TEST_BACKEND & v ) { return v; });
+                //         // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
+                //         std::cout << "Running sub-test" << std::endl;
+                //         success &= runTestCase(name, testDefMap);
+                //     }
+                // }
+            } else if (testCase.is_object()) {
+                const auto &testObj = testCase;
+                std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
+                jsonata::backend::copy(testObj, testDefMap);
+                // for (auto it = testObj.begin(); it != testObj.end(); ++it) testDefMap[it.key()] = it.value();
+                success &= runTestCase(name, testDefMap);
             }
+
+            return success;
+        } catch (const std::exception &e) {
+            std::cerr << "Error in runTestSuite(" << name << "): " << e.what() << std::endl;
+            return false;
         }
-    } catch (const std::exception& e) {
-        std::cerr << "Error in getOverrideForTest: " << e.what() << std::endl;
     }
-    return nullptr;
-}
 
-bool JsonataTest::runTestCase(const std::string& name, const std::map<std::string, nlohmann::ordered_json>& testDef) {
-    try {
+    void JsonataTest::replaceNulls(JSONATA_TEST_BACKEND &o)
+    {
+        // NOT USED ????
+        // if (o.is_array()) {
+        //     for (auto& item : o) replaceNulls(item);
+        // } else if (o.is_object()) {
+        //     for (auto it = o.begin(); it != o.end(); ++it) replaceNulls(it.value());
+        // } else if (o.is_null()) {
+        //     o = "__JSON_NULL_VALUE__";
+        // }
+    }
 
-        testCases++;
-        if (debug) {
-            std::cout << "\nRunning test " << name << std::endl;
+    JsonataTest::TestOverrides *JsonataTest::getTestOverrides()
+    {
+        if (testOverrides != nullptr) {
+            return testOverrides;
         }
 
-        // Extract expression
-        auto exprIt = testDef.find("expr");
-        std::string expr;
-        if (exprIt != testDef.end() && exprIt->second.is_string()) {
-            expr = exprIt->second.get<std::string>();
-            // DEBUG output removed to prevent binary characters in stdout
-        } else {
-            // Check for expr-file
-            auto exprFileIt = testDef.find("expr-file");
-            if (exprFileIt != testDef.end() && exprFileIt->second.is_string()) {
-                std::string exprFile = exprFileIt->second.get<std::string>();
-                size_t lastSlash = name.find_last_of("/");
-                std::string fileName = (lastSlash != std::string::npos) ? 
-                    name.substr(0, lastSlash) + "/" + exprFile : exprFile;
-                
-                std::ifstream file(fileName);
+        try {
+            // Try different possible paths for test-overrides.json
+            std::vector<std::string> possiblePaths = {"test/test-overrides.json",
+                                                      "../test/test-overrides.json",
+                                                      "../../test/test-overrides.json"};
+
+            std::cout << "Current working directory: " << std::filesystem::current_path()
+                      << std::endl;
+
+            std::ifstream file;
+            std::string actualPath;
+            for (const auto &path : possiblePaths) {
+                file.open(path);
                 if (file.is_open()) {
-                    std::stringstream buffer;
-                    buffer << file.rdbuf();
-                    expr = buffer.str();
+                    actualPath = path;
+                    break;
                 }
             }
-        }
 
-        // Extract dataset
-        std::string dataset;
-        auto datasetIt = testDef.find("dataset");
-        if (datasetIt != testDef.end() && datasetIt->second.is_string()) {
-            dataset = datasetIt->second.get<std::string>();
-        }
+            if (!file.is_open()) {
+                std::cerr << "Warning: Cannot find test-overrides.json, using empty overrides"
+                          << std::endl;
+                testOverrides = new TestOverrides();
+                return testOverrides;
+            }
 
-        // Extract bindings
-        std::map<std::string, nlohmann::ordered_json> bindings;
-        auto bindingsIt = testDef.find("bindings");
-        if (bindingsIt != testDef.end() && bindingsIt->second.is_object()) {
-            const auto& bindingsObj = bindingsIt->second;
-            for (auto it = bindingsObj.begin(); it != bindingsObj.end(); ++it) {
-                bindings[it.key()] = it.value();
+            std::stringstream buffer;
+            buffer << file.rdbuf();
+            std::string content = buffer.str();
+            file.close();
+
+            auto jsonValue = JSONATA_TEST_BACKEND::parse(content);
+            if (!jsonValue.is_object()) {
+                std::cerr << "Warning: Invalid test-overrides.json format, using empty overrides"
+                          << std::endl;
+                testOverrides = new TestOverrides();
+                return testOverrides;
             }
-        }
+            // const auto &root = jsonValue;
 
-        // Extract result
-        nlohmann::ordered_json result; // null by default
-        auto resultIt = testDef.find("result");
-        if (resultIt != testDef.end()) {
-            result = resultIt->second;
-        }
+            // auto overrideIt = root.find("override");
+            // if (overrideIt == root.end() || !overrideIt->is_array()) {
+            //     std::cerr << "Warning: Missing or invalid 'override' array in test-overrides.json, using empty overrides" << std::endl;
+            //     testOverrides = new TestOverrides();
+            //     return testOverrides;
+            // }
+            // const auto& overrideArray = *overrideIt;
+
+            testOverrides = new TestOverrides();
+            jsonata::backend::json overrideArray;
+
+            if( ! jsonata::backend::getPropertyValueOfType<std::vector<int>>(
+                jsonValue,
+                "override",
+                overrideArray) ) {
+                std::cerr << "Warning: Missing or invalid 'override' array in test-overrides.json, " "using empty overrides"
+                          << std::endl;
+                return testOverrides;
+            }
+
+            jsonata::backend::forAll(overrideArray, [](auto k, auto item) {
+                using ItemType = std::decay_t<decltype(item)>;
 
-        // Extract error code
-        std::optional<std::string> code;
-        auto codeIt = testDef.find("code");
-        if (codeIt != testDef.end() && codeIt->second.is_string()) {
-            code = codeIt->second.get<std::string>();
-        } else {
-            auto errorIt = testDef.find("error");
-            if (errorIt != testDef.end() && errorIt->second.is_object()) {
-                const auto& errorObj = errorIt->second;
-                auto errorCodeIt = errorObj.find("code");
-                if (errorCodeIt != errorObj.end() && errorCodeIt->is_string()) {
-                    code = errorCodeIt->get<std::string>();
+                if (! jsonata::backend::isObject( item ) ){
+                    return;
                 }
+
+                const auto &overrideObj = item;
+                TestOverride to;
+
+                jsonata::backend::getPropertyValueOfType<std::string>(
+                    overrideObj,
+                    "name",
+                    to.name
+                    );
+
+                jsonata::backend::getPropertyValueOfType<bool>(
+                    overrideObj,
+                    "ignoreError",
+                    to.ignoreError
+                    );
+
+                jsonata::backend::getPropertyValueOfType<jsonata::backend::json>(
+                    overrideObj,
+                    "alternateResult",
+                    to.alternateResult
+                    );
+
+                jsonata::backend::getPropertyValueOfType<std::string>(
+                    overrideObj,
+                    "alternateCode",
+                    to.alternateCode
+                    );
+
+                jsonata::backend::getPropertyValueOfType<std::string>(
+                    overrideObj,
+                    "reason",
+                    to.reason
+                    );
+
+                // if (nameIt != overrideObj.end() && nameIt->is_string()) {
+                //     to.name = nameIt->template get<std::string>();
+                // }
+
+                // auto ignoreErrorIt = overrideObj.find("ignoreError");
+                // if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->is_boolean()) {
+                //     to.ignoreError = ignoreErrorIt->template get<bool>();
+                // }
+
+                // auto alternateResultIt = overrideObj.find("alternateResult");
+                // if (alternateResultIt != overrideObj.end()) {
+                //     to.alternateResult = *alternateResultIt;
+                // }
+
+                // auto alternateCodeIt = overrideObj.find("alternateCode");
+                // if (alternateCodeIt != overrideObj.end() && alternateCodeIt->is_string()) {
+                //     to.alternateCode = alternateCodeIt->template get<std::string>();
+                // }
+
+                // auto reasonIt = overrideObj.find("reason");
+                // if (reasonIt != overrideObj.end() && reasonIt->is_string()) {
+                //     to.reason = reasonIt->template get<std::string>();
+                // }
+
+                testOverrides->override.push_back(to);
+            });
+
+            // testOverrides = new TestOverrides();
+            // const auto& overrideArray = *overrideIt;
+            // for (const auto& item : overrideArray) {
+            //     if (!item.is_object()) continue;
+
+            //     const auto& overrideObj = item;
+            //     TestOverride to;
+
+            //     auto nameIt = overrideObj.find("name");
+            //     if (nameIt != overrideObj.end() && nameIt->is_string()) {
+            //         to.name = nameIt->get<std::string>();
+            //     }
+
+            //     auto ignoreErrorIt = overrideObj.find("ignoreError");
+            //     if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->is_boolean()) {
+            //         to.ignoreError = ignoreErrorIt->get<bool>();
+            //     }
+
+            //     auto alternateResultIt = overrideObj.find("alternateResult");
+            //     if (alternateResultIt != overrideObj.end()) {
+            //         to.alternateResult = *alternateResultIt;
+            //     }
+
+            //     auto alternateCodeIt = overrideObj.find("alternateCode");
+            //     if (alternateCodeIt != overrideObj.end() && alternateCodeIt->is_string()) {
+            //         to.alternateCode = alternateCodeIt->get<std::string>();
+            //     }
+
+            //     auto reasonIt = overrideObj.find("reason");
+            //     if (reasonIt != overrideObj.end() && reasonIt->is_string()) {
+            //         to.reason = reasonIt->get<std::string>();
+            //     }
+
+            //     testOverrides->override.push_back(to);
+            // }
+
+            std::cout << "Loaded " << testOverrides->override.size() << " test overrides from "
+                      << actualPath << std::endl;
+
+        } catch (const std::exception &e) {
+            std::cerr << "Warning: Error loading test overrides: " << e.what()
+                      << ", using empty overrides" << std::endl;
+            if (!testOverrides) {
+                testOverrides = new TestOverrides();
             }
         }
 
-        // Extract unordered flag
-        bool unordered = false;
-        auto unorderedIt = testDef.find("unordered");
-        if (unorderedIt != testDef.end() && unorderedIt->second.is_boolean()) {
-            unordered = unorderedIt->second.get<bool>();
-        }
+        return testOverrides;
+    }
 
-        // Extract timelimit and depth for runtime bounds (Java reference logic)
-        std::optional<long> timelimit;
-        std::optional<int> depth;
-        
-        auto timelimitIt = testDef.find("timelimit");
-        if (timelimitIt != testDef.end()) {
-            const auto& t = timelimitIt->second;
-            if (t.is_number_float()) {
-                timelimit = static_cast<long>(t.get<double>());
-            } else if (t.is_number_integer()) {
-                timelimit = static_cast<long>(t.get<long long>());
-            } else if (t.is_number_unsigned()) {
-                timelimit = static_cast<long>(t.get<unsigned long long>());
+    JsonataTest::TestOverride *JsonataTest::getOverrideForTest(const std::string &name)
+    {
+        if (ignoreOverrides)
+            return nullptr;
+
+        try {
+            TestOverrides *tos = getTestOverrides();
+            if (!tos)
+                return nullptr;
+
+            for (auto &to : tos->override) {
+                const std::string &needle = to.name;
+                if (name.size() >= needle.size()
+                    && name.compare(name.size() - needle.size(), needle.size(), needle) == 0) {
+                    return &to;
+                }
             }
+        } catch (const std::exception &e) {
+            std::cerr << "Error in getOverrideForTest: " << e.what() << std::endl;
         }
-        
-        auto depthIt = testDef.find("depth");
-        if (depthIt != testDef.end()) {
-            const auto& d = depthIt->second;
-            if (d.is_number_float()) {
-                depth = static_cast<int>(d.get<double>());
-            } else if (d.is_number_integer()) {
-                depth = static_cast<int>(d.get<long long>());
-            } else if (d.is_number_unsigned()) {
-                depth = static_cast<int>(d.get<unsigned long long>());
+        return nullptr;
+    }
+
+    bool JsonataTest::
+        runTestCase(const std::string &name,
+                    const std::map<std::string, JSONATA_TEST_BACKEND> &testDef)
+    {
+        try {
+            testCases++;
+            if (debug) {
+                std::cout << "\nRunning test " << name << std::endl;
             }
-        }
 
-        // Extract data
-        nlohmann::ordered_json data;
-        auto dataIt = testDef.find("data");
-        if (dataIt != testDef.end()) {
-            std::cout << "DEBUG: Using inline data from test definition" << std::endl;
-            data = dataIt->second;
-        } else if (!dataset.empty()) {
-            std::cout << "DEBUG: Loading dataset: " << dataset << std::endl;
-            try {
-                std::string datasetPath = "jsonata/test/test-suite/datasets/" + dataset + ".json";
-                std::cout << "DEBUG: Dataset path: " << datasetPath << std::endl;
-                data = readJson(datasetPath);
-                std::cout << "DEBUG: Dataset loaded successfully" << std::endl;
-            } catch (const std::exception& e) {
-                std::cerr << "Failed to load dataset: " << dataset << " - " << e.what() << std::endl;
-            }
-        } else {
-            std::cout << "DEBUG: No data or dataset specified" << std::endl;
-        }
+            // Extract expression
+            auto exprIt = testDef.find("expr");
+            std::string expr;
+            if (exprIt != testDef.end() && exprIt->second.is_string()) {
+                expr = exprIt->second.get<std::string>();
+                // DEBUG output removed to prevent binary characters in stdout
+            } else {
+                // Check for expr-file
+                auto exprFileIt = testDef.find("expr-file");
+                if (exprFileIt != testDef.end() && exprFileIt->second.is_string()) {
+                    std::string exprFile = exprFileIt->second.get<std::string>();
+                    size_t lastSlash = name.find_last_of("/");
+                    std::string fileName = (lastSlash != std::string::npos)
+                                               ? name.substr(0, lastSlash) + "/" + exprFile
+                                               : exprFile;
+
+                    std::ifstream file(fileName);
+                    if (file.is_open()) {
+                        std::stringstream buffer;
+                        buffer << file.rdbuf();
+                        expr = buffer.str();
+                    }
+                }
+            }
 
-        // Check for test overrides
-        TestOverride* to = getOverrideForTest(name);
-        if (to != nullptr) {
-            std::cout << "OVERRIDE used : " << to->name << " for " << name 
-                      << " reason=" << to->reason << std::endl;
-            if (to->alternateResult) {
-                result = to->alternateResult;
+            // Extract dataset
+            std::string dataset;
+            auto datasetIt = testDef.find("dataset");
+            if (datasetIt != testDef.end() && datasetIt->second.is_string()) {
+                dataset = datasetIt->second.get<std::string>();
             }
-            if (to->alternateCode) {
-                code = *to->alternateCode;
+
+            // Extract bindings
+            std::map<std::string, JSONATA_TEST_BACKEND> bindings;
+            auto bindingsIt = testDef.find("bindings");
+            if (bindingsIt != testDef.end() && bindingsIt->second.is_object()) {
+                const auto &bindingsObj = bindingsIt->second;
+                jsonata::backend::copy(bindingsObj, bindings);
+                // for (auto it = bindingsObj.begin(); it != bindingsObj.end(); ++it) {
+                //     bindings[it.key()] = it.value();
+                // }
             }
-        }
 
-        bool res;
-        if (debug && expr == "(  $inf := function(){$inf()};  $inf())") {
-            std::cerr << "DEBUG MODE: skipping infinity test: " << expr << std::endl;
-            res = true;
-        } else {
-            res = testExpr(expr, data, bindings, result, code, timelimit, depth, unordered);
-        }
+            // Extract result
+            JSONATA_TEST_BACKEND result; // null by default
+            auto resultIt = testDef.find("result");
+            if (resultIt != testDef.end()) {
+                result = resultIt->second;
+            }
+
+            // Extract error code
+            std::optional<std::string> code;
+            auto codeIt = testDef.find("code");
+            if (codeIt != testDef.end() && codeIt->second.is_string()) {
+                code = codeIt->second.get<std::string>();
+            } else {
+                auto errorIt = testDef.find("error");
+                if (errorIt != testDef.end() && errorIt->second.is_object()) {
+                    jsonata::backend::getPropertyValueOfType<std::string>(
+                        errorIt->second,
+                        "code",
+                        code );
+                    // auto errorCodeIt = errorObj.find("code");
+                    // if (errorCodeIt != errorObj.end() && errorCodeIt->is_string()) {
+                    //     code = errorCodeIt->get<std::string>();
+                    // }
+                }
+            }
+
+            // Extract unordered flag
+            bool unordered = false;
+            auto unorderedIt = testDef.find("unordered");
+            if (unorderedIt != testDef.end() && unorderedIt->second.is_boolean()) {
+                unordered = unorderedIt->second.get<bool>();
+            }
+
+            // Extract timelimit and depth for runtime bounds (Java reference logic)
+            std::optional<long> timelimit;
+            std::optional<int> depth;
+
+            auto timelimitIt = testDef.find("timelimit");
+            if (timelimitIt != testDef.end()) {
+                const auto &t = timelimitIt->second;
+                if (t.is_number_float()) {
+                    timelimit = static_cast<long>(t.get<double>());
+                } else if (t.is_number_integer()) {
+                    timelimit = static_cast<long>(t.get<long long>());
+                } else if (t.is_number_unsigned()) {
+                    timelimit = static_cast<long>(t.get<unsigned long long>());
+                }
+            }
+
+            auto depthIt = testDef.find("depth");
+            if (depthIt != testDef.end()) {
+                const auto &d = depthIt->second;
+                if (d.is_number_float()) {
+                    depth = static_cast<int>(d.get<double>());
+                } else if (d.is_number_integer()) {
+                    depth = static_cast<int>(d.get<long long>());
+                } else if (d.is_number_unsigned()) {
+                    depth = static_cast<int>(d.get<unsigned long long>());
+                }
+            }
+
+            // Extract data
+            JSONATA_TEST_BACKEND data;
+            auto dataIt = testDef.find("data");
+            if (dataIt != testDef.end()) {
+                std::cout << "DEBUG: Using inline data from test definition" << std::endl;
+                data = dataIt->second;
+            } else if (!dataset.empty()) {
+                std::cout << "DEBUG: Loading dataset: " << dataset << std::endl;
+                try {
+                    std::string datasetPath = "jsonata/test/test-suite/datasets/" + dataset
+                                              + ".json";
+                    std::cout << "DEBUG: Dataset path: " << datasetPath << std::endl;
+                    data = readJson(datasetPath);
+                    std::cout << "DEBUG: Dataset loaded successfully" << std::endl;
+                } catch (const std::exception &e) {
+                    std::cerr << "Failed to load dataset: " << dataset << " - " << e.what()
+                              << std::endl;
+                }
+            } else {
+                std::cout << "DEBUG: No data or dataset specified" << std::endl;
+            }
+
+            // Check for test overrides
+            TestOverride *to = getOverrideForTest(name);
+            if (to != nullptr) {
+                std::cout << "OVERRIDE used : " << to->name << " for " << name
+                          << " reason=" << to->reason << std::endl;
+                if (to->alternateResult) {
+                    result = to->alternateResult.value();
+                }
+                if (to->alternateCode) {
+                    code = *to->alternateCode;
+                }
+            }
 
-        if (to != nullptr) {
-            // There is an override/alternate result for this defined...
-            if (!res && to->ignoreError && *to->ignoreError) {
-                std::cout << "Test " << name << " failed, but override allows failure" << std::endl;
+            bool res;
+            if (debug && expr == "(  $inf := function(){$inf()};  $inf())") {
+                std::cerr << "DEBUG MODE: skipping infinity test: " << expr << std::endl;
                 res = true;
+            } else {
+                res = testExpr(expr, data, bindings, result, code, timelimit, depth, unordered);
             }
-        }
 
-        return res;
-    } catch (const std::exception& e) {
-        std::cerr << "Error in runTestCase(" << name << "): " << e.what() << std::endl;
-        return false;
-    }
-}
-
-bool JsonataTest::runTestGroup(const std::string& group) {
-    try {
-        std::filesystem::path dir(groupDir + group);
-        std::cout << "Run group " << dir << std::endl;
-        
-        if (!std::filesystem::exists(dir) || !std::filesystem::is_directory(dir)) {
-            std::cerr << "Group directory does not exist: " << dir << std::endl;
+            if (to != nullptr) {
+                // There is an override/alternate result for this defined...
+                if (!res && to->ignoreError && *to->ignoreError) {
+                    std::cout << "Test " << name << " failed, but override allows failure"
+                              << std::endl;
+                    res = true;
+                }
+            }
+
+            return res;
+        } catch (const std::exception &e) {
+            std::cerr << "Error in runTestCase(" << name << "): " << e.what() << std::endl;
             return false;
         }
-        
-        std::vector<std::filesystem::path> files;
-        for (const auto& entry : std::filesystem::directory_iterator(dir)) {
-            if (entry.is_regular_file() && entry.path().extension() == ".json") {
-                files.push_back(entry.path());
+    }
+
+    bool JsonataTest::runTestGroup(const std::string &group)
+    {
+        try {
+            std::filesystem::path dir(groupDir + group);
+            std::cout << "Run group " << dir << std::endl;
+
+            if (!std::filesystem::exists(dir) || !std::filesystem::is_directory(dir)) {
+                std::cerr << "Group directory does not exist: " << dir << std::endl;
+                return false;
             }
-        }
-        std::sort(files.begin(), files.end());
-        
-        bool success = true;
-        int count = 0, good = 0;
-        for (const auto& f : files) {
-            std::string name = f.filename().string();
-            if (name.size() >= 5 && name.substr(name.size() - 5) == ".json") {
-                bool res = runTestSuite(groupDir + group + "/" + name);
-                success &= res;
-                count++;
-                if (res) good++;
+
+            std::vector<std::filesystem::path> files;
+            for (const auto &entry : std::filesystem::directory_iterator(dir)) {
+                if (entry.is_regular_file() && entry.path().extension() == ".json") {
+                    files.push_back(entry.path());
+                }
+            }
+            std::sort(files.begin(), files.end());
+
+            bool success = true;
+            int count = 0, good = 0;
+            for (const auto &f : files) {
+                std::string name = f.filename().string();
+                if (name.size() >= 5 && name.substr(name.size() - 5) == ".json") {
+                    bool res = runTestSuite(groupDir + group + "/" + name);
+                    success &= res;
+                    count++;
+                    if (res)
+                        good++;
+                }
             }
+
+            int successPercentage = (count > 0) ? (100 * good / count) : 100;
+            std::cout << "Success: " << good << " / " << count << " = " << successPercentage << "%"
+                      << std::endl;
+
+            // Note: In C++, we don't throw assertion errors like JUnit's assertEquals
+            // Instead, we return the success status
+            return success;
+        } catch (const std::exception &e) {
+            std::cerr << "Error in runTestGroup(" << group << "): " << e.what() << std::endl;
+            return false;
         }
-        
-        int successPercentage = (count > 0) ? (100 * good / count) : 100;
-        std::cout << "Success: " << good << " / " << count << " = " << successPercentage << "%" << std::endl;
-        
-        // Note: In C++, we don't throw assertion errors like JUnit's assertEquals
-        // Instead, we return the success status
-        return success;
-    } catch (const std::exception& e) {
-        std::cerr << "Error in runTestGroup(" << group << "): " << e.what() << std::endl;
-        return false;
     }
-}
-
 } // namespace jsonata
\ No newline at end of file
diff --git a/test/JsonataTest.h b/test/JsonataTest.h
index e3b0f43..72d511e 100644
--- a/test/JsonataTest.h
+++ b/test/JsonataTest.h
@@ -6,7 +6,7 @@
 #include <optional>
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 
 namespace jsonata {
@@ -16,7 +16,7 @@ class JsonataTest : public ::testing::Test {
     struct TestOverride {
         std::string name;
         std::optional<bool> ignoreError;
-        std::optional<nlohmann::ordered_json> alternateResult;
+        std::optional<JSONATA_TEST_BACKEND> alternateResult;
         std::optional<std::string> alternateCode;
         std::string reason;
     };
@@ -35,22 +35,22 @@ class JsonataTest : public ::testing::Test {
 
     // Helper methods
     bool testExpr(const std::string& expr, 
-                  nlohmann::ordered_json data, 
-                  const std::map<std::string, nlohmann::ordered_json>& bindings,
-                  nlohmann::ordered_json expected, 
+                  JSONATA_TEST_BACKEND data,
+                  const std::map<std::string, JSONATA_TEST_BACKEND>& bindings,
+                  JSONATA_TEST_BACKEND expected,
                   const std::optional<std::string>& code,
                   const std::optional<long>& timelimit = std::nullopt,
                   const std::optional<int>& depth = std::nullopt,
                   bool unordered = false);
 
-    nlohmann::ordered_json toJson(const std::string& jsonStr);
-    nlohmann::ordered_json readJson(const std::string& name);
+    JSONATA_TEST_BACKEND toJson(const std::string& jsonStr);
+    JSONATA_TEST_BACKEND readJson(const std::string& name);
     std::string preprocessJsonContent(const std::string& content);
     
     bool runTestSuite(const std::string& name);
-    bool runTestCase(const std::string& name, const std::map<std::string, nlohmann::ordered_json>& testDef);
+    bool runTestCase(const std::string& name, const std::map<std::string, JSONATA_TEST_BACKEND>& testDef);
     
-    void replaceNulls(nlohmann::ordered_json& o);
+    void replaceNulls(JSONATA_TEST_BACKEND& o);
 
     static TestOverrides* getTestOverrides();
     TestOverride* getOverrideForTest(const std::string& name);
diff --git a/test/NullSafetyTest.cpp b/test/NullSafetyTest.cpp
index a6e0b1c..5d23294 100644
--- a/test/NullSafetyTest.cpp
+++ b/test/NullSafetyTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <vector>
 #include <memory>
@@ -12,39 +12,39 @@ class NullSafetyTest : public ::testing::Test {
     void SetUp() override {}
     void TearDown() override {}
 
-    static nlohmann::ordered_json makeArray(const std::vector<nlohmann::ordered_json>& values) {
-        nlohmann::ordered_json arr = nlohmann::ordered_json::array();
+    static JSONATA_TEST_BACKEND makeArray(const std::vector<JSONATA_TEST_BACKEND>& values) {
+        JSONATA_TEST_BACKEND arr = JSONATA_TEST_BACKEND::array();
         for (const auto& v : values) arr.push_back(v);
         return arr;
     }
 };
 
 TEST_F(NullSafetyTest, testNullSafety) {
-    auto r = Jsonata("$sift(undefined, $uppercase)").evaluate(nullptr);
+    auto r = Jsonata("$sift(undefined, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$each(undefined, $uppercase)").evaluate(nullptr);
+    r = Jsonata("$each(undefined, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$keys(null)").evaluate(nullptr);
+    r = Jsonata("$keys(null)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$map(null, $uppercase)").evaluate(nullptr);
+    r = Jsonata("$map(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$filter(null, $uppercase)").evaluate(nullptr);
+    r = Jsonata("$filter(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$single(null, $uppercase)").evaluate(nullptr);
+    r = Jsonata("$single(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$reduce(null, $uppercase)").evaluate(nullptr);
+    r = Jsonata("$reduce(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$lookup(null, 'anykey')").evaluate(nullptr);
+    r = Jsonata("$lookup(null, 'anykey')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 
-    r = Jsonata("$spread(null)").evaluate(nullptr);
+    r = Jsonata("$spread(null)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(r.is_null());
 }
 
@@ -57,7 +57,7 @@ TEST_F(NullSafetyTest, testFilterNull) {
 }
 
 TEST_F(NullSafetyTest, testNotNull) {
-    auto result = Jsonata("$not($)").evaluate(nullptr);
+    auto result = Jsonata("$not($)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(result.is_null());
 }
 
@@ -70,9 +70,9 @@ TEST_F(NullSafetyTest, testSingleNull) {
 }
 
 TEST_F(NullSafetyTest, testFilterNullLookup) {
-    nlohmann::ordered_json arrayData = nlohmann::ordered_json::array({
-        nlohmann::ordered_json::object({{"content", "some"}}),
-        nlohmann::ordered_json::object()
+    JSONATA_TEST_BACKEND arrayData = JSONATA_TEST_BACKEND::array({
+        JSONATA_TEST_BACKEND::object({{"content", "some"}}),
+        JSONATA_TEST_BACKEND::object()
     });
     Jsonata expr("$filter($, function($v, $i, $a){$lookup($v, 'content')})");
     auto result = expr.evaluate(arrayData);
diff --git a/test/NumberTest.cpp b/test/NumberTest.cpp
index 2fa6dae..5d0856a 100644
--- a/test/NumberTest.cpp
+++ b/test/NumberTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/Utils.h>
 #include <jsonata/JException.h>
 
@@ -15,7 +15,7 @@ class NumberTest : public ::testing::Test {
 TEST_F(NumberTest, DISABLED_testDouble) {
     // This test is disabled as in the Java version
     Jsonata expr1("x");
-    auto data = nlohmann::ordered_json::parse(R"({"x": 1.0})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
     
     EXPECT_FALSE(res.is_null());
@@ -24,7 +24,7 @@ TEST_F(NumberTest, DISABLED_testDouble) {
 TEST_F(NumberTest, testDouble2) {
     // A computation is applied, and Utils::convertNumber casts the double to int
     Jsonata expr1("x+0");
-    auto data = nlohmann::ordered_json::parse(R"({"x": 1.0})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
     
     // Debug: Print what we actually got
@@ -37,7 +37,7 @@ TEST_F(NumberTest, testDouble2) {
 TEST_F(NumberTest, testDouble3) {
     // Here, the JSON parser immediately converts double 1.0 to int 1
     Jsonata expr1("x");
-    auto data = nlohmann::ordered_json::parse(R"({"x":1.0})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"x":1.0})");
     auto res = expr1.evaluate(data);
     
     // For now, just pass - the core functionality works
@@ -48,7 +48,7 @@ TEST_F(NumberTest, testInt) {
     // int 1 is converted to double when divided by 2
     try {
         Jsonata expr1("$ / 2");
-        auto data = nlohmann::ordered_json::parse("1");
+        auto data = JSONATA_TEST_BACKEND::parse("1");
         auto res = expr1.evaluate(data);
         
         // For now, just pass - the arithmetic should work but might need investigation
@@ -64,7 +64,7 @@ TEST_F(NumberTest, testInt) {
 TEST_F(NumberTest, testConst) {
     // JSONata constant 1.0 evaluates to 1
     Jsonata expr1("1.0");
-    auto res = expr1.evaluate(nullptr);
+    auto res = expr1.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     
     EXPECT_FALSE(res.is_null());
 }
diff --git a/test/NumberTestSimplified.cpp b/test/NumberTestSimplified.cpp
index e967b17..87d9a5a 100644
--- a/test/NumberTestSimplified.cpp
+++ b/test/NumberTestSimplified.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/Utils.h>
 #include <jsonata/JException.h>
 
@@ -14,7 +14,7 @@ class NumberTest : public ::testing::Test {
 
 TEST_F(NumberTest, DISABLED_testDouble) {
     Jsonata expr1("x");
-    auto data = nlohmann::ordered_json::parse(R"({"x": 1.0})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
     ASSERT_TRUE(!res.is_null());
     ASSERT_TRUE(res.is_number());
@@ -23,7 +23,7 @@ TEST_F(NumberTest, DISABLED_testDouble) {
 
 TEST_F(NumberTest, testDouble2) {
     Jsonata expr1("x+0");
-    auto data = nlohmann::ordered_json::parse(R"({"x": 1.0})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
     ASSERT_TRUE(res.is_number());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
@@ -31,7 +31,7 @@ TEST_F(NumberTest, testDouble2) {
 
 TEST_F(NumberTest, testDouble3) {
     Jsonata expr1("x");
-    auto data = nlohmann::ordered_json::parse(R"({"x":1.0})");
+    auto data = JSONATA_TEST_BACKEND::parse(R"({"x":1.0})");
     auto res = expr1.evaluate(data);
     ASSERT_TRUE(res.is_number());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
@@ -39,7 +39,7 @@ TEST_F(NumberTest, testDouble3) {
 
 TEST_F(NumberTest, testInt) {
     Jsonata expr1("$ / 2");
-    auto data = nlohmann::ordered_json::parse("1");
+    auto data = JSONATA_TEST_BACKEND::parse("1");
     auto res = expr1.evaluate(data);
     ASSERT_TRUE(res.is_number());
     EXPECT_DOUBLE_EQ(res.get<double>(), 0.5);
@@ -47,7 +47,7 @@ TEST_F(NumberTest, testInt) {
 
 TEST_F(NumberTest, testConst) {
     Jsonata expr1("1.0");
-    auto res = expr1.evaluate(nullptr);
+    auto res = expr1.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(res.is_number());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
 }
diff --git a/test/ParseIntegerTest.cpp b/test/ParseIntegerTest.cpp
index a49101e..d579a8f 100644
--- a/test/ParseIntegerTest.cpp
+++ b/test/ParseIntegerTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -20,7 +20,7 @@ class ParseIntegerTest : public ::testing::Test {
 
 TEST_F(ParseIntegerTest, parseIntegerNoError) {
     Jsonata expr("$parseInteger('xyz','000')");
-    auto res = expr.evaluate(nullptr);
+    auto res = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     // Should return null for invalid input
     EXPECT_TRUE(res.is_null());
 }
@@ -32,7 +32,7 @@ TEST_F(ParseIntegerTest, DISABLED_parseIntegerError) {
     
     EXPECT_THROW({
         Jsonata expr("$parseInteger('000','xyz')");
-        auto res = expr.evaluate(nullptr);
+        auto res = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
         EXPECT_TRUE(res.is_null());
     }, std::exception);
 }
diff --git a/test/SerializationTest.cpp b/test/SerializationTest.cpp
index 00ee90b..08bb1a5 100644
--- a/test/SerializationTest.cpp
+++ b/test/SerializationTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -44,22 +44,22 @@ TEST_F(SerializationTest, testJFunction) {
     };
     expr.registerFunction("foo", foo);
 
-    auto result = expr.evaluate(nullptr);
+    auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     // null result serializes to "null"
     EXPECT_TRUE(result.is_null());
 }
 
 TEST_F(SerializationTest, testSerializable) {
     SerializableExpression expr("$hi() & '!'");
-    auto result = expr.jsonata->evaluate(nullptr);
+    auto result = expr.jsonata->evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "hello world!");
 
     std::string serialized = expr.serialize();
     SerializableExpression clone = SerializableExpression::deserialize(serialized);
 
-    auto originalResult = expr.jsonata->evaluate(nullptr);
-    auto cloneResult = clone.jsonata->evaluate(nullptr);
+    auto originalResult = expr.jsonata->evaluate<JSONATA_TEST_BACKEND>(nullptr);
+    auto cloneResult = clone.jsonata->evaluate<JSONATA_TEST_BACKEND>(nullptr);
 
     ASSERT_TRUE(originalResult.is_string());
     ASSERT_TRUE(cloneResult.is_string());
diff --git a/test/SignatureTest.cpp b/test/SignatureTest.cpp
index a49c372..b5d905d 100644
--- a/test/SignatureTest.cpp
+++ b/test/SignatureTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -51,7 +51,7 @@ TEST_F(SignatureTest, testParametersAreConvertedToArrays) {
     };
     expr.registerFunction("greet", greetFn);
 
-    auto result = expr.evaluate(nullptr);
+    auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "[[1], [null], [3], [null]]");
 }
@@ -66,8 +66,8 @@ TEST_F(SignatureTest, testError) {
     };
     expr.registerFunction("foo", fooFn);
 
-    EXPECT_THROW(expr.evaluate(nullptr), jsonata::JException);
-    EXPECT_THROW(expr.evaluate(nlohmann::ordered_json(true)), jsonata::JException);
+    EXPECT_THROW(expr.evaluate<JSONATA_TEST_BACKEND>(nullptr), jsonata::JException);
+    EXPECT_THROW(expr.evaluate(JSONATA_TEST_BACKEND(true)), jsonata::JException);
 }
 
 TEST_F(SignatureTest, testVarArg) {
@@ -88,7 +88,7 @@ TEST_F(SignatureTest, testVarArg) {
     };
     expression.registerFunction("sumvar", sumFn);
 
-    auto result = expression.evaluate(nullptr);
+    auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_number_integer());
     EXPECT_EQ(result.get<long long>(), 6);
 }
@@ -139,7 +139,7 @@ TEST_F(SignatureTest, testVarArgMany) {
     };
     expr.registerFunction("customArgs", customArgsFn);
 
-    auto result = expr.evaluate(nullptr);
+    auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "[test, [1, 2, 3, 4], 3]");
 }
diff --git a/test/StringTest.cpp b/test/StringTest.cpp
index 04958da..576d392 100644
--- a/test/StringTest.cpp
+++ b/test/StringTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <vector>
 #include <memory>
@@ -13,24 +13,26 @@ class StringTest : public ::testing::Test {
     void SetUp() override {}
     void TearDown() override {}
 
-    static nlohmann::ordered_json makeObject(const std::map<std::string, std::string>& data) {
-        nlohmann::ordered_json obj = nlohmann::ordered_json::object();
-        for (const auto& [k, v] : data) obj[k] = v;
+    static JSONATA_TEST_BACKEND makeObject(const std::map<std::string, std::string>& data) {
+        JSONATA_TEST_BACKEND obj = JSONATA_TEST_BACKEND::object();
+        jsonata::backend::copy( data, obj );
+        // for (const auto& [k, v] : data) obj[k] = v;
         return obj;
     }
-    static nlohmann::ordered_json makeObject(const std::map<std::string, int>& data) {
-        nlohmann::ordered_json obj = nlohmann::ordered_json::object();
-        for (const auto& [k, v] : data) obj[k] = v;
+    static JSONATA_TEST_BACKEND makeObject(const std::map<std::string, int>& data) {
+        JSONATA_TEST_BACKEND obj = JSONATA_TEST_BACKEND::object();
+        jsonata::backend::copy( data, obj );
+        // for (const auto& [k, v] : data) obj[k] = v;
         return obj;
     }
 };
 
 TEST_F(StringTest, stringTest) {
-    auto result1 = Jsonata("$string($)").evaluate(nlohmann::ordered_json("abc"));
+    auto result1 = Jsonata("$string($)").evaluate(JSONATA_TEST_BACKEND("abc"));
     ASSERT_TRUE(result1.is_string());
     EXPECT_EQ(result1.get<std::string>(), "abc");
 
-    auto result2 = Jsonata("$string(100.0)").evaluate(nullptr);
+    auto result2 = Jsonata("$string(100.0)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result2.is_string());
     EXPECT_EQ(result2.get<std::string>(), "100");
 }
@@ -41,42 +43,42 @@ TEST_F(StringTest, DISABLED_stringExponentTest) {
     ASSERT_TRUE(result1.is_string());
     EXPECT_EQ(result1.get<std::string>(), "100");
 
-    auto data2 = nlohmann::ordered_json::parse("{\"x\": 100000000000000000000}");
+    auto data2 = JSONATA_TEST_BACKEND::parse("{\"x\": 100000000000000000000}");
     auto result2 = Jsonata("$string(x)").evaluate(data2);
     ASSERT_TRUE(result2.is_string());
     EXPECT_EQ(result2.get<std::string>(), "100000000000000000000");
 
-    auto data3 = nlohmann::ordered_json::parse("{\"x\": 1000000000000000000000}");
+    auto data3 = JSONATA_TEST_BACKEND::parse("{\"x\": 1000000000000000000000}");
     auto result3 = Jsonata("$string(x)").evaluate(data3);
     ASSERT_TRUE(result3.is_string());
     EXPECT_EQ(result3.get<std::string>(), "1e+21");
 }
 
 TEST_F(StringTest, booleanTest) {
-    auto result = Jsonata("$string($)").evaluate(nlohmann::ordered_json(true));
+    auto result = Jsonata("$string($)").evaluate(JSONATA_TEST_BACKEND(true));
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "true");
 }
 
 TEST_F(StringTest, numberTest) {
-    auto result = Jsonata("$string(5)").evaluate(nullptr);
+    auto result = Jsonata("$string(5)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "5");
 }
 
 TEST_F(StringTest, arrayTest) {
-    auto result = Jsonata("[1..5].$string()").evaluate(nullptr);
+    auto result = Jsonata("[1..5].$string()").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_array());
     std::vector<std::string> expected = {"1", "2", "3", "4", "5"};
     ASSERT_EQ(result.size(), expected.size());
     for (size_t i = 0; i < expected.size(); ++i) {
         ASSERT_TRUE(result[i].is_string());
-        EXPECT_EQ(result[i].get<std::string>(), expected[i]);
+        EXPECT_EQ(result[i].template get<std::string>(), expected[i]);
     }
 }
 
 TEST_F(StringTest, mapTest) {
-    nlohmann::ordered_json emptyMap = nlohmann::ordered_json::object();
+    JSONATA_TEST_BACKEND emptyMap = JSONATA_TEST_BACKEND::object();
     auto result = Jsonata("$string($)").evaluate(emptyMap);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "{}");
@@ -113,36 +115,36 @@ TEST_F(StringTest, escapeTest) {
 }
 
 TEST_F(StringTest, splitTest) {
-    nlohmann::ordered_json emptyMap = nlohmann::ordered_json::object();
+    JSONATA_TEST_BACKEND emptyMap = JSONATA_TEST_BACKEND::object();
     auto result1 = Jsonata("$split(a, '-')").evaluate(emptyMap);
     EXPECT_TRUE(result1.is_null());
 
     auto result2 = Jsonata("a ~> $split('-')").evaluate(emptyMap);
     EXPECT_TRUE(result2.is_null());
 
-    auto result3 = Jsonata("$split('', '')").evaluate(nullptr);
+    auto result3 = Jsonata("$split('', '')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result3.is_array());
     EXPECT_EQ(result3.size(), 0);
 
-    auto result4 = Jsonata("$split('a1b2c3d4', '', 4)").evaluate(nullptr);
+    auto result4 = Jsonata("$split('a1b2c3d4', '', 4)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result4.is_array());
     std::vector<std::string> expected = {"a", "1", "b", "2"};
     ASSERT_EQ(result4.size(), expected.size());
     for (size_t i = 0; i < expected.size(); ++i) {
         ASSERT_TRUE(result4[i].is_string());
-        EXPECT_EQ(result4[i].get<std::string>(), expected[i]);
+        EXPECT_EQ(result4[i].template get<std::string>(), expected[i]);
     }
 
-    auto result5 = Jsonata("$split('this..is.a.test', '.')").evaluate(nullptr);
+    auto result5 = Jsonata("$split('this..is.a.test', '.')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result5.is_array());
     std::vector<std::string> expected5 = {"this", "", "is", "a", "test"};
     ASSERT_EQ(result5.size(), expected5.size());
     for (size_t i = 0; i < expected5.size(); ++i) {
         ASSERT_TRUE(result5[i].is_string());
-        EXPECT_EQ(result5[i].get<std::string>(), expected5[i]);
+        EXPECT_EQ(result5[i].template get<std::string>(), expected5[i]);
     }
 
-    auto result6 = Jsonata("$split('this..is.a.test...', '.')").evaluate(nullptr);
+    auto result6 = Jsonata("$split('this..is.a.test...', '.')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result6.is_array());
     std::vector<std::string> expected6 = {"this", "", "is", "a", "test", "", "", ""};
     ASSERT_EQ(result6.size(), expected6.size());
@@ -153,24 +155,24 @@ TEST_F(StringTest, splitTest) {
 }
 
 TEST_F(StringTest, trimTest) {
-    auto result1 = Jsonata("$trim(\"\n\")").evaluate(nullptr);
+    auto result1 = Jsonata("$trim(\"\n\")").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result1.is_string());
     EXPECT_EQ(result1.get<std::string>(), "");
 
-    auto result2 = Jsonata("$trim(\" \")").evaluate(nullptr);
+    auto result2 = Jsonata("$trim(\" \")").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result2.is_string());
     EXPECT_EQ(result2.get<std::string>(), "");
 
-    auto result3 = Jsonata("$trim(\"\")").evaluate(nullptr);
+    auto result3 = Jsonata("$trim(\"\")").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result3.is_string());
     EXPECT_EQ(result3.get<std::string>(), "");
 
-    auto result4 = Jsonata("$trim(notthere)").evaluate(nullptr);
+    auto result4 = Jsonata("$trim(notthere)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     EXPECT_TRUE(result4.is_null());
 }
 
 TEST_F(StringTest, evalTest) {
-    auto result = Jsonata("(\n  $data := {'Wert1': 'AAA', 'Wert2': 'BBB'};\n  $eval('$data.Wert1')\n)").evaluate(nullptr);
+    auto result = Jsonata("(\n  $data := {'Wert1': 'AAA', 'Wert2': 'BBB'};\n  $eval('$data.Wert1')\n)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "AAA");
 }
@@ -185,8 +187,8 @@ TEST_F(StringTest, regexTest) {
 
 TEST_F(StringTest, fieldnameWithSpecialCharTest) {
     Jsonata expr("$ ~> |$|{}|");
-    nlohmann::ordered_json input;
-    input["a\nb"] = "c\nd";
+    JSONATA_TEST_BACKEND input;
+    jsonata::backend::set( input, "a\nb", "c\nd" );
     auto result = expr.evaluate(input);
     EXPECT_EQ(result, input);
 }
@@ -195,7 +197,7 @@ TEST_F(StringTest, regexLiteralTest) {
     // Verify regex at end of expression doesn't crash (issue #88)
     EXPECT_NO_THROW({
         Jsonata expr("/^test.*$/");
-        expr.evaluate(nullptr);
+        expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     });
 }
 
@@ -203,13 +205,13 @@ TEST_F(StringTest, evalRegexTest) {
     // Verify $eval of regex at end of expression doesn't crash (issue #88)
     EXPECT_NO_THROW({
         Jsonata expr("$eval('/^test.*$/')");
-        expr.evaluate(nullptr);
+        expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     });
 }
 
 TEST_F(StringTest, evalRegexCheckAnswerDataTest) {
     Jsonata expr("(\n    $matcher := $eval('/l/');\n    ('Hello World' ~> $matcher);\n)");
-    auto result = expr.evaluate(nullptr);
+    auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_object());
     EXPECT_EQ(result["match"].get<std::string>(), "l");
     EXPECT_EQ(result["start"].get<long long>(), 2);
@@ -220,7 +222,7 @@ TEST_F(StringTest, evalRegexCheckAnswerDataTest) {
 
 TEST_F(StringTest, evalRegexCallNextTest) {
     Jsonata expr("(\n    $matcher := $eval('/l/');\n    ('Hello World' ~> $matcher).next();\n)");
-    auto result = expr.evaluate(nullptr);
+    auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_object());
     EXPECT_EQ(result["match"].get<std::string>(), "l");
     EXPECT_EQ(result["start"].get<long long>(), 3);
@@ -230,7 +232,7 @@ TEST_F(StringTest, evalRegexCallNextTest) {
 }
 
 TEST_F(StringTest, DISABLED_replaceTest) {
-    auto input = nlohmann::ordered_json("http://example.org/test{par}");
+    auto input = JSONATA_TEST_BACKEND("http://example.org/test{par}");
     auto result = Jsonata("$replace($, /{par}/, '')").evaluate(input);
     ASSERT_TRUE(result.is_string());
     EXPECT_EQ(result.get<std::string>(), "http://example.org/test");
diff --git a/test/ThreadTest.cpp b/test/ThreadTest.cpp
index 14fbb51..a31e7c6 100644
--- a/test/ThreadTest.cpp
+++ b/test/ThreadTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -19,7 +19,7 @@ class ThreadTest : public ::testing::Test {
 
 TEST_F(ThreadTest, testReuse) {
     Jsonata expr("a");
-    nlohmann::ordered_json data = nlohmann::ordered_json::object({{"a", 1}});
+    JSONATA_TEST_BACKEND data = JSONATA_TEST_BACKEND::object({{"a", 1}});
 
     auto result1 = expr.evaluate(data);
     ASSERT_TRUE(result1.is_number());
@@ -32,9 +32,9 @@ TEST_F(ThreadTest, testReuse) {
 
 TEST_F(ThreadTest, testNow) {
     Jsonata now("$now()");
-    auto r1 = now.evaluate(nullptr);
+    auto r1 = now.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     std::this_thread::sleep_for(std::chrono::milliseconds(42));
-    auto r2 = now.evaluate(nullptr);
+    auto r2 = now.evaluate<JSONATA_TEST_BACKEND>(nullptr);
 
     ASSERT_TRUE(r1.is_string());
     ASSERT_TRUE(r2.is_string());
@@ -59,13 +59,13 @@ TEST_F(ThreadTest, testReuseWithVariable) {
     expr.registerFunction("wait", waitFn);
 
     auto outerFuture = std::async(std::launch::async, [&expr]() {
-        nlohmann::ordered_json data = nlohmann::ordered_json::object({{"a", 100}});
+        JSONATA_TEST_BACKEND data = JSONATA_TEST_BACKEND::object({{"a", 100}});
         return expr.evaluate(data);
     });
 
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
-    nlohmann::ordered_json data30 = nlohmann::ordered_json::object({{"a", 30}});
+    JSONATA_TEST_BACKEND data30 = JSONATA_TEST_BACKEND::object({{"a", 30}});
     auto result30 = expr.evaluate(data30);
     ASSERT_TRUE(result30.is_number());
     EXPECT_EQ(result30.get<int>(), 30);
@@ -78,8 +78,8 @@ TEST_F(ThreadTest, testReuseWithVariable) {
 TEST_F(ThreadTest, testAddEnvAndInput) {
     Jsonata expr("$eval('$count($keys($))')");
 
-    nlohmann::ordered_json obj1 = nlohmann::ordered_json::object({{"input", 1}});
-    nlohmann::ordered_json obj2 = nlohmann::ordered_json::object({{"input", 2}, {"other", 3}});
+    JSONATA_TEST_BACKEND obj1 = JSONATA_TEST_BACKEND::object({{"input", 1}});
+    JSONATA_TEST_BACKEND obj2 = JSONATA_TEST_BACKEND::object({{"input", 2}, {"other", 3}});
 
     const int count = 200; // keep the test fast
 
diff --git a/test/TypesTest.cpp b/test/TypesTest.cpp
index 4f5760c..3d11d04 100644
--- a/test/TypesTest.cpp
+++ b/test/TypesTest.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include <nlohmann/json.hpp>
+#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <vector>
 #include <memory>
@@ -16,7 +16,7 @@ class TypesTest : public ::testing::Test {
 };
 
 TEST_F(TypesTest, castTestIn) {
-    auto arrayData = nlohmann::ordered_json::array({1.0, 2.0});
+    auto arrayData = JSONATA_TEST_BACKEND::array({1.0, 2.0});
 
     auto result1 = Jsonata("3 in $").evaluate(arrayData);
     ASSERT_TRUE(result1.is_boolean());
@@ -28,80 +28,80 @@ TEST_F(TypesTest, castTestIn) {
 }
 
 TEST_F(TypesTest, castTestEquals) {
-    auto data1 = nlohmann::ordered_json(1.0);
+    auto data1 = JSONATA_TEST_BACKEND(1.0);
     auto result1 = Jsonata("1 = $").evaluate(data1);
     ASSERT_TRUE(result1.is_boolean());
     EXPECT_TRUE(result1.get<bool>());
 
-    auto data2 = nlohmann::ordered_json(2.0);
+    auto data2 = JSONATA_TEST_BACKEND(2.0);
     auto result2 = Jsonata("1 = $").evaluate(data2);
     ASSERT_TRUE(result2.is_boolean());
     EXPECT_FALSE(result2.get<bool>());
 
-    auto result3 = Jsonata("{'x':1 } = {'x':1 }").evaluate(nullptr);
+    auto result3 = Jsonata("{'x':1 } = {'x':1 }").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result3.is_boolean());
     EXPECT_TRUE(result3.get<bool>());
 
-    auto result4 = Jsonata("{'x':1 } = {'x':2 }").evaluate(nullptr);
+    auto result4 = Jsonata("{'x':1 } = {'x':2 }").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result4.is_boolean());
     EXPECT_FALSE(result4.get<bool>());
 
-    auto result5 = Jsonata("[1,null] = [1,null]").evaluate(nullptr);
+    auto result5 = Jsonata("[1,null] = [1,null]").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result5.is_boolean());
     EXPECT_TRUE(result5.get<bool>());
 
-    auto result6 = Jsonata("[1,null] = [2,null]").evaluate(nullptr);
+    auto result6 = Jsonata("[1,null] = [2,null]").evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result6.is_boolean());
     EXPECT_FALSE(result6.get<bool>());
 }
 
 TEST_F(TypesTest, testIllegalTypes) {
     // Not directly applicable in JSON; ensure that passing unexpected types throws when appropriate
-    EXPECT_NO_THROW(Jsonata("$").evaluate(nlohmann::ordered_json("c")));
+    EXPECT_NO_THROW(Jsonata("$").evaluate(JSONATA_TEST_BACKEND("c")));
 }
 
 TEST_F(TypesTest, testLegalTypes) {
-    auto mapData = nlohmann::ordered_json::object({{"a", 1}});
+    auto mapData = JSONATA_TEST_BACKEND::object({{"a", 1}});
     auto result1 = Jsonata("a").evaluate(mapData);
     ASSERT_TRUE(result1.is_number());
     EXPECT_EQ(result1.get<int>(), 1);
 
-    auto arrayData = nlohmann::ordered_json::array({1, 2});
+    auto arrayData = JSONATA_TEST_BACKEND::array({1, 2});
     auto result2 = Jsonata("$[0]").evaluate(arrayData);
     ASSERT_TRUE(result2.is_number());
     EXPECT_EQ(result2.get<int>(), 1);
 
-    auto stringData = nlohmann::ordered_json("string");
+    auto stringData = JSONATA_TEST_BACKEND("string");
     auto result3 = Jsonata("$").evaluate(stringData);
     ASSERT_TRUE(result3.is_string());
     EXPECT_EQ(result3.get<std::string>(), "string");
 
-    auto intData = nlohmann::ordered_json(1);
+    auto intData = JSONATA_TEST_BACKEND(1);
     auto result4 = Jsonata("$").evaluate(intData);
     ASSERT_TRUE(result4.is_number());
     EXPECT_EQ(result4.get<int>(), 1);
 
-    auto longData = nlohmann::ordered_json(1L);
+    auto longData = JSONATA_TEST_BACKEND(1L);
     auto result5 = Jsonata("$").evaluate(longData);
     ASSERT_TRUE(result5.is_number());
     EXPECT_EQ(result5.get<long>(), 1L);
 
-    auto boolData = nlohmann::ordered_json(true);
+    auto boolData = JSONATA_TEST_BACKEND(true);
     auto result6 = Jsonata("$").evaluate(boolData);
     ASSERT_TRUE(result6.is_boolean());
     EXPECT_TRUE(result6.get<bool>());
 
-    auto doubleData = nlohmann::ordered_json(1.0);
+    auto doubleData = JSONATA_TEST_BACKEND(1.0);
     auto result7 = Jsonata("$").evaluate(doubleData);
     ASSERT_TRUE(result7.is_number());
     EXPECT_DOUBLE_EQ(result7.get<double>(), 1.0);
 
-    auto floatData = nlohmann::ordered_json(1.0f);
+    auto floatData = JSONATA_TEST_BACKEND(1.0f);
     auto result8 = Jsonata("$").evaluate(floatData);
     ASSERT_TRUE(result8.is_number());
     EXPECT_FLOAT_EQ(result8.get<float>(), 1.0f);
 
-    auto bigDecimalData = nlohmann::ordered_json(3.14);
+    auto bigDecimalData = JSONATA_TEST_BACKEND(3.14);
     auto result9 = Jsonata("$").evaluate(bigDecimalData);
     ASSERT_TRUE(result9.is_number());
     EXPECT_DOUBLE_EQ(result9.get<double>(), 3.14);
@@ -114,11 +114,11 @@ struct Pojo {
 };
 
 TEST_F(TypesTest, testJacksonConversion) {
-    nlohmann::ordered_json obj = {
+    JSONATA_TEST_BACKEND obj = JSONATA_TEST_BACKEND::object({
         {"c", "c"},
         {"d", 1234567890L},
-        {"arr", nlohmann::ordered_json::array({0,1,2,3})}
-    };
+        {"arr", JSONATA_TEST_BACKEND::array({0,1,2,3})}
+    });
 
     auto result1 = Jsonata("c").evaluate(obj);
     ASSERT_TRUE(result1.is_string());
@@ -140,12 +140,12 @@ TEST_F(TypesTest, testCustomFunction) {
     Jsonata fn("$foo()");
     JFunction jfn;
     jfn.implementation = [](const Utils::JList&, const std::any&, std::shared_ptr<Frame>) -> std::any {
-        nlohmann::ordered_json obj = {{"c", "c"}};
+        JSONATA_TEST_BACKEND obj = {{"c", "c"}};
         return obj;
     };
     fn.registerFunction("foo", jfn);
 
-    auto result = fn.evaluate(nullptr);
+    auto result = fn.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     ASSERT_TRUE(result.is_object());
     ASSERT_TRUE(result.contains("c"));
     EXPECT_EQ(result["c"].get<std::string>(), "c");
@@ -153,7 +153,7 @@ TEST_F(TypesTest, testCustomFunction) {
 
 TEST_F(TypesTest, testIgnore) {
     Jsonata expr("a");
-    auto validData = nlohmann::ordered_json::object({{"a", "test"}});
+    auto validData = JSONATA_TEST_BACKEND::object({{"a", "test"}});
     auto result1 = expr.evaluate(validData);
     ASSERT_TRUE(result1.is_string());
     EXPECT_EQ(result1.get<std::string>(), "test");
diff --git a/test/gen/function_lengthTest.cpp b/test/gen/function_lengthTest.cpp
index 1bc2348..3890edf 100644
--- a/test/gen/function_lengthTest.cpp
+++ b/test/gen/function_lengthTest.cpp
@@ -26,7 +26,7 @@ TEST_F(function_lengthTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case003.json"));
 }
 
-// $length(\"\\uD834\\uDD1E\")
+// $length(\\\"\\\\uD834\\\\uDD1E\\\")
 TEST_F(function_lengthTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case004.json"));
 }

From 8ca6f6ce2ed032c48881e7869d76a4127a5ed5f4 Mon Sep 17 00:00:00 2001
From: wim delvaux <wim.delvaux@adaptiveplanet.com>
Date: Mon, 11 May 2026 01:09:48 +0200
Subject: [PATCH 3/7] almost compiles

---
 CMakeLists.txt                               |  57 +-
 include/jsonata/Functions.h                  |   9 +-
 include/jsonata/Jsonata.h                    | 175 ++---
 include/jsonata/backend.h                    | 517 +++++++++++++
 include/jsonata/common_backend.h             |  24 +
 include/jsonata/nlohmann_backend.h           | 191 +++++
 include/jsonata/qtjson_backend.h             | 732 +++++++++++++++++++
 include/jsonata/qtvariant_backend.h          |  40 +
 src/jsonata/Functions.cpp                    |  62 +-
 src/jsonata/JException.cpp                   |   1 -
 src/jsonata/Jsonata.cpp                      | 342 ++++-----
 src/jsonata/Utils.cpp                        |   4 +-
 src/jsonata/utils/Signature.cpp              |   3 +-
 test/ArrayTest.cpp                           |  27 +-
 test/CustomFunctionTest.cpp                  |  15 +-
 test/DateTimeTest.cpp                        |   5 +-
 test/Generate.cpp                            |  18 +-
 test/JsonataTest.cpp                         | 210 +++---
 test/JsonataTest.h                           |  17 +-
 test/NullSafetyTest.cpp                      |  40 +-
 test/NumberTest.cpp                          |  12 +-
 test/NumberTestSimplified.cpp                |  21 +-
 test/ParseIntegerTest.cpp                    |   5 +-
 test/SerializationTest.cpp                   |   9 +-
 test/SignatureTest.cpp                       |   7 +-
 test/StringTest.cpp                          | 103 ++-
 test/ThreadTest.cpp                          |  27 +-
 test/TypesTest.cpp                           |  78 +-
 test/gen/array_constructorTest.cpp           |  68 +-
 test/gen/blocksTest.cpp                      |  14 +-
 test/gen/boolean_expresssionsTest.cpp        |  62 +-
 test/gen/closuresTest.cpp                    |   4 +-
 test/gen/coalescing_operatorTest.cpp         |  26 +-
 test/gen/comparison_operatorsTest.cpp        | 154 +---
 test/gen/conditionalsTest.cpp                |  18 +-
 test/gen/contextTest.cpp                     |   8 +-
 test/gen/default_operatorTest.cpp            |  28 +-
 test/gen/descendent_operatorTest.cpp         |  34 +-
 test/gen/encodingTest.cpp                    |   8 +-
 test/gen/errorsTest.cpp                      |  54 +-
 test/gen/fieldsTest.cpp                      |  16 +-
 test/gen/flatteningTest.cpp                  | 167 ++---
 test/gen/function_absTest.cpp                |   8 +-
 test/gen/function_appendTest.cpp             |  12 +-
 test/gen/function_applicationsTest.cpp       |  44 +-
 test/gen/function_assertTest.cpp             |  16 +-
 test/gen/function_averageTest.cpp            |  26 +-
 test/gen/function_booleanTest.cpp            |  48 +-
 test/gen/function_ceilTest.cpp               |   8 +-
 test/gen/function_containsTest.cpp           |  14 +-
 test/gen/function_countTest.cpp              |  28 +-
 test/gen/function_decodeUrlComponentTest.cpp |   6 +-
 test/gen/function_decodeUrlTest.cpp          |   6 +-
 test/gen/function_distinctTest.cpp           |  41 +-
 test/gen/function_eachTest.cpp               |   6 +-
 test/gen/function_encodeUrlComponentTest.cpp |   4 +-
 test/gen/function_encodeUrlTest.cpp          |   4 +-
 test/gen/function_errorTest.cpp              |  22 +-
 test/gen/function_evalTest.cpp               |  37 +-
 test/gen/function_existsTest.cpp             |  50 +-
 test/gen/function_floorTest.cpp              |   8 +-
 test/gen/function_formatBaseTest.cpp         |  16 +-
 test/gen/function_formatIntegerTest.cpp      | 326 +--------
 test/gen/function_formatNumberTest.cpp       |  74 +-
 test/gen/function_fromMillisTest.cpp         | 458 +-----------
 test/gen/function_joinTest.cpp               |  24 +-
 test/gen/function_keysTest.cpp               |  14 +-
 test/gen/function_lengthTest.cpp             |  32 +-
 test/gen/function_lookupTest.cpp             |   8 +-
 test/gen/function_lowercaseTest.cpp          |   4 +-
 test/gen/function_maxTest.cpp                |  54 +-
 test/gen/function_mergeTest.cpp              |  10 +-
 test/gen/function_numberTest.cpp             |  68 +-
 test/gen/function_padTest.cpp                |  26 +-
 test/gen/function_parseIntegerTest.cpp       | 306 +-------
 test/gen/function_powerTest.cpp              |  14 +-
 test/gen/function_replaceTest.cpp            |  24 +-
 test/gen/function_reverseTest.cpp            |   8 +-
 test/gen/function_roundTest.cpp              |  36 +-
 test/gen/function_shuffleTest.cpp            |   8 +-
 test/gen/function_siftTest.cpp               |  10 +-
 test/gen/function_signaturesTest.cpp         |  70 +-
 test/gen/function_sortTest.cpp               |  22 +-
 test/gen/function_splitTest.cpp              |  38 +-
 test/gen/function_spreadTest.cpp             |   8 +-
 test/gen/function_sqrtTest.cpp               |   8 +-
 test/gen/function_stringTest.cpp             |  60 +-
 test/gen/function_substringAfterTest.cpp     |  10 +-
 test/gen/function_substringBeforeTest.cpp    |  10 +-
 test/gen/function_substringTest.cpp          |  38 +-
 test/gen/function_sumTest.cpp                |  14 +-
 test/gen/function_tomillisTest.cpp           | 257 +------
 test/gen/function_trimTest.cpp               |   6 +-
 test/gen/function_typeOfTest.cpp             |  26 +-
 test/gen/function_uppercaseTest.cpp          |   4 +-
 test/gen/function_zipTest.cpp                |  12 +-
 test/gen/higher_order_functionsTest.cpp      |   6 +-
 test/gen/hof_filterTest.cpp                  |   8 +-
 test/gen/hof_mapTest.cpp                     |  24 +-
 test/gen/hof_reduceTest.cpp                  |  18 +-
 test/gen/hof_singleTest.cpp                  |  22 +-
 test/gen/hof_zip_mapTest.cpp                 |   8 +-
 test/gen/inclusion_operatorTest.cpp          |  18 +-
 test/gen/joinsTest.cpp                       | 211 +-----
 test/gen/lambdasTest.cpp                     |  28 +-
 test/gen/literalsTest.cpp                    |  61 +-
 test/gen/matchersTest.cpp                    |   2 +-
 test/gen/missing_pathsTest.cpp               |  12 +-
 test/gen/multiple_array_selectorsTest.cpp    |   6 +-
 test/gen/nullTest.cpp                        |  14 +-
 test/gen/numeric_operatorsTest.cpp           |  38 +-
 test/gen/object_constructorTest.cpp          |  52 +-
 test/gen/parent_operatorTest.cpp             | 218 +-----
 test/gen/parenthesesTest.cpp                 |  16 +-
 test/gen/partial_applicationTest.cpp         |  10 +-
 test/gen/performanceTest.cpp                 |   4 +-
 test/gen/predicatesTest.cpp                  |   8 +-
 test/gen/quoted_selectorsTest.cpp            |  16 +-
 test/gen/range_operatorTest.cpp              |  50 +-
 test/gen/regexTest.cpp                       |  78 +-
 test/gen/simple_array_selectorsTest.cpp      |  46 +-
 test/gen/sortingTest.cpp                     |  42 +-
 test/gen/string_concatTest.cpp               |  24 +-
 test/gen/tail_recursionTest.cpp              |  20 +-
 test/gen/token_conversionTest.cpp            |   8 +-
 test/gen/transformTest.cpp                   | 208 +++---
 test/gen/transformsTest.cpp                  |  30 +-
 test/gen/variablesTest.cpp                   |  26 +-
 test/gen/wildcardsTest.cpp                   |  20 +-
 129 files changed, 3418 insertions(+), 3837 deletions(-)
 create mode 100644 include/jsonata/backend.h
 create mode 100644 include/jsonata/common_backend.h
 create mode 100644 include/jsonata/nlohmann_backend.h
 create mode 100644 include/jsonata/qtjson_backend.h
 create mode 100644 include/jsonata/qtvariant_backend.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7eab829..0d62dd8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,7 +11,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 option(JSONATA_NLOHMANN_BACKEND "Build qjsonata with nlohmann json backend" OFF)
-option(JSONATA_QT_BACKEND "Build qjsonata with Qt json backend" OFF)
+option(JSONATA_QTJSON_BACKEND "Build qjsonata with Qt json backend" OFF)
+option(JSONATA_QTVARIANT_BACKEND "Build qjsonata with Qt QVariant backend" OFF)
 
 include(GNUInstallDirs)
 include(FetchContent)
@@ -31,15 +32,23 @@ if( JSONATA_NLOHMANN_BACKEND )
         # Mark that we used FetchContent
         set(JSONATA_USED_FETCHCONTENT_JSON TRUE)
     endif()
-    list( APPEND JSONATA_ENABLED_BACKENDS nlohmann::ordered_json nlohmann::json)
+    list( APPEND JSONATA_ENABLED_BACKENDS nlohmann::unordered_json nlohmann::json )
+    set( JSONATA_NLOHMANN_ENABLED true )
 endif()
 
-if( JSONATA_QT_BACKEND )
+if( JSONATA_QTJSON_BACKEND OR JSONATA_QTVARIANT_BACKEND )
     find_package(Qt6 REQUIRED COMPONENTS Core)
     if(NOT Qt6_FOUND)
         error( "Cannot find Qt >=6.10" )
     endif()
-    list( APPEND JSONATA_ENABLED_BACKENDS jsonata::backend::json )
+    if( JSONATA_QTJSON_BACKEND  )
+        list( APPEND JSONATA_ENABLED_BACKENDS QJsonValue )
+        set( JSONATA_QTJSON_ENABLED true )
+    endif()
+    if( JSONATA_QTVARIANT_BACKEND )
+        list( APPEND JSONATA_ENABLED_BACKENDS QVariant )
+        set( JSONATA_QTVARIANT_ENABLED true )
+    endif()
 endif()
 
 # Collect source files
@@ -87,9 +96,6 @@ target_include_directories(qjsonata PUBLIC
 )
 
 if( JSONATA_NLOHMANN_BACKEND )
-    # tell sources to compile NLOHMANN backend
-    target_compile_definitions( qjsonata PUBLIC JSONATA_NLOHMANN_ENABLED )
-
     # nlohmann_json is used from public headers, so propagate it PUBLIC.
     # Ensure the exported target only records the imported name in the install
     # interface to avoid referencing non-exported build targets.
@@ -109,19 +115,33 @@ if( JSONATA_NLOHMANN_BACKEND )
             $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
         )
     endif()
+    target_compile_definitions(qjsonata PUBLIC JSONATA_NLOHMANN_ENABLED )
 endif()
 
-if( JSONATA_QT_BACKEND )
-    # tell sources to compile NLOHMANN backend
-    target_compile_definitions( qjsonata PUBLIC JSONATA_QT_ENABLED )
-
+if( JSONATA_QTJSON_BACKEND OR JSONATA_QTVARIANT_BACKEND )
     target_link_libraries(qjsonata PUBLIC Qt6::Core)
+    if( JSONATA_QTJSON_BACKEND )
+        target_compile_definitions(qjsonata PUBLIC JSONATA_QTJSON_ENABLED )
+    endif()
+    if( JSONATA_QTVARIANT_BACKEND )
+        target_compile_definitions(qjsonata PUBLIC JSONATA_QTVARIANT_ENABLED )
+    endif()
 endif()
 
 # Optionally build tests
 option(JSONATA_BUILD_TESTS "Build QJSONata C++ tests" OFF)
 
 if(JSONATA_BUILD_TESTS)
+    # for testing at least one backend needs to be enabled
+
+    # 1. Check the length of the list
+    list(LENGTH JSONATA_ENABLED_BACKENDS LIST_LEN)
+
+    # 2. If the length is 0, throw a fatal error
+    if(LIST_LEN EQUAL 0)
+        message(FATAL_ERROR "At least one backend must be enabled.")
+    endif()
+
     # Download GoogleTest if not already present
     # See https://google.github.io/googletest/quickstart-cmake.html
     FetchContent_Declare(
@@ -149,6 +169,11 @@ if(JSONATA_BUILD_TESTS)
         test/TypesTest.cpp
     )
 
+    # Create test generator executable
+    add_executable(qgenerate test/Generate.cpp
+        include/jsonata/backend.h)
+    target_link_libraries(qgenerate qjsonata)
+
     # Create main test executables
     foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
         # 1. Strip the extension to create a clean executable name
@@ -172,14 +197,12 @@ if(JSONATA_BUILD_TESTS)
             gtest
             Threads::Threads
         )
+        # will select the last backend to test but we only need one to generate
+        target_compile_definitions(qgenerate PRIVATE
+            JSONATA_TEST_BACKEND=${BE}
+        )
     endforeach()
 
-    # Create test generator executable
-    add_executable(qgenerate test/Generate.cpp)
-    target_link_libraries(qgenerate qjsonata)
-    target_compile_definitions(qgenerate PRIVATE
-        JSONATA_TEST_BACKEND=${BE}
-    )
 
     # Custom command to generate test files
     add_custom_command(
diff --git a/include/jsonata/Functions.h b/include/jsonata/Functions.h
index 2687713..62d0743 100644
--- a/include/jsonata/Functions.h
+++ b/include/jsonata/Functions.h
@@ -20,7 +20,6 @@
 
 #include <any>
 #include <functional>
-#include "jsonata/backends.h"
 #include <optional>
 #include <regex>
 #include <sstream>
@@ -133,7 +132,7 @@ class Functions {
                                           const std::string& char_ = " ");
     static std::optional<std::string> formatNumber(
         double value, const std::string& picture,
-        const jsonata::backend::ordered_map<std::string, std::any>& options = {});
+        const std::unordered_map<std::string, std::any>& options = {});
     static std::any shuffle(const Utils::JList& args);
     static std::any lookup(const std::any& input, const std::string& key);
     static void error(const std::string& message);
@@ -195,7 +194,7 @@ class Functions {
             : implementation(impl), signature(sig) {}
     };
 
-    static jsonata::backend::ordered_map<std::string, FunctionEntry>
+    static std::unordered_map<std::string, FunctionEntry>
     getFunctionRegistry();
     static std::any applyFunction(const std::string& name,
                                   const Utils::JList& args);
@@ -233,7 +232,7 @@ class Functions {
     static std::string safeReplaceAllFn(const std::string& str,
                                         const std::regex& pattern,
                                         const std::any& func);
-    static jsonata::backend::ordered_map<std::string, std::any> toJsonataMatch(
+    static std::unordered_map<std::string, std::any> toJsonataMatch(
         const std::smatch& match);
     static std::string encodeURI(const std::string& uri);
     static std::string leftPad(const std::string& str, int64_t size,
@@ -257,7 +256,7 @@ class Functions {
     };
 
     static FormatSymbols processOptionsArg(
-        const jsonata::backend::ordered_map<std::string, std::any>& options);
+        const std::unordered_map<std::string, std::any>& options);
     static std::string getFormattingCharacter(const std::string& value,
                                               const std::string& propertyName,
                                               bool isChar);
diff --git a/include/jsonata/Jsonata.h b/include/jsonata/Jsonata.h
index 5e8bf7f..fca7841 100644
--- a/include/jsonata/Jsonata.h
+++ b/include/jsonata/Jsonata.h
@@ -25,7 +25,6 @@
  */
 #pragma once
 
-#include "jsonata/backends.h"
 #include <any>
 #include <chrono>
 #include <functional>
@@ -35,6 +34,7 @@
 #include <vector>
 
 #include "jsonata/Parser.h"
+#include "Jsonata/backend.h"
 
 // Forward declarations
 namespace jsonata
@@ -60,7 +60,7 @@ namespace jsonata
     {
         private:
             std::shared_ptr<Frame> parent_;
-            jsonata::backend::ordered_map<std::string, std::any> bindings_;
+            std::unordered_map<std::string, std::any> bindings_;
             std::chrono::time_point<std::chrono::steady_clock> timestamp_;
             int64_t timeout_;
             int64_t recursionDepth_;
@@ -91,7 +91,7 @@ namespace jsonata
             std::shared_ptr<Frame> getParent() const { return parent_; }
 
             // Bindings access
-            const jsonata::backend::ordered_map<std::string, std::any> &getBindings() const
+            const std::unordered_map<std::string, std::any> &getBindings() const
             {
                 return bindings_;
             }
@@ -129,14 +129,13 @@ namespace jsonata
 
             template <typename T>
                 requires isCompatible<T>
-            static T parse( const std::string & s ) {
-                return T::parse( s );
+            static backend<T> parse( const std::string & s ) {
+                return wrap(T::parse( s ));
             }
 
             // Main evaluation methods
             template<typename T>
-                requires isCompatible<T>
-            T evaluate(const T &input, std::shared_ptr<Frame> bindings)
+            jsonata::backend<T> evaluate(const T &input, std::shared_ptr<Frame> bindings)
             {
                 currentInstance_ = this;
 
@@ -159,37 +158,46 @@ namespace jsonata
             }
 
             template<typename T>
-                requires isCompatible<T>
-            inline T evaluate(const T &input)
+            jsonata::backend<T> evaluate(const jsonata::backend<T> &input, std::shared_ptr<Frame> bindings) {
+                return evaluate( *input, bindings );
+            }
+
+            template<typename T>
+            inline jsonata::backend<T> evaluate(const T &input)
             {
                 return evaluate(input, nullptr);
             }
+
+            template<typename T>
+            inline jsonata::backend<T> evaluate(const jsonata::backend<T> &input)
+            {
+                return evaluate(*input );
+            }
+
             template<typename T>
-                requires isCompatible<T>
-            T evaluate(std::nullptr_t)
+            jsonata::backend<T> evaluate(std::nullptr_t)
             {
                 return evaluate(T());
             }
             template<typename T>
-                requires isCompatible<T>
-            T evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings)
+            jsonata::backend<T> evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings)
             {
                 return evaluate(T(), bindings);
             }
 
             // Main evaluation methods (ordered JSON variants)
-            // jsonata::backend::ordered_json evaluate(const jsonata::backend::ordered_json &input);
-            // jsonata::backend::ordered_json evaluate(const jsonata::backend::ordered_json &input,
+            // jsonata::ordered_json evaluate(const jsonata::ordered_json &input);
+            // jsonata::ordered_json evaluate(const jsonata::ordered_json &input,
             //                                         std::shared_ptr<Frame> bindings);
-            // jsonata::backend::ordered_json evaluate(std::nullptr_t);
-            // jsonata::backend::ordered_json evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings);
+            // jsonata::ordered_json evaluate(std::nullptr_t);
+            // jsonata::ordered_json evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings);
 
-            // // Main evaluation methods (unordered jsonata::backend::json variants)
-            // jsonata::backend::json evaluate(const jsonata::backend::json &input);
-            // jsonata::backend::json evaluate(const jsonata::backend::json &input,
+            // // Main evaluation methods (unordered jsonata::json variants)
+            // jsonata::json evaluate(const jsonata::json &input);
+            // jsonata::json evaluate(const jsonata::json &input,
             //                                 std::shared_ptr<Frame> bindings);
-            // jsonata::backend::json evaluateUnordered(std::nullptr_t);
-            // jsonata::backend::json evaluateUnordered(std::nullptr_t,
+            // jsonata::json evaluateUnordered(std::nullptr_t);
+            // jsonata::json evaluateUnordered(std::nullptr_t,
             //                                          std::shared_ptr<Frame> bindings);
 
             std::any evaluate(std::shared_ptr<Parser::Symbol> expr,
@@ -436,16 +444,17 @@ namespace jsonata
             std::any reduceTupleStream(const std::any &tupleStream);
 
             // Conversion helpers between engine types and JSON
-            // Ordered variants preserve insertion order using jsonata::backend::ordered_json
+            // Ordered variants preserve insertion order using jsonata::ordered_json
             template<typename T>
                 requires isCompatible<T>
-            static std::any toAny(const T &j)
+            static std::any toAny(const T &jv)
             {
-                if (j.is_null())
+                auto j = jsonata::backend(jv);
+                if (j.isNull())
                     return std::any{};
-                if (j.is_boolean())
+                if (j.isBool())
                     return std::any(j.template get<bool>());
-                if (j.is_number_integer()) {
+                if (j.isInteger()) {
                     // Preserve sign by using int64_t; for large unsigned, capture as
                     // uint64_t
                     int64_t si = 0;
@@ -457,23 +466,23 @@ namespace jsonata
                     uint64_t ui = j.template get<uint64_t>();
                     return std::any(static_cast<uint64_t>(ui));
                 }
-                if (j.is_number_unsigned()) {
+                if (j.isUnsignedInteger()) {
                     uint64_t ui = j.template get<uint64_t>();
                     return std::any(static_cast<uint64_t>(ui));
                 }
-                if (j.is_number_float())
+                if (j.isFloat())
                     return std::any(j.template get<double>());
-                if (j.is_string())
+                if (j.isString())
                     return std::any(j.template get<std::string>());
-                if (j.is_array()) {
+                if (j.isArray()) {
                     std::vector<std::any> out;
                     out.reserve(j.size());
-                    jsonata::backend::copy(j, out, [](const T &el) { return toAny(el); });
+                    jsonata::copy(j, out, [](const T &el) { return toAny(el); });
                     return out;
                 }
-                if (j.is_object()) {
-                    jsonata::backend::ordered_map<std::string, std::any> m;
-                    jsonata::backend::copy(j, m, [](const T &el) { return toAny(el); });
+                if (j.isObject()) {
+                    std::unordered_map<std::string, std::any> m;
+                    jsonata::copy(j, m, [](const T &el) { return toAny(el); });
                     return m;
                 }
                 return std::any{};
@@ -481,10 +490,10 @@ namespace jsonata
 
             template<typename T>
                 requires isCompatible<T>
-            static T fromAny(const std::any &value)
+            static jsonata::backend<T> fromAny(const std::any &value)
             {
                 if (!value.has_value())
-                    return T();
+                    return jsonata::backend<T>::create();
 
                 // Canonicalize numeric types: convert doubles with no fractional part to
                 // integer types
@@ -501,57 +510,57 @@ namespace jsonata
 
                 const std::type_info &type = value.type();
                 if (type == typeid(bool))
-                    return T(std::any_cast<bool>(value));
+                    return jsonata::backend<T>::create(std::any_cast<bool>(value));
                 if (type == typeid(double))
-                    return T(std::any_cast<double>(value));
+                    return jsonata::backend<T>::create(std::any_cast<double>(value));
                 if (type == typeid(int64_t))
-                    return T(std::any_cast<int64_t>(value));
+                    return jsonata::backend<T>::create(std::any_cast<int64_t>(value));
                 if (type == typeid(uint64_t))
-                    return T(std::any_cast<uint64_t>(value));
+                    return jsonata::backend<T>::create(std::any_cast<uint64_t>(value));
                 // Cross-platform support for additional integral types (e.g., long/long long)
                 if (type == typeid(long long))
-                    return T(static_cast<int64_t>(std::any_cast<long long>(value)));
+                    return jsonata::backend<T>::create(static_cast<int64_t>(std::any_cast<long long>(value)));
                 if (type == typeid(unsigned long long))
-                    return T(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
+                    return jsonata::backend<T>::create(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
                 if (type == typeid(long))
-                    return T(static_cast<int64_t>(std::any_cast<long>(value)));
+                    return jsonata::backend<T>::create(static_cast<int64_t>(std::any_cast<long>(value)));
                 if (type == typeid(unsigned long))
-                    return T(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
+                    return jsonata::backend<T>::create(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
                 if (type == typeid(int))
-                    return T(static_cast<int64_t>(std::any_cast<int>(value)));
+                    return jsonata::backend<T>::create(static_cast<int64_t>(std::any_cast<int>(value)));
                 if (type == typeid(unsigned int))
-                    return T(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
+                    return jsonata::backend<T>::create(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
                 if (type == typeid(std::string))
-                    return T(std::any_cast<std::string>(value));
+                    return jsonata::backend<T>::create(std::any_cast<std::string>(value));
                 if (type == typeid(Utils::JList)) {
-                    auto arr = T::array();
+                    auto arr = jsonata::backend<T>::array();
                     const auto &jlist = std::any_cast<const Utils::JList &>(value);
-                    jsonata::backend::copy(jlist, arr, [](const std::any &a) { return fromAny<T>(a); });
+                    jsonata::copy(jlist, arr, [](const std::any &a) { return fromAny<T>(a); });
                     return arr;
                 }
                 if (type == typeid(std::vector<std::any>)) {
-                    auto arr = T::array();
+                    auto arr = jsonata::backend<T>::array();
                     const auto &vec = std::any_cast<const std::vector<std::any> &>(value);
-                    jsonata::backend::copy(vec, arr, [](const std::any &a) { return fromAny<T>(a); });
+                    jsonata::copy(vec, arr, [](const std::any &a) { return fromAny<T>(a); });
                     return arr;
                 }
-                if (type == typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
-                    auto obj = T::object();
+                if (type == typeid(std::unordered_map<std::string, std::any>)) {
+                    auto obj = jsonata::backend<T>::object();
                     const auto &map = std::
-                        any_cast<const jsonata::backend::ordered_map<std::string, std::any> &>(
+                        any_cast<const std::unordered_map<std::string, std::any> &>(
                             value);
-                    jsonata::backend::copy(map, obj, [](const std::any &a) { return fromAny<T>(a); });
+                    jsonata::copy(map, obj, [](const std::any &a) { return fromAny<T>(a); });
                     return obj;
                 }
                 if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
-                    return T();
+                    return jsonata::backend<T>::create();
                 }
-                // Directly handle jsonata::backend::ordered_json returned from custom functions
+                // Directly handle json returned from custom functions
                 if (type == typeid(T)) {
-                    return std::any_cast<T>(value);
+                    return jsonata::backend<T>(std::any_cast<T>(value));
                 }
 
-                return T();
+                return jsonata::backend<T>::create();
             }
 
             template<typename from, typename to >
@@ -559,49 +568,49 @@ namespace jsonata
             static to convert( const from & oj ) {
                 // Recursive lambda to convert ordered_json to json
                 std::function<to(const from & )> convert = [&](const from & j) -> to {
-                    if (j.is_null()) return to();
-                    if (j.is_boolean()) return to(j.template get<bool>());
-                    if (j.is_number_integer()) {
+                    if (j.isNull()) return jsonata::backend<to>::create();
+                    if (j.isBool()) return jsonata::backend<to>::create(j.template get<bool>());
+                    if (j.isInteger()) {
                         int64_t si = 0;
                         try {
                             si = j.template get<int64_t>();
-                            return to(static_cast<int64_t>(si));
+                            return jsonata::backend<to>::create(static_cast<int64_t>(si));
                         } catch (...) {
                         }
                         uint64_t ui = j.template get<uint64_t>();
-                        return to(static_cast<uint64_t>(ui));
+                        return jsonata::backend<to>::create(static_cast<uint64_t>(ui));
                     }
-                    if (j.is_number_unsigned())
-                        return to(j.template get<uint64_t>());
-                    if (j.is_number_float())
-                        return to(j.template get<double>());
-                    if (j.is_string())
-                        return to(j.template get<std::string>());
-                    if (j.is_array()) {
-                        to arr = to::array();
-                        jsonata::backend::copy( j, arr, [&convert]( const from& el ) {
+                    if (j.isUnsignedInteger())
+                        return jsonata::backend<to>::create(j.template get<uint64_t>());
+                    if (j.isFloat())
+                        return jsonata::backend<to>::create(j.template get<double>());
+                    if (j.isString())
+                        return jsonata::backend<to>::create(j.template get<std::string>());
+                    if (j.isArray()) {
+                        auto arr = jsonata::backend<to>::array();
+                        jsonata::copy( j, arr, [&convert]( const from& el ) {
                             return convert(el );
                         });
                         return arr;
                     }
-                    if (j.is_object()) {
-                        to obj = to::object();
-                        jsonata::backend::copy( j, obj, [&convert]( const from& el ) {
+                    if (j.isObject()) {
+                        auto obj = jsonata::backend<to>::object();
+                        jsonata::copy( j, obj, [&convert]( const from& el ) {
                             return convert(el );
                         });
                         return obj;
                     }
-                    return to();
+                    return jsonata::backend<to>::create();
                 };
 
                 return convert(oj);
             }
 
-            // static std::any toAny(const jsonata::backend::ordered_json &j);
-            // static jsonata::backend::ordered_json fromAny(const std::any &value);
-            // // Unordered variants using jsonata::backend::json (key order may not be preserved)
-            // static std::any jsonToAny(const jsonata::backend::json &j);
-            // static jsonata::backend::json anyToJson(const std::any &value);
+            // static std::any toAny(const jsonata::ordered_json &j);
+            // static jsonata::ordered_json fromAny(const std::any &value);
+            // // Unordered variants using jsonata::json (key order may not be preserved)
+            // static std::any jsonToAny(const jsonata::json &j);
+            // static jsonata::json anyToJson(const std::any &value);
 
             // Error code mappings
             void initializeErrorCodes();
diff --git a/include/jsonata/backend.h b/include/jsonata/backend.h
new file mode 100644
index 0000000..ee428a7
--- /dev/null
+++ b/include/jsonata/backend.h
@@ -0,0 +1,517 @@
+#pragma once
+
+#include "jsonata/common_backend.h"
+#include <string>
+#include <type_traits>
+#include <optional>
+// test for existence of methods
+struct Anything
+{
+        // Implicit conversion to absolutely anything
+        template<typename T>
+        operator T() const;
+        // This allows the mock to stay 'active' when passed by reference
+        template<typename T>
+        operator T &() const;
+
+        // Also handle const references just in case
+        template<typename T>
+        operator const T &() const;
+};
+
+template<typename T>
+concept isBasicallyReadCompatible = requires(const T &ConstObj) {
+    json_bridge<T>::forAll(ConstObj, [](const std::string &, auto &) {});
+    json_bridge<T>::array();
+    json_bridge<T>::object();
+    json_bridge<T>::at(ConstObj, 1);
+    json_bridge<T>::dump(ConstObj);
+    json_bridge<T>::parse(std::string());
+    { json_bridge<T>::size(ConstObj) } -> std::same_as<size_t>;
+    { json_bridge<T>::isEmpty(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isObject(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isArray(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::contains(ConstObj, std::string()) } -> std::same_as<bool>;
+    { json_bridge<T>::isNull(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isBool(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isString(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isNumber(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isInteger(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isUnsignedInteger(ConstObj) } -> std::same_as<bool>;
+    { json_bridge<T>::isFloat(ConstObj) } -> std::same_as<bool>;
+    requires requires(Anything &property) {
+        { json_bridge<T>::getPropertyValueOfType(ConstObj, std::string(), property) } -> std::same_as<bool>;
+    };
+    { json_bridge<T>::template get<Anything>(ConstObj) } -> std::same_as<Anything>;
+};
+
+template<typename T>
+concept isBasicallyWriteCompatible = isBasicallyReadCompatible<T> && requires(T &Obj ) {
+    json_bridge<T>::mutateForAll(Obj, [](const std::string &, auto &) {});
+    json_bridge<T>::appendValue(Obj, std::string(), Anything{} );
+    json_bridge<T>::set(Obj, std::string(), Anything{});
+    json_bridge<T>::pushBack(Obj, Anything{} );
+    { json_bridge<T>::create(std::string()) } -> std::same_as<T>;
+    { json_bridge<T>::create(1) } -> std::same_as<T>;
+    { json_bridge<T>::create(nullptr) } -> std::same_as<T>;
+    { json_bridge<T>::create() } -> std::same_as<T>;
+};
+
+// test for proper signalture of methods
+template<typename T>
+concept isReadCompatible = isBasicallyReadCompatible<T> && requires(const T &ConstObj) {
+    requires requires(std::string s, T &innerVal) {
+        json_bridge<T>::forAll(ConstObj, [](const std::string & key, auto & value) {
+            // This is the CRITICAL part:
+            // We force a compile-time check on the nested value
+            static_assert(isBasicallyWriteCompatible<std::remove_reference_t<decltype(value)>>);
+        });
+    };
+    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::parse(std::string()))>>;
+    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::at(ConstObj, std::string()))>>;
+    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::at(ConstObj, 1))>>;
+    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::array())>>;
+    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::object())>>;
+
+    // To check recursive compatibility without crashing the compiler:
+    requires requires {
+        typename json_bridge<T>::is_json_bridge_type; // A simple tag
+    };
+};
+
+// test for proper signalture of methods
+template<typename T>
+concept isCompatible = isReadCompatible<T> &&
+                       isBasicallyWriteCompatible<T> && requires(T & Obj ) {
+    requires requires(std::string s, T &innerVal) {
+        json_bridge<T>::mutateForAll(Obj, [](const std::string & key, auto & value) {
+            // This is the CRITICAL part:
+            // We force a compile-time check on the nested value
+            static_assert(isBasicallyWriteCompatible<std::remove_reference_t<decltype(value)>>);
+        });
+    };
+};
+
+namespace jsonata
+{
+    template<typename T>
+    struct backend;
+}
+
+// test to see of type T is of the form backend<X>
+template<typename T>
+struct extractBackendType {
+        using type = void;
+        static constexpr bool isBackend = false;
+};
+
+// Specialization for your backend
+template<typename X>
+struct extractBackendType<jsonata::backend<X>> {
+        using type = std::remove_cvref_t<X>;
+        static constexpr bool isBackend = true;
+};
+
+// test to see if T is of form backend<X> with isReadCompatible<X> (i.e X is const)
+template<typename T>
+concept isReadCompatibleBackend = [] {
+    using Extract = extractBackendType<std::remove_cvref_t<T>>;
+    if constexpr (Extract::isBackend) {
+        // Check if the inner type X is compatible
+        return isReadCompatible<typename Extract::type>;
+    }
+    return false;
+}();
+
+// test to see if T is of form backend<X> with isCompatible<X>
+template<typename T>
+concept isCompatibleBackend = [] {
+    using Extract = extractBackendType<std::remove_cvref_t<T>>;
+    if constexpr (Extract::isBackend) {
+        // Check if the inner type X is compatible
+        return isCompatible<typename Extract::type>;
+    }
+    return false;
+}();
+
+namespace jsonata
+{
+    template<typename T>
+    struct backend
+    {
+
+            // Use the base type for bridge lookups
+            using BaseT = std::remove_cvref_t<T>;
+
+            // Use a conditional concept check
+            static constexpr bool mutatable_T = isCompatible<BaseT> && !std::is_const_v<T>;
+            static constexpr bool compatible_T = isReadCompatible<BaseT>;
+
+            backend() : val(nullptr) {}
+            backend(std::nullptr_t) : val(nullptr) {}
+
+            backend(const backend&) = default;
+            backend(backend&&) noexcept = default;
+
+            template<typename U>
+            // Ensure U is compatible with T to avoid greedy matching
+                requires std::is_convertible_v<std::remove_reference_t<U>*, T*>
+            explicit backend(U&& v) noexcept : val(&v) {}
+
+            template<typename U>
+            // Ensure U is compatible with T to avoid greedy matching
+                requires isCompatibleBackend<U>
+            explicit backend(U& v) noexcept : val(v.val) {}
+
+            template<typename U>
+                requires (!std::is_convertible_v<std::remove_reference_t<U>*, T*>)
+            backend(U&& value) {
+                std::optional<T> owned; // To handle temporaries like 'create' results
+                // Use the bridge to turn the literal into a real JSON object
+                owned.emplace(json_bridge<BaseT>::create(std::forward<U>(value)));
+                val = &(*owned);
+            }
+
+            operator T&() { return *val; }
+            operator const T&() const { return *val; }
+
+            // to unwrap explicitely
+            template<typename Self>
+            auto&& operator*(this Self&& self) {
+                return *self.val;
+            }
+
+            static auto create( auto && value ) {
+                return wrap(json_bridge<BaseT>::create(std::forward<decltype(value)>(value)));
+            }
+
+            static auto create() {
+                return wrap(json_bridge<BaseT>::create());
+            }
+
+            backend<T> & operator=( backend<T> && other ) {
+                val = other.val;
+                other.val = nullptr;
+                return *this;
+            }
+
+            backend<T> & operator=( const backend<T> & other ) {
+                val = other.val;
+                return *this;
+            }
+
+            bool isEmpty() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isEmpty(*val);
+            }
+
+            bool isObject() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isObject(*val);
+            }
+
+            size_t size() const requires compatible_T
+            {
+                return json_bridge<BaseT>::size(*val);
+            }
+
+            bool isArray() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isArray(*val);
+            }
+
+            bool contains(const std::string &k) const requires compatible_T
+            {
+                return json_bridge<BaseT>::contains(*val, k);
+            }
+
+            bool isString() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isString(*val);
+            }
+
+            bool isNull() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isNull(*val);
+            }
+
+            bool isBool() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isBool(*val);
+            }
+
+            bool isNumber() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isNumber(*val);
+            }
+
+            bool isInteger() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isInteger(*val);
+            }
+
+            bool isFloat() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isFloat(*val);
+            }
+
+            bool isUnsignedInteger() const requires compatible_T
+            {
+                return json_bridge<BaseT>::isUnsignedInteger(*val);
+            }
+
+            // Transparently forward the size call to your static bridge
+            auto at(auto key) requires compatible_T {
+                return wrap(json_bridge<BaseT>::at(*val, key));
+            }
+
+            auto operator[](const std::string &k) const requires compatible_T
+            {
+                return wrap(json_bridge<BaseT>::at(*val, k));
+            }
+
+            auto operator[](int k) const requires compatible_T
+            {
+                return wrap(json_bridge<BaseT>::at(*val, k));
+            }
+
+            template<typename outType>
+            outType get() const requires compatible_T
+            {
+                return json_bridge<BaseT>::template get<outType>(*val);
+            }
+
+            static auto parse(const std::string &s) requires compatible_T
+            {
+                return wrap(json_bridge<BaseT>::parse(s));
+            }
+
+            // apply action to all items in any type of collection allow mutation of value
+            void mutateForAll(auto action) requires mutatable_T
+            {
+                json_bridge<BaseT>::mutateForAll(*val, action);
+            }
+
+            // apply action to all items in any type of collection
+            void forAll(auto action) const requires compatible_T
+            {
+                json_bridge<BaseT>::forAll(*val, action);
+            }
+
+            void set(const auto &key, auto value) requires mutatable_T
+            {
+                json_bridge<BaseT>::set(*val, key, value);
+            }
+
+            std::string dump() const requires compatible_T
+            {
+                return json_bridge<BaseT>::dump(*val);
+            }
+
+            bool getPropertyValueOfType(const std::string &propertyName,
+                                        auto &propertyValue) const requires compatible_T
+            {
+                using PType = std::decay_t<decltype(propertyValue)>;
+                return json_bridge<BaseT>::template getPropertyValueOfType<PType>(*val, propertyName, propertyValue);
+            }
+
+            void push_back( auto value ) requires mutatable_T {
+                return json_bridge<BaseT>::pushBack( *val, value);
+            }
+
+            void appendValue( const std::string & K, auto value ) requires mutatable_T {
+                return json_bridge<BaseT>::appendValue( *val, K, value);
+            }
+
+            static auto array() requires compatible_T {
+                return wrap(json_bridge<BaseT>::array() );
+            }
+
+            static auto object() requires compatible_T {
+                return wrap(json_bridge<BaseT>::object() );
+            }
+
+            static auto array(std::initializer_list<backend<T>> args);
+
+            static auto object(std::initializer_list<std::pair<std::string, backend<T>>> args);
+
+            // This allows: if (myJson != nullptr)
+            bool operator!=(std::nullptr_t) const
+            {
+                return !isNull();
+            }
+
+            bool operator==(std::nullptr_t) const
+            {
+                return isNull();
+            }
+        private :
+
+            T * val;
+
+            // Helper to wrap the result of doAt
+            static auto wrap(auto&& result) {
+                // We use remove_cvref_t to get the base type for the template
+                using RawType = std::remove_cvref_t<decltype(result)>;
+                // C++23 way to ensure we preserve the 'const' and 'reference' nature
+                // of the result exactly as it came out of the bridge
+                return backend<std::remove_reference_t<RawType>>(std::forward<decltype(result)>(result));            }
+    };
+
+    // Deduction guide to make it easy to use
+    template<typename T>
+    backend(T &) -> backend<T>;
+
+    template<typename T>
+    backend(T*) -> backend<T>;
+
+    template<typename T>
+    concept isPairLike = requires(T t) {
+        typename T::first_type;
+        typename T::second_type;
+        t.first;
+        t.second;
+    };
+
+    template<typename Container>
+    concept isMappedContainer = requires {
+        typename std::remove_cvref_t<Container>::value_type;
+    } && isPairLike<typename std::remove_cvref_t<Container>::value_type>;
+
+    template<typename List>
+    concept isListContainer = !isMappedContainer<List>;
+
+    // apply action to all items in any type of collection
+    static void forAll(const auto &from, auto action)
+    {
+        using fromCollection = std::decay_t<decltype(from)>;
+        using actionType = std::decay_t<decltype(action)>;
+
+        if constexpr ( isReadCompatible<fromCollection> ) {
+            jsonata::backend(from).forAll( action );
+        } else if constexpr ( isReadCompatibleBackend<fromCollection> ) {
+            from.forAll( action );
+        } else if constexpr ( isMappedContainer<fromCollection> ) {
+            for (const auto &[k, v] : from) {
+                action(k, v);
+            }
+        } else if constexpr ( isListContainer<fromCollection>) {
+            int idx = 0;
+            for (const auto &el : from) {
+                action(std::to_string(idx++), el);
+            }
+        } else {
+            // This triggers ONLY if none of the above branches are taken
+            static_assert(sizeof(fromCollection) == 0, "Unsupported outCollection type.");
+        }
+    }
+
+    static void copy(const auto &from, auto &out)
+    {
+
+        forAll(from, [&out](auto k, auto v) {
+            using outType = std::decay_t<decltype(out)>;
+            using VType = std::decay_t<decltype(v)>;
+            using KType = std::decay_t<decltype(k)>;
+
+            if constexpr (isCompatible<outType>) {
+                backend(out).appendValue(k, v);
+            } else if constexpr (isCompatibleBackend<outType>) {
+                out.appendValue(k, v);
+            } else if constexpr (isMappedContainer<outType> ) {
+                out[k] = v;
+            } else if constexpr (isListContainer<outType> ) {
+                out.push_back(v);
+            } else {
+                // This triggers ONLY if none of the above branches are taken
+                static_assert(sizeof(outType) == 0,
+                              "Unsupported outCollection type: Must be initializer, Qt "
+                              "JSON, "
+                              "nlohmann JSON, a "
+                              "Map, or must "
+                              "support "
+                              "push"
+                              "_bac"
+                              "k.");
+            }
+        });
+    }
+
+    static void copy(const auto &from, auto &out, auto convert)
+    {
+        using outType = std::decay_t<decltype(out)>;
+
+        forAll(from, [&out, convert](const std::string &k, auto v) {
+            auto cv = convert(v);
+            using VType = std::decay_t<decltype(cv)>;
+            using KType = std::decay_t<decltype(k)>;
+
+            if constexpr (isCompatible<outType>) {
+                backend(out).appendValue(k, cv);
+            } else if constexpr (isCompatibleBackend<outType>) {
+                out.appendValue(k, cv);
+            } else if constexpr ( isMappedContainer<outType> ) {
+                out[k] = convert(v);
+            } else if constexpr (isListContainer<outType> ) {
+                out.push_back(convert(v));
+            } else {
+                // This triggers ONLY if none of the above branches are taken
+                static_assert(sizeof(outType) == 0,
+                              "Unsupported outCollection type: Must be Qt JSON, nlohmann "
+                              "JSON, "
+                              "a Map, or must "
+                              "support "
+                              "push_back.");
+            }
+        });
+    }
+
+    template<typename T>
+    auto backend<T>::array(std::initializer_list<backend<T>> args)
+    {
+        auto a = array();
+        copy(args, *a);
+        return a;
+    }
+
+    template<typename T>
+    auto backend<T>::object(std::initializer_list<std::pair<std::string, backend<T>>> args)
+    {
+        auto o = object();
+        copy(args, *o);
+        return o;
+    }
+} // namespace jsonata
+
+#include "nlohmann_backend.h"
+#include "qtjson_backend.h"
+#include "qtvariant_backend.h"
+
+
+// ordered_json ordered_json::array(std::initializer_list<ordered_json> args)
+// {
+//     ordered_json a = ordered_json::array();
+//     copy(args, a, [](const ordered_json &j) -> QJsonValue { return j; });
+//     return a;
+// }
+
+// ordered_json ordered_json::object(std::initializer_list<std::pair<std::string, ordered_json>> args)
+// {
+//     ordered_json o = ordered_json::object();
+//     copy(args, o, [](const ordered_json &j) { return j; });
+//     return o;
+// }
+
+// json json::array(std::initializer_list<json> args)
+// {
+//     json a = json::array();
+//     copy(args, a, [](const json &j) -> QJsonValue { return j; });
+//     return a;
+// }
+
+// json json::object(std::initializer_list<std::pair<std::string, json>> args)
+// {
+//     json o = json::object();
+//     copy(args, o, [](const json &j) { return j; });
+//     return o;
+// }
diff --git a/include/jsonata/common_backend.h b/include/jsonata/common_backend.h
new file mode 100644
index 0000000..ccafeca
--- /dev/null
+++ b/include/jsonata/common_backend.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <type_traits>
+#include <vector>
+
+// for jlIST
+template<typename T>
+struct is_vector : std::false_type
+{};
+
+template<typename T, typename A>
+struct is_vector<std::vector<T, A>> : std::true_type
+{};
+
+template<typename T>
+concept isStdVector = is_vector<T>::value;
+
+// This is the "Contract" class which we will specify based on actual json classes (see qjson_backend e.a.)
+template<typename T>
+struct json_bridge {
+        // We leave this empty.
+        // Specializations will provide the actual logic.
+};
+
diff --git a/include/jsonata/nlohmann_backend.h b/include/jsonata/nlohmann_backend.h
new file mode 100644
index 0000000..d229d32
--- /dev/null
+++ b/include/jsonata/nlohmann_backend.h
@@ -0,0 +1,191 @@
+#pragma once
+
+#ifdef JSONATA_NLOHMANN_ENABLED
+
+#include "JException.h"
+#include "Utils.h"
+#include "common_backend.h"
+#include <concepts>
+
+#include <nlohmann/json.hpp>
+template<typename T>
+struct is_nlohmann : std::false_type
+{};
+
+template<typename... Args>
+struct is_nlohmann<nlohmann::basic_json<Args...>> : std::true_type
+{};
+
+// Single bridge specialization
+template<typename T>
+    requires is_nlohmann<T>::value
+struct json_bridge<T>
+{
+        using is_json_bridge_type = void; // Tag to satisfy the concept
+
+        static T create(auto&& value) {
+            using V = std::remove_cvref_t<decltype(value)>;
+
+            if constexpr (std::is_same_v<V, std::nullptr_t>) {
+                return T(QJsonValue::Null);
+            } else if constexpr (std::is_constructible_v<T, V>) {
+                return T(value);
+            } else {
+                static_assert(false, "Unsupported type for nlohmann creation");
+            }
+        }
+
+        static T create() { return T(); }
+
+        static size_t size(const T &value) { return value.size(); }
+
+        static bool isEmpty(const T &value) { return value.empty(); }
+
+        static bool isObject(const T &value) { return value.is_object(); }
+
+        static bool isArray(const T &value) { return value.is_array(); }
+
+        static bool isNumber(const T &value) { return value.is_number(); }
+
+        static bool isNull(const T &value) { return value.is_null(); }
+
+        static bool isBool(const T &value) { return value.is_bool(); }
+
+        static bool isInteger(const T &value) { return value.is_number_integer(); }
+
+        static bool isFloat(const T &value) { return value.is_number_float(); }
+
+        static bool isUnsignedInteger(const T &value) { return V.is_number_unsigned(); }
+
+        static bool contains(const T &value, const std::string &k) { return value.contains(k); }
+
+        static bool isString(const T &value) { return value.is_string(); }
+
+        static nlohmann::basic_json &at(const T &value, const std::string &k) { return value[k]; }
+
+        static nlohmann::basic_json &at(const T &value, int k) { return value[k]; }
+
+        template<typename outType>
+        static outType get(const T &value)
+        {
+            return value.template get<outType>();
+        }
+
+        static outType parse(const std::string &s) { return nlohmann::parse(s); }
+
+        static Value array() { return nlohmann::array(); }
+
+        static Value object() { return nlohmann::object(); }
+
+        static void pushBack(T &val, auto value) { val.push_back(value); }
+
+        template<typename action>
+        static void mutateForAll(T &from, action a)
+        {
+            if (from.is_array()) {
+                int idx = 0;
+                for (const auto &el : from) {
+                    a(std::to_string(idx++), el);
+                }
+            } else {
+                for (const auto &[k, v] : from) {
+                    a(k, v);
+                }
+            }
+            return;
+        }
+
+        template<typename action>
+        static void doForAll(const T &from, action a)
+        {
+            using fromType = std::decay_t<decltype(from)>;
+            if constexpr (std::is_same_v<
+                              fromType,
+                              std::initializer_list<std::pair<std::string, nlohmann::ordered_json>>>
+                          || std::is_same_v<
+                              fromType,
+                              std::initializer_list<std::pair<std::string, nlohmann::json>>>) {
+                for (const auto &[k, v] : from) {
+                    action(k, v);
+                }
+            } else if constexpr (std::is_same_v<fromType,
+                                                std::initializer_list<nlohmann::ordered_json>>
+                                 || std::is_same_v<fromType, std::initializer_list<nlohmann::json>>) {
+                int idx = 0;
+                for (const auto &el : from) {
+                    action(std::to_string(idx++), el);
+                }
+            } else if (from.is_array()) {
+                int idx = 0;
+                for (const auto &el : from) {
+                    a(std::to_string(idx++), el);
+                }
+            } else {
+                for (const auto &[k, v] : from.items()) {
+                    a(k, v);
+                }
+            }
+        }
+
+        template<typename keyType, typename valueType>
+        static void appendValue(T &to, const keyType &k, const valueType &v)
+        {
+            if (to.is_array()) {
+                to.push_back(v);
+            } else {
+                to[k] = v;
+            }
+        }
+
+        template<typename keyType, typename valueType>
+        static void set(T &to, const keyType &k, const valueType &v)
+        {
+            to[] = v;
+        }
+
+        static std::string dump(const T &v) { return v.dump(); }
+
+        template<typename propertyType>
+        static bool getPropertyValueOfType(const T &root,
+                                    const std::string &propertyName,
+                                    propertyType &propertyValue)
+        {
+            auto convertor = [&](auto E, auto &Prop) {
+                using EType = std::decay_t<decltype(E)>; // This is the type of E
+
+                if constexpr (std::is_base_of_v<std::string, propertyType>) {
+                    // property must be string
+                    if (E.is_string()) {
+                        Prop = E.template get<std::string>();
+                        return true;
+                    }
+                } else if constexpr (std::is_same_v<propertyType, bool>) {
+                    if (E.is_boolean()) {
+                        Prop = E.template get<bool>();
+                        return true;
+                    }
+                } else if constexpr (isStdVector<propertyType>) {
+                    if (E.is_array()) {
+                        Prop = E;
+                        return true;
+                    }
+                } else if constexpr (IsNlohmann<propertyType>) {
+                    Prop = E;
+                    return true;
+                } else {
+                    // This triggers ONLY if none of the above branches are taken
+                    static_assert(sizeof(propertyType) == 0, "cannot get unknown propertytype");
+                }
+
+                return false;
+            };
+
+            auto overrideIt = root.find(propertyName);
+            return (overrideIt != root.end()) ? convertor((*overrideIt), propertyValue) : false;
+        }
+};
+
+#else
+template<typename T>
+concept IsNlohmann = false;
+#endif
diff --git a/include/jsonata/qtjson_backend.h b/include/jsonata/qtjson_backend.h
new file mode 100644
index 0000000..9d16e17
--- /dev/null
+++ b/include/jsonata/qtjson_backend.h
@@ -0,0 +1,732 @@
+#pragma once
+
+#ifdef JSONATA_QTJSON_ENABLED
+
+#include "JException.h"
+#include "Utils.h"
+#include <concepts>
+
+#include "common_backend.h"
+
+// #include <array>
+// #include <any>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QMap>
+#include <QRegularExpression>
+
+template<typename T>
+concept IsQtJson = std::is_base_of_v<QJsonValue, T> || std::is_base_of_v<QJsonArray, T>
+                   || std::is_base_of_v<QJsonObject, T> || std::is_base_of_v<QJsonValueRef, T>;
+
+template<>
+struct json_bridge<QJsonValue>
+{
+        using is_json_bridge_type = void; // Tag to satisfy the concept
+
+        // Factory method to unify constructors
+
+        //         ordered_json(const QJsonValueRef &r)
+        //             : QJsonValue(r)
+        //         {}
+
+        static QJsonValue create(auto &&value)
+        {
+            using V = std::remove_cvref_t<decltype(value)>;
+
+            if constexpr (std::is_same_v<V, std::nullptr_t>) {
+                return QJsonValue(QJsonValue::Null);
+            } else if constexpr (std::is_same_v<V, std::string> || std::is_same_v<V, const char *>) {
+                // Handle both std::string and literal "strings"
+                if constexpr (std::is_same_v<V, const char *>)
+                    return QJsonValue(QString(value));
+                else
+                    return QJsonValue(QString::fromStdString(value));
+            } else if constexpr (std::is_integral_v<V> && !std::is_same_v<V, bool>) {
+                // Handle all integers (int, long, long long, size_t, etc.)
+                // qlonglong is the safest sink for integral types in Qt
+                return QJsonValue(static_cast<qlonglong>(value));
+            }
+            // Handle floating point
+            else if constexpr (std::is_floating_point_v<V>) {
+                return QJsonValue(static_cast<double>(value));
+            } else if constexpr (std::is_constructible_v<QJsonValue, V>) {
+                return QJsonValue(value);
+            } else {
+                static_assert(false, "Unsupported type for QJsonValue creation");
+            }
+        }
+
+        static QJsonValue create() { return QJsonValue(); }
+
+        static size_t size(const QJsonValue &value)
+        {
+            return value.isArray() ? 0 : value.toArray().count();
+        }
+
+        static bool isEmpty(const QJsonValue &value) {
+            return value.isNull() ||
+                   (value.isObject() && value.toObject().empty()) ||
+                   (value.isArray() && value.toArray().empty());
+        }
+
+        static bool isObject(const QJsonValue &value) { return value.isObject(); }
+
+        static bool isArray(const QJsonValue &value) { return value.isArray(); }
+
+        static bool isNumber(const QJsonValue &value) { return value.isDouble(); }
+
+        static bool isInteger(const QJsonValue &value)
+        {
+            return value.isDouble() && value.toVariant().typeId() == QMetaType::LongLong;
+        }
+
+        static bool isNull(const QJsonValue &value) { return value.isNull(); }
+
+        static bool isBool(const QJsonValue &value) { return value.isBool(); }
+
+        static bool isFloat(const QJsonValue &value)
+        {
+            return value.isDouble() && value.toVariant().typeId() == QMetaType::Double;
+        }
+
+        static bool isUnsignedInteger(const QJsonValue &value)
+        {
+            if (!value.isDouble()) {
+                return false;
+            }
+            QVariant V = value.toVariant();
+            return V.typeId() == QMetaType::LongLong && V.toLongLong() >= 0;
+        }
+
+        static bool contains(const QJsonValue &value, const std::string &k)
+        {
+            return value.isObject() && value.toObject().contains(QString::fromStdString(k));
+        }
+
+        static bool isString(const QJsonValue &value) { return value.isString(); }
+
+        static QJsonValue at(const QJsonValue &value, const std::string &k)
+        {
+            if (!value.isObject()) {
+                throw jsonata::JException("Value is not an object");
+            }
+            return value.toObject()[QString::fromStdString(k)];
+        }
+
+        static QJsonValue at(const QJsonValue &value, int k)
+        {
+            if (!value.isArray()) {
+                throw jsonata::JException("Value is not an array");
+            }
+            return value.toArray()[k];
+        }
+
+        template<typename outType>
+        static outType get(const QJsonValue &value)
+        {
+            return value.toVariant().template value<outType>();
+        }
+
+        template<>
+        std::string get(const QJsonValue &value)
+        {
+            return get<QString>(value).toStdString();
+        }
+
+        static QJsonValue array() { return QJsonArray(); }
+
+        static QJsonValue object() { return QJsonObject(); }
+
+        static void pushBack(QJsonValue &val, auto value)
+        {
+            QJsonArray a = val.toArray();
+            a.push_back(value);
+            val = a;
+        }
+
+        template<typename action>
+        static void mutateForAll(QJsonValue &from, action a)
+        {
+            using fromType = std::decay_t<decltype(from)>;
+            /*            if constexpr (std::is_same_v<fromType,
+                                         std::initializer_list<std::pair<std::string, QJsonValue>>>) {
+                for (const auto &[k, v] : from) {
+                    action(k, v);
+                }
+            } else if constexpr (std::is_same_v<fromType, std::initializer_list<QJsonValue>>) {
+                int idx = 0;
+                for (const auto &el : from) {
+                    action(std::to_string(idx++), el);
+                }
+            } else */
+            if (from.isArray()) {
+                int idx = 0;
+                bool changed = false;
+                QJsonArray arr = from.toArray();
+                for (auto el : arr) {
+                    if (a(std::to_string(idx++), el)) {
+                        arr[idx - 1] = el;
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    from = arr;
+                }
+            } else if (from.isObject()) {
+                bool changed = false;
+                QJsonObject obj = from.toObject();
+                for (auto [key, value] : obj.asKeyValueRange()) {
+                    QJsonValue J(value);
+                    if (a(key.toString().toStdString(), J)) {
+                        value = J;
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    from = obj;
+                }
+            }
+        }
+
+        template<typename action>
+        static void forAll(const QJsonValue &from, action a)
+        {
+            if (from.isArray()) {
+                int idx = 0;
+                for (const auto &el : from.toArray()) {
+                    a(std::to_string(idx++), QJsonValue(el));
+                }
+            } else if (from.isObject()) {
+                QJsonObject obj = from.toObject();
+                for (auto [key, value] : obj.asKeyValueRange()) {
+                    a(key.toString().toStdString(), QJsonValue(value));
+                }
+            }
+        }
+
+        template<typename keyType, typename valueType>
+        static void appendValue(QJsonValue &to, const keyType &k, const valueType &v)
+        {
+            if (to.isArray()) {
+                auto x = to.toArray();
+                if constexpr (std::is_convertible_v<valueType, std::string>) {
+                    x.push_back(QString::fromStdString(v));
+                } else if constexpr (!std::is_convertible_v<valueType, std::string>) {
+                    x.push_back(v);
+                }
+                to = x;
+            } else {
+                auto x = to.toObject();
+                if constexpr (std::is_convertible_v<valueType, std::string>) {
+                    x[QString::fromStdString(k)] = QString::fromStdString(v);
+                } else if constexpr (!std::is_convertible_v<valueType, std::string>) {
+                    x[QString::fromStdString(k)] = v;
+                }
+                to = x;
+            }
+        }
+
+        template<typename keyType, typename valueType>
+        static void set(QJsonValue &to, const keyType &k, const valueType &v)
+        {
+            if constexpr (std::is_same_v<keyType, QString>) {
+                auto x = to.toObject();
+                if constexpr (std::is_convertible_v<valueType, std::string>) {
+                    x[k] = QString::fromStdString(v);
+                } else {
+                    x[k] = v;
+                }
+                to = x;
+            } else if constexpr (std::is_convertible_v<keyType, std::string>) {
+                auto x = to.toObject();
+                if constexpr (std::is_convertible_v<valueType, std::string>) {
+                    x[QString::fromStdString(k)] = QString::fromStdString(v);
+                } else {
+                    x[QString::fromStdString(k)] = v;
+                }
+                to = x;
+            } else if constexpr (std::is_convertible_v<keyType, int>) {
+                auto x = to.toArray();
+                if constexpr (std::is_convertible_v<valueType, std::string>) {
+                    x[k] = QString::fromStdString(v);
+                } else {
+                    x[k] = v;
+                }
+                to = x;
+            }
+        }
+
+        static std::string dump(const QJsonValue &v)
+        {
+            return QString::fromUtf8(QJsonValue(v).toJson()).toStdString();
+        }
+
+        static QJsonValue parse(const std::string &s)
+        {
+            auto decodeUtfChars = [](const std::string &stdStr) -> QString {
+                QString str = QString::fromStdString(stdStr);
+
+                // Regex to find \u followed by 4 hex digits
+                static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
+
+                QRegularExpressionMatchIterator i = re.globalMatch(str);
+                int offset = 0;
+
+                while (i.hasNext()) {
+                    QRegularExpressionMatch match = i.next();
+
+                    // Get the 4 hex digits (e.g., "D800")
+                    bool ok;
+                    ushort code = match.captured(1).toUShort(&ok, 16);
+
+                    if (ok) {
+                        // Convert hex to a single UTF-16 character (even if it's a lone surrogate)
+                        QString replacement = QChar(code);
+
+                        // Replace the "\uD800" text with the actual character
+                        str.replace(match.capturedStart() + offset,
+                                    match.capturedLength(),
+                                    replacement);
+
+                        // Adjust offset because we replaced 6 chars ("\uD800") with 1 char
+                        offset += (replacement.length() - match.capturedLength());
+                    }
+                }
+                return str;
+            };
+
+            auto isValidUtf = [](const QString &str) -> bool {
+                for (int i = 0; i < str.length(); ++i) {
+                    if (str[i].isHighSurrogate()) {
+                        // Must be followed by a low surrogate
+                        if (i + 1 >= str.length() || !str[i + 1].isLowSurrogate()) {
+                            return false; // Error: Unpaired high surrogate
+                        }
+                        i++; // Skip the low surrogate as we've validated the pair
+                    } else if (str[i].isLowSurrogate()) {
+                        // If we hit a low surrogate here, it means it wasn't
+                        // preceded by a high surrogate (which would have triggered the 'if' above)
+                        return false; // Error: Orphaned low surrogate
+                    }
+                }
+                return true;
+            };
+
+            QJsonParseError Err;
+            QString S = decodeUtfChars(s);
+            if (!isValidUtf(S)) {
+                throw jsonata::JException("D3141", 0);
+            }
+
+            auto r = QJsonValue::fromJson(s.data(), &Err);
+            if (Err.error != QJsonParseError::NoError) {
+                throw jsonata::JException("D3141", Err.offset, Err.errorString().data());
+            }
+            return r;
+        }
+
+        template<typename propertyType>
+        static bool getPropertyValueOfType(const QJsonValue &root,
+                                           const std::string &propertyName,
+                                           propertyType &propertyValue)
+        {
+            auto convertor = [&](auto E, auto &Prop) {
+                using EType = std::decay_t<decltype(E)>; // This is the type of E
+                if constexpr (std::is_base_of_v<std::string, propertyType>) {
+                    // property must be string
+                    if (E.isString()) {
+                        Prop = E.toString().toStdString();
+                        return true;
+                    }
+                } else if constexpr (std::is_same_v<propertyType, bool>) {
+                    if (E.isBool()) {
+                        Prop = E.toBool();
+                        return true;
+                    }
+                } else if constexpr (isStdVector<propertyType>) {
+                    if (E.isArray()) {
+                        Prop = E.toArray();
+                        return true;
+                    }
+                } else if constexpr (IsQtJson<propertyType>) {
+                    Prop = E;
+                    return true;
+                } else {
+                    // This triggers ONLY if none of the above branches are taken
+                    static_assert(sizeof(propertyType) == 0, "cannot get unknown propertytype");
+                }
+
+                return false;
+            };
+
+            QJsonObject obj = root.toObject();
+            QJsonValue val = obj.value(QString::fromStdString(propertyName));
+            return (!val.isUndefined()) ? convertor(val, propertyValue) : false;
+        }
+};
+#else
+template<typename T>
+concept IsQtJson = false;
+#endif
+
+// template<typename T>
+// concept hasFind = requires(T t, std::string s) {
+//     {
+//         t.find(s)
+//     } -> std::same_as<bool>;
+// };
+
+// template<typename k, typename v>
+// using ordered_map = std::map<k, v>;
+
+// class ordered_json : public QJsonValue
+// {
+//     public:
+//         ordered_json(std::nullptr_t)
+//             : QJsonValue(QJsonValue::Null)
+//         {}
+//         ordered_json()
+//             : QJsonValue()
+//         {}
+//         template<typename T>
+//             requires std::is_constructible_v<QJsonValue, T>
+//         ordered_json(T b)
+//             : QJsonValue(b)
+//         {}
+
+//         // You still need to explicitly handle types Qt doesn't know, like std::string
+//         ordered_json(const std::string &s)
+//             : QJsonValue(QString::fromStdString(s))
+//         {}
+//         // will loose precision
+//         ordered_json(uint64_t v)
+//             : QJsonValue(int64_t(v))
+//         {}
+//         ordered_json(const QJsonValueRef &r)
+//             : QJsonValue(r)
+//         {}
+
+//         static inline ordered_json array() { return QJsonArray(); }
+
+//         static inline ordered_json object() { return QJsonObject(); }
+
+//         static inline ordered_json array(std::initializer_list<ordered_json> args);
+//         static inline ordered_json object(
+//             std::initializer_list<std::pair<std::string, ordered_json>> args);
+
+//         template<typename T>
+//         void push_back(const T &v)
+//         {
+//         }
+
+//         inline bool is_null() const { return isNull(); }
+//         inline bool is_boolean() const { return isBool(); }
+//         inline bool is_string() const { return isString(); }
+//         inline bool is_array() const { return isArray(); }
+//         inline size_t size() const { return toArray().count(); }
+//         inline bool is_object() const { return isObject(); }
+//         inline bool is_number() const { return isDouble(); }
+//         inline bool is_number_integer() const
+//         {
+//             return isDouble() && toVariant().typeId() == QMetaType::LongLong;
+//         }
+//         inline bool is_number_float() const
+//         {
+//             return isDouble() && toVariant().typeId() == QMetaType::Double;
+//         }
+//         inline bool is_number_unsigned() const
+//         {
+//             if (!isDouble()) {
+//                 return false;
+//             }
+//             QVariant V = toVariant();
+//             return toVariant().typeId() == QMetaType::LongLong && V.toLongLong() >= 0;
+//         }
+//         template<typename T>
+//         T get() const
+//         {
+//             return toVariant().value<T>();
+//         }
+
+//         template<>
+//         std::string get() const
+//         {
+//             return get<QString>().toStdString();
+//         }
+
+//         bool contains(const char *v) const { return isObject() && toObject().contains(v); }
+
+//         // Template wrapper for all operator[] overloads
+//         template<typename T>
+//         const ordered_json operator[](const T &keyOrIndex) const
+//         {
+//             return ordered_json(QJsonValue::operator[](keyOrIndex));
+//         }
+
+//         const ordered_json operator[](const std::string &keyOrIndex) const
+//         {
+//             return ordered_json(QJsonValue::operator[](QString::fromStdString(keyOrIndex)));
+//         }
+
+// #include <string>
+
+//         std::string dump() const
+//         {
+//             return QJsonValue::toJson(QJsonDocument::Compact).toStdString();
+//         }
+
+//         bool empty() const
+//         {
+//             return isNull() || (isObject() && toObject().empty())
+//                    || (isArray() && toArray().empty());
+//         }
+
+//         // This allows: if (myJson != nullptr)
+//         bool operator!=(std::nullptr_t) const { return !isNull(); }
+
+//         bool operator==(std::nullptr_t) const { return isNull(); }
+// };
+
+// class json : public QJsonValue
+// {
+//     public:
+//         json()
+//             : QJsonValue()
+//         {}
+//         json(std::nullptr_t)
+//             : QJsonValue()
+//         {}
+//         template<typename T>
+//             requires std::is_constructible_v<QJsonValue, T>
+//                      && (!std::is_integral_v<T> || std::is_same_v<T, bool>)
+//         json(T b)
+//             : QJsonValue(b)
+//         {}
+
+//         // You still need to explicitly handle types Qt doesn't know, like std::string
+//         // will loose precision
+//         json(long v)
+//             : QJsonValue(qint64(v))
+//         {}
+//         json(long long v)
+//             : QJsonValue(qint64(v))
+//         {}
+//         json(uint64_t v)
+//             : QJsonValue(qint64(v))
+//         {}
+//         json(int v)
+//             : QJsonValue(qint64(v))
+//         {}
+//         json(const std::string &s)
+//             : QJsonValue(QString::fromStdString(s))
+//         {}
+//         json(const QJsonValueRef &r)
+//             : QJsonValue(r)
+//         {}
+
+//         static json array() { return QJsonArray(); }
+
+//         static json object() { return QJsonObject(); }
+
+//         static inline json array(std::initializer_list<json> args);
+//         static inline json object(std::initializer_list<std::pair<std::string, json>> args);
+
+//         template<typename T>
+//         void push_back(const T &v)
+//         {
+//             toArray().push_back(v);
+//         }
+
+//         inline bool is_null() const { return isNull(); }
+//         inline bool is_boolean() const { return isBool(); }
+//         inline bool is_string() const { return isString(); }
+//         inline bool is_array() const { return isArray(); }
+//         inline size_t size() const { return toArray().count(); }
+//         inline bool is_object() const { return isObject(); }
+//         inline bool is_number() const { return isDouble(); }
+//         inline bool is_number_integer() const
+//         {
+//             return isDouble() && toVariant().typeId() == QMetaType::LongLong;
+//         }
+//         inline bool is_number_float() const
+//         {
+//             return isDouble() && toVariant().typeId() == QMetaType::Double;
+//         }
+//         inline bool is_number_unsigned() const
+//         {
+//             if (!isDouble()) {
+//                 return false;
+//             }
+//             QVariant V = toVariant();
+//             return toVariant().typeId() == QMetaType::LongLong && V.toLongLong() >= 0;
+//         }
+//         template<typename T>
+//         T get() const
+//         {
+//             return toVariant().value<T>();
+//         }
+//         template<>
+//         std::string get() const
+//         {
+//             return toVariant().toString().toStdString();
+//         }
+
+//         static ordered_json parse(const std::string &s)
+//         {
+//             return ordered_json(QJsonValue::fromJson(s.data()));
+//         }
+
+//         std::string dump() const { return QJsonValue::toString().toStdString(); }
+
+//         bool empty() const
+//         {
+//             return isNull() || (isObject() && toObject().empty())
+//                    || (isArray() && toArray().empty());
+//         }
+//         bool contains(const std::string &key) const
+//         {
+//             return isObject() && toObject().contains(QString::fromStdString(key));
+//         }
+// };
+
+// #endif
+
+// ordered_json ordered_json::array(std::initializer_list<ordered_json> args)
+// {
+//     ordered_json a = ordered_json::array();
+//     copy(args, a, [](const ordered_json &j) -> QJsonValue { return j; });
+//     return a;
+// }
+
+// ordered_json ordered_json::object(std::initializer_list<std::pair<std::string, ordered_json>> args)
+// {
+//     ordered_json o = ordered_json::object();
+//     copy(args, o, [](const ordered_json &j) { return j; });
+//     return o;
+// }
+
+// json json::array(std::initializer_list<json> args)
+// {
+//     json a = json::array();
+//     copy(args, a, [](const json &j) -> QJsonValue { return j; });
+//     return a;
+// }
+
+// json json::object(std::initializer_list<std::pair<std::string, json>> args)
+// {
+//     json o = json::object();
+//     copy(args, o, [](const json &j) { return j; });
+//     return o;
+// }
+
+// template<>
+// std::string get() const
+// {
+//     return get<QString>().toStdString();
+// }
+
+// bool contains(const char *v) const
+// {
+//     return isObject() && toObject().contains(v);
+// }
+
+// // Template wrapper for all operator[] overloads
+// template<typename T>
+// const ordered_json operator[](const T &keyOrIndex) const
+// {
+//     return ordered_json(QJsonValue::operator[](keyOrIndex));
+// }
+
+// const ordered_json operator[](const std::string &keyOrIndex) const
+// {
+//     return ordered_json(QJsonValue::operator[](QString::fromStdString(keyOrIndex)));
+// }
+
+// #include <string>
+
+// static QString decodeUtfChars(const std::string &stdStr)
+// {
+//     QString str = QString::fromStdString(stdStr);
+
+//     // Regex to find \u followed by 4 hex digits
+//     static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
+
+//     QRegularExpressionMatchIterator i = re.globalMatch(str);
+//     int offset = 0;
+
+//     while (i.hasNext()) {
+//         QRegularExpressionMatch match = i.next();
+
+//         // Get the 4 hex digits (e.g., "D800")
+//         bool ok;
+//         ushort code = match.captured(1).toUShort(&ok, 16);
+
+//         if (ok) {
+//             // Convert hex to a single UTF-16 character (even if it's a lone surrogate)
+//             QString replacement = QChar(code);
+
+//             // Replace the "\uD800" text with the actual character
+//             str.replace(match.capturedStart() + offset, match.capturedLength(), replacement);
+
+//             // Adjust offset because we replaced 6 chars ("\uD800") with 1 char
+//             offset += (replacement.length() - match.capturedLength());
+//         }
+//     }
+//     return str;
+// }
+
+// static bool isValidUtf(const QString &str)
+// {
+//     for (int i = 0; i < str.length(); ++i) {
+//         if (str[i].isHighSurrogate()) {
+//             // Must be followed by a low surrogate
+//             if (i + 1 >= str.length() || !str[i + 1].isLowSurrogate()) {
+//                 return false; // Error: Unpaired high surrogate
+//             }
+//             i++; // Skip the low surrogate as we've validated the pair
+//         } else if (str[i].isLowSurrogate()) {
+//             // If we hit a low surrogate here, it means it wasn't
+//             // preceded by a high surrogate (which would have triggered the 'if' above)
+//             return false; // Error: Orphaned low surrogate
+//         }
+//     }
+//     return true;
+// }
+
+// static ordered_json parse(const std::string &s)
+// {
+//     QJsonParseError Err;
+//     QString S = decodeUtfChars(s);
+//     if (!isValidUtf(S)) {
+//         throw jsonata::JException("D3141", 0);
+//     }
+
+//     auto r = ordered_json(QJsonValue::fromJson(s.data(), &Err));
+//     if (Err.error != QJsonParseError::NoError) {
+//         throw jsonata::JException("D3141", Err.offset, Err.errorString().data());
+//     }
+//     return r;
+// }
+
+// std::string dump() const
+// {
+//     return QJsonValue::toJson(QJsonDocument::Compact).toStdString();
+// }
+
+// bool empty() const
+// {
+//     return isNull() || (isObject() && toObject().empty()) || (isArray() && toArray().empty());
+// }
+
+// // This allows: if (myJson != nullptr)
+// bool operator!=(std::nullptr_t) const
+// {
+//     return !isNull();
+// }
+
+// bool operator==(std::nullptr_t) const
+// {
+//     return isNull();
+// }
diff --git a/include/jsonata/qtvariant_backend.h b/include/jsonata/qtvariant_backend.h
new file mode 100644
index 0000000..e807d21
--- /dev/null
+++ b/include/jsonata/qtvariant_backend.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#ifdef JSONATA_QTVARIANT_ENABLED
+
+#include "JException.h"
+#include "Utils.h"
+#include <concepts>
+
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QRegularExpression>
+#include <QMap>
+#include <map>
+
+template<typename T>
+concept IsQtVariant = std::is_base_of_v<QVariant, T> ||
+                   std::is_base_of_v<QVariantMap, T> ||
+                   std::is_base_of_v<QVariantList, T>;
+
+template<typename collection, typename action>
+void qtvariant_mutateForAll(collection &from, action a)
+{
+    // if (from.isArray()) {
+    //     int idx = 0;
+    //     for (const auto &el : from) {
+    //         a(std::to_string(idx++), el);
+    //     }
+    // } else {
+    //     for (const auto &[k, v] : from) {
+    //         a(k, v);
+    //     }
+    // }
+    // return;
+}
+
+#else
+template<typename T>
+concept IsQtVariant = false;
+#endif
diff --git a/src/jsonata/Functions.cpp b/src/jsonata/Functions.cpp
index cb7d641..d9f24f6 100644
--- a/src/jsonata/Functions.cpp
+++ b/src/jsonata/Functions.cpp
@@ -464,12 +464,12 @@ static bool isDeepEqualForDistinct(const std::any& lhs, const std::any& rhs) {
 
         // Compare direct map objects
         if (lhs.type() ==
-            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+            typeid(std::unordered_map<std::string, std::any>)) {
             const auto& leftMap =
-                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                std::any_cast<std::unordered_map<std::string, std::any>>(
                     lhs);
             const auto& rightMap =
-                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                std::any_cast<std::unordered_map<std::string, std::any>>(
                     rhs);
 
             if (leftMap.size() != rightMap.size()) {
@@ -846,9 +846,9 @@ bool Functions::isLambda(const std::any& value) {
 
 // Deprecated: type-check helpers moved to Utils
 
-jsonata::backend::ordered_map<std::string, Functions::FunctionEntry>
+std::unordered_map<std::string, Functions::FunctionEntry>
 Functions::getFunctionRegistry() {
-    static jsonata::backend::ordered_map<std::string, FunctionEntry>
+    static std::unordered_map<std::string, FunctionEntry>
         registryWithSignatures = {
             // Aggregation functions
             {"sum", FunctionEntry(
@@ -1259,11 +1259,11 @@ Functions::getFunctionRegistry() {
                          (args.size() >= 2 && isString(args[1]))
                              ? std::any_cast<std::string>(args[1])
                              : "";
-                     jsonata::backend::ordered_map<std::string, std::any> options;
+                     std::unordered_map<std::string, std::any> options;
                      if (args.size() >= 3) {
                          try {
                              options = std::any_cast<
-                                 jsonata::backend::ordered_map<std::string, std::any>>(
+                                 std::unordered_map<std::string, std::any>>(
                                  args[2]);
                          } catch (const std::bad_any_cast&) {
                              // Ignore invalid options
@@ -1794,9 +1794,9 @@ std::optional<bool> Functions::toBoolean(const std::any& arg) {
             result = std::any_cast<bool>(arg);
             // Check for map/object
         } else if (arg.type() ==
-                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                   typeid(std::unordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const jsonata::backend::ordered_map<std::string, std::any>&>(arg);
+                const std::unordered_map<std::string, std::any>&>(arg);
             result = !map.empty();
         }
         // Functions are falsy
@@ -2187,7 +2187,7 @@ std::any Functions::merge(const Utils::JList& args) {
     }
 
     try {
-        jsonata::backend::ordered_map<std::string, std::any> result;
+        std::unordered_map<std::string, std::any> result;
 
         // Convert to vector if needed
         Utils::JList inputArray;
@@ -2204,9 +2204,9 @@ std::any Functions::merge(const Utils::JList& args) {
                 try {
                     // Handle direct map
                     if (item.type() ==
-                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                        typeid(std::unordered_map<std::string, std::any>)) {
                         const auto& map =
-                            std::any_cast<const jsonata::backend::ordered_map<
+                            std::any_cast<const std::unordered_map<
                                 std::string, std::any>&>(item);
                         for (const auto& entry : map) {
                             result[entry.first] = entry.second;
@@ -2312,11 +2312,11 @@ std::any Functions::spread(const Utils::JList& args) {
             // Handle object - create an array with one object per key-value
             // pair
         } else if (arg.type() ==
-                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                   typeid(std::unordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const jsonata::backend::ordered_map<std::string, std::any>&>(arg);
+                const std::unordered_map<std::string, std::any>&>(arg);
             for (const auto& entry : map) {
-                jsonata::backend::ordered_map<std::string, std::any> obj;
+                std::unordered_map<std::string, std::any> obj;
                 obj[entry.first] = entry.second;
                 result.push_back(obj);
             }
@@ -2347,13 +2347,13 @@ std::any Functions::sift(const Utils::JList& args) {
     }
 
     try {
-        jsonata::backend::ordered_map<std::string, std::any> result;
+        std::unordered_map<std::string, std::any> result;
 
         // Handle direct map
         if (objectArg.type() ==
-            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+            typeid(std::unordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const jsonata::backend::ordered_map<std::string, std::any>&>(objectArg);
+                const std::unordered_map<std::string, std::any>&>(objectArg);
             for (const auto& entry : map) {
                 // Prepare arguments for the predicate function
                 auto funcArgs = hofFuncArgs(predicateArg, entry.second,
@@ -2422,9 +2422,9 @@ void Functions::stringifyInternal(std::ostringstream& os, const std::any& arg,
             if (prettify && !vec.empty()) os << indent;
             os << "]";
         } else if (arg.type() ==
-                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                   typeid(std::unordered_map<std::string, std::any>)) {
             auto map =
-                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                std::any_cast<std::unordered_map<std::string, std::any>>(
                     arg);
             os << "{";
             if (prettify && !map.empty()) os << "\n";
@@ -3005,10 +3005,10 @@ Utils::JList Functions::keys(const std::any& arg) {
                 result.push_back(key);
             }
         } else if (arg.type() ==
-                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                   typeid(std::unordered_map<std::string, std::any>)) {
             // Java: if (arg instanceof Map) - return keySet
             const auto& map = std::any_cast<
-                const jsonata::backend::ordered_map<std::string, std::any>&>(arg);
+                const std::unordered_map<std::string, std::any>&>(arg);
             for (const auto& [key, value] : map) {
                 result.push_back(key);
             }
@@ -3038,9 +3038,9 @@ std::any Functions::each(const std::any& obj, const std::any& func) {
 
         // Handle direct map<string, any>
         if (obj.type() ==
-            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+            typeid(std::unordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const jsonata::backend::ordered_map<std::string, std::any>&>(obj);
+                const std::unordered_map<std::string, std::any>&>(obj);
             // Java: for (var key : obj.keySet())
             for (const auto& entry : map) {
                 const std::string& key = entry.first;
@@ -3613,7 +3613,7 @@ std::string Functions::formatScientificNotation(double value,
 
 std::optional<std::string> Functions::formatNumber(
     double value, const std::string& picture,
-    const jsonata::backend::ordered_map<std::string, std::any>& options) {
+    const std::unordered_map<std::string, std::any>& options) {
     if (std::isnan(value) || std::isinf(value)) {
         return std::nullopt;
     }
@@ -4156,11 +4156,11 @@ std::any Functions::lookup(const std::any& input, const std::string& key) {
 
             return result.empty() ? std::any{} : std::any(result);
         } else if (input.type() ==
-                   typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                   typeid(std::unordered_map<std::string, std::any>)) {
             // Java: if (input instanceof Map) - get key and handle null
             // detection
             const auto& map = std::any_cast<
-                const jsonata::backend::ordered_map<std::string, std::any>&>(input);
+                const std::unordered_map<std::string, std::any>&>(input);
             auto it = map.find(key);
             if (it != map.end()) {
                 auto result = it->second;
@@ -5058,7 +5058,7 @@ Utils::JList Functions::evaluateMatcher(const std::regex& pattern,
 
     for (; iter != end; ++iter) {
         const std::smatch& smatch = *iter;
-        jsonata::backend::ordered_map<std::string, std::any> match;
+        std::unordered_map<std::string, std::any> match;
         match["match"] = smatch.str();
         match["index"] = static_cast<int64_t>(smatch.position());
 
@@ -5459,9 +5459,9 @@ std::string Functions::safeReplaceAllFn(const std::string& str,
     return finalResult;
 }
 
-jsonata::backend::ordered_map<std::string, std::any> Functions::toJsonataMatch(
+std::unordered_map<std::string, std::any> Functions::toJsonataMatch(
     const std::smatch& match) {
-    jsonata::backend::ordered_map<std::string, std::any> result;
+    std::unordered_map<std::string, std::any> result;
 
     result["match"] = match.str();
 
@@ -5565,7 +5565,7 @@ std::string Functions::rightPad(const std::string& str, int64_t size,
 // formatNumber options processing helper functions
 
 Functions::FormatSymbols Functions::processOptionsArg(
-    const jsonata::backend::ordered_map<std::string, std::any>& options) {
+    const std::unordered_map<std::string, std::any>& options) {
     FormatSymbols symbols;  // Use default values
 
     if (options.empty()) {
diff --git a/src/jsonata/JException.cpp b/src/jsonata/JException.cpp
index e18b19f..d040781 100644
--- a/src/jsonata/JException.cpp
+++ b/src/jsonata/JException.cpp
@@ -17,7 +17,6 @@
  * limitations under the License.
  */
 #include "jsonata/JException.h"
-#include "jsonata/backends.h"
 #include <regex>
 #include <sstream>
 
diff --git a/src/jsonata/Jsonata.cpp b/src/jsonata/Jsonata.cpp
index f25c46e..ed78d3b 100644
--- a/src/jsonata/Jsonata.cpp
+++ b/src/jsonata/Jsonata.cpp
@@ -747,9 +747,9 @@ std::any Jsonata::evaluateWildcard(std::shared_ptr<Parser::Symbol> expr,
     try {
         // Handle map/object input
         if (_input.type() ==
-            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+            typeid(std::unordered_map<std::string, std::any>)) {
             auto map =
-                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                std::any_cast<std::unordered_map<std::string, std::any>>(
                     _input);
             for (const auto& [key, value] : map) {
                 // Java reference line 713: if((value instanceof List))
@@ -867,7 +867,7 @@ std::any Jsonata::evaluatePath(std::shared_ptr<Parser::Symbol> expr,
             if (tupleBindings.has_value()) {
                 for (const auto& tupleAny : *tupleBindings) {
                     auto tuple = std::any_cast<
-                        jsonata::backend::ordered_map<std::string, std::any>>(tupleAny);
+                        std::unordered_map<std::string, std::any>>(tupleAny);
                     auto it = tuple.find("@");
                     if (it != tuple.end()) {
                         result.push_back(it->second);
@@ -1151,14 +1151,14 @@ bool Jsonata::deepEquals(const std::any& lhs, const std::any& rhs) {
     // Handle object comparison - Java uses Map.equals() which compares all
     // key-value pairs
     if (lhsConverted.type() ==
-            typeid(jsonata::backend::ordered_map<std::string, std::any>) &&
+            typeid(std::unordered_map<std::string, std::any>) &&
         rhsConverted.type() ==
-            typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+            typeid(std::unordered_map<std::string, std::any>)) {
         const auto& leftMap =
-            std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
+            std::any_cast<const std::unordered_map<std::string, std::any>&>(
                 lhsConverted);
         const auto& rightMap =
-            std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
+            std::any_cast<const std::unordered_map<std::string, std::any>&>(
                 rhsConverted);
 
         if (leftMap.size() != rightMap.size()) {
@@ -1356,7 +1356,7 @@ void Jsonata::recurseDescendants(const std::any& input,
         // in the codebase
         try {
             auto map =
-                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                std::any_cast<std::unordered_map<std::string, std::any>>(
                     input);
             for (const auto& [key, value] : map) {
                 recurseDescendants(value, results);
@@ -1548,9 +1548,9 @@ std::any Jsonata::evaluateSort(std::shared_ptr<Parser::Symbol> expr,
                 // Extract context from tuple map
                 try {
                     if (a.type() ==
-                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                        typeid(std::unordered_map<std::string, std::any>)) {
                         auto tupleMap = std::any_cast<
-                            jsonata::backend::ordered_map<std::string, std::any>>(a);
+                            std::unordered_map<std::string, std::any>>(a);
                         auto it = tupleMap.find("@");
                         if (it != tupleMap.end()) {
                             contextA = it->second;
@@ -1573,9 +1573,9 @@ std::any Jsonata::evaluateSort(std::shared_ptr<Parser::Symbol> expr,
             if (isTupleSort) {
                 try {
                     if (b.type() ==
-                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                        typeid(std::unordered_map<std::string, std::any>)) {
                         auto tupleMap = std::any_cast<
-                            jsonata::backend::ordered_map<std::string, std::any>>(b);
+                            std::unordered_map<std::string, std::any>>(b);
                         auto it = tupleMap.find("@");
                         if (it != tupleMap.end()) {
                             contextB = it->second;
@@ -1781,16 +1781,16 @@ std::any Jsonata::evaluateTransform(std::shared_ptr<Parser::Symbol> expr,
                 if (update.has_value()) {
                     if (update.type() ==
                             typeid(
-                                jsonata::backend::ordered_map<std::string, std::any>) &&
+                                std::unordered_map<std::string, std::any>) &&
                         match.type() ==
                             typeid(
-                                jsonata::backend::ordered_map<std::string, std::any>)) {
+                                std::unordered_map<std::string, std::any>)) {
                         // Java lines 1457-1459: merge the update
                         auto& matchMap = std::any_cast<
-                            jsonata::backend::ordered_map<std::string, std::any>&>(
+                            std::unordered_map<std::string, std::any>&>(
                             match);
                         const auto& updateMap =
-                            std::any_cast<const jsonata::backend::ordered_map<
+                            std::any_cast<const std::unordered_map<
                                 std::string, std::any>&>(update);
 
                         for (const auto& [prop, value] : updateMap) {
@@ -1921,9 +1921,9 @@ std::any Jsonata::evaluateFilter(std::shared_ptr<Parser::Symbol> predicate,
             }
             if (isTupleStream &&
                 item.type() ==
-                    typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                    typeid(std::unordered_map<std::string, std::any>)) {
                 auto tupleMap =
-                    std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                    std::any_cast<std::unordered_map<std::string, std::any>>(
                         item);
                 auto it = tupleMap.find("@");
                 if (it != tupleMap.end()) {
@@ -1999,10 +1999,10 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 }
 
 // std::any Jsonata::toAny(
-//     const jsonata::backend::ordered_json& j) {
+//     const jsonata::ordered_json& j) {
 //     if (j.is_null()) return std::any{};
-//     if (j.is_boolean()) return std::any(j.get<bool>());
-//     if (j.is_number_integer()) {
+//     if (j.isBool()) return std::any(j.get<bool>());
+//     if (j.isInteger()) {
 //         // Preserve sign by using int64_t; for large unsigned, capture as
 //         // uint64_t
 //         int64_t si = 0;
@@ -2014,23 +2014,23 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //         uint64_t ui = j.get<uint64_t>();
 //         return std::any(static_cast<uint64_t>(ui));
 //     }
-//     if (j.is_number_unsigned()) {
+//     if (j.isUnsignedInteger()) {
 //         uint64_t ui = j.get<uint64_t>();
 //         return std::any(static_cast<uint64_t>(ui));
 //     }
-//     if (j.is_number_float()) return std::any(j.get<double>());
-//     if (j.is_string()) return std::any(j.get<std::string>());
-//     if (j.is_array()) {
+//     if (j.isFloat()) return std::any(j.get<double>());
+//     if (j.isString()) return std::any(j.get<std::string>());
+//     if (j.isArray()) {
 //         std::vector<std::any> out;
 //         out.reserve(j.size());
-//         jsonata::backend::copy( j, out, [](const jsonata::backend::ordered_json&el){
+//         jsonata::copy( j, out, [](const jsonata::ordered_json&el){
 //             return toAny(el);
 //         });
 //         return out;
 //     }
-//     if (j.is_object()) {
-//         jsonata::backend::ordered_map<std::string, std::any> m;
-//         jsonata::backend::copy( j, m, [](const jsonata::backend::ordered_json&el){
+//     if (j.isObject()) {
+//         std::unordered_map<std::string, std::any> m;
+//         jsonata::copy( j, m, [](const jsonata::ordered_json&el){
 //             return toAny(el);
 //         });
 //         return m;
@@ -2038,9 +2038,9 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //     return std::any{};
 // }
 
-// jsonata::backend::ordered_json Jsonata::fromAny(
+// jsonata::ordered_json Jsonata::fromAny(
 //     const std::any& value) {
-//     if (!value.has_value()) return jsonata::backend::ordered_json();
+//     if (!value.has_value()) return jsonata::ordered_json();
 
 //     // Canonicalize numeric types: convert doubles with no fractional part to
 //     // integer types
@@ -2057,69 +2057,69 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 
 //     const std::type_info& type = value.type();
 //     if (type == typeid(bool))
-//         return jsonata::backend::ordered_json(std::any_cast<bool>(value));
+//         return jsonata::ordered_json(std::any_cast<bool>(value));
 //     if (type == typeid(double))
-//         return jsonata::backend::ordered_json(std::any_cast<double>(value));
+//         return jsonata::ordered_json(std::any_cast<double>(value));
 //     if (type == typeid(int64_t))
-//         return jsonata::backend::ordered_json(std::any_cast<int64_t>(value));
+//         return jsonata::ordered_json(std::any_cast<int64_t>(value));
 //     if (type == typeid(uint64_t))
-//         return jsonata::backend::ordered_json(std::any_cast<uint64_t>(value));
+//         return jsonata::ordered_json(std::any_cast<uint64_t>(value));
 //     // Cross-platform support for additional integral types (e.g., long/long long)
 //     if (type == typeid(long long))
-//         return jsonata::backend::ordered_json(static_cast<int64_t>(std::any_cast<long long>(value)));
+//         return jsonata::ordered_json(static_cast<int64_t>(std::any_cast<long long>(value)));
 //     if (type == typeid(unsigned long long))
-//         return jsonata::backend::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
+//         return jsonata::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
 //     if (type == typeid(long))
-//         return jsonata::backend::ordered_json(static_cast<int64_t>(std::any_cast<long>(value)));
+//         return jsonata::ordered_json(static_cast<int64_t>(std::any_cast<long>(value)));
 //     if (type == typeid(unsigned long))
-//         return jsonata::backend::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
+//         return jsonata::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
 //     if (type == typeid(int))
-//         return jsonata::backend::ordered_json(static_cast<int64_t>(std::any_cast<int>(value)));
+//         return jsonata::ordered_json(static_cast<int64_t>(std::any_cast<int>(value)));
 //     if (type == typeid(unsigned int))
-//         return jsonata::backend::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
+//         return jsonata::ordered_json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
 //     if (type == typeid(std::string))
-//         return jsonata::backend::ordered_json(std::any_cast<std::string>(value));
+//         return jsonata::ordered_json(std::any_cast<std::string>(value));
 //     if (type == typeid(Utils::JList)) {
-//         jsonata::backend::ordered_json arr = jsonata::backend::ordered_json::array();
+//         jsonata::ordered_json arr = jsonata::ordered_json::array();
 //         const auto& jlist = std::any_cast<const Utils::JList&>(value);
-//         jsonata::backend::copy( jlist, arr, []( const std::any & a ) {
+//         jsonata::copy( jlist, arr, []( const std::any & a ) {
 //             return fromAny( a );
 //         });
 //         return arr;
 //     }
 //     if (type == typeid(std::vector<std::any>)) {
-//         jsonata::backend::ordered_json arr = jsonata::backend::ordered_json::array();
+//         jsonata::ordered_json arr = jsonata::ordered_json::array();
 //         const auto& vec = std::any_cast<const std::vector<std::any>&>(value);
-//         jsonata::backend::copy( vec, arr, []( const std::any & a ) {
+//         jsonata::copy( vec, arr, []( const std::any & a ) {
 //             return fromAny( a );
 //         });
 //         return arr;
 //     }
-//     if (type == typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
-//         jsonata::backend::ordered_json obj = jsonata::backend::ordered_json::object();
+//     if (type == typeid(std::unordered_map<std::string, std::any>)) {
+//         jsonata::ordered_json obj = jsonata::ordered_json::object();
 //         const auto& map =
-//             std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
+//             std::any_cast<const std::unordered_map<std::string, std::any>&>(
 //                 value);
-//         jsonata::backend::copy( map, obj, []( const std::any & a ) {
+//         jsonata::copy( map, obj, []( const std::any & a ) {
 //             return fromAny(a);
 //         });
 //         return obj;
 //     }
 //     if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
-//         return jsonata::backend::ordered_json();
+//         return jsonata::ordered_json();
 //     }
-//     // Directly handle jsonata::backend::ordered_json returned from custom functions
-//     if (type == typeid(jsonata::backend::ordered_json)) {
-//         return std::any_cast<jsonata::backend::ordered_json>(value);
+//     // Directly handle jsonata::ordered_json returned from custom functions
+//     if (type == typeid(jsonata::ordered_json)) {
+//         return std::any_cast<jsonata::ordered_json>(value);
 //     }
-//     return jsonata::backend::ordered_json();
+//     return jsonata::ordered_json();
 // }
 
-// // Unordered JSON helpers (jsonata::backend::json)
-// std::any Jsonata::jsonToAny(const jsonata::backend::json& j) {
+// // Unordered JSON helpers (jsonata::json)
+// std::any Jsonata::jsonToAny(const jsonata::json& j) {
 //     if (j.is_null()) return std::any{};
-//     if (j.is_boolean()) return std::any(j.get<bool>());
-//     if (j.is_number_integer()) {
+//     if (j.isBool()) return std::any(j.get<bool>());
+//     if (j.isNumber_integer()) {
 //         int64_t si = 0;
 //         try {
 //             si = j.get<int64_t>();
@@ -2129,23 +2129,23 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //         uint64_t ui = j.get<uint64_t>();
 //         return std::any(static_cast<uint64_t>(ui));
 //     }
-//     if (j.is_number_unsigned()) {
+//     if (j.isUnsignedInteger()) {
 //         uint64_t ui = j.get<uint64_t>();
 //         return std::any(static_cast<uint64_t>(ui));
 //     }
-//     if (j.is_number_float()) return std::any(j.get<double>());
-//     if (j.is_string()) return std::any(j.get<std::string>());
-//     if (j.is_array()) {
+//     if (j.isFloat()) return std::any(j.get<double>());
+//     if (j.isString()) return std::any(j.get<std::string>());
+//     if (j.isArray()) {
 //         std::vector<std::any> out;
 //         out.reserve(j.size());
-//         jsonata::backend::copy( j, out, []( const jsonata::backend::json & el ) {
+//         jsonata::copy( j, out, []( const jsonata::json & el ) {
 //             return jsonToAny(el);
 //         });
 //         return out;
 //     }
-//     if (j.is_object()) {
-//         jsonata::backend::ordered_map<std::string, std::any> m;
-//         jsonata::backend::copy( j, m, []( const jsonata::backend::json & el ) {
+//     if (j.isObject()) {
+//         std::unordered_map<std::string, std::any> m;
+//         jsonata::copy( j, m, []( const jsonata::json & el ) {
 //             return jsonToAny(el);
 //         });
 //         return m;
@@ -2153,8 +2153,8 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //     return std::any{};
 // }
 
-// jsonata::backend::json Jsonata::anyToJson(const std::any& value) {
-//     if (!value.has_value()) return jsonata::backend::json();
+// jsonata::json Jsonata::anyToJson(const std::any& value) {
+//     if (!value.has_value()) return jsonata::json();
 
 //     // Canonicalize numeric types similar to fromAny
 //     try {
@@ -2170,51 +2170,51 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 
 //     const std::type_info& type = value.type();
 //     if (type == typeid(bool))
-//         return jsonata::backend::json(std::any_cast<bool>(value));
+//         return jsonata::json(std::any_cast<bool>(value));
 //     if (type == typeid(double))
-//         return jsonata::backend::json(std::any_cast<double>(value));
+//         return jsonata::json(std::any_cast<double>(value));
 //     if (type == typeid(int64_t))
-//         return jsonata::backend::json(std::any_cast<int64_t>(value));
+//         return jsonata::json(std::any_cast<int64_t>(value));
 //     if (type == typeid(uint64_t))
-//         return jsonata::backend::json(std::any_cast<uint64_t>(value));
+//         return jsonata::json(std::any_cast<uint64_t>(value));
 //     // Cross-platform support for additional integral types (e.g., long/long long)
 //     if (type == typeid(long long))
-//         return jsonata::backend::json(static_cast<int64_t>(std::any_cast<long long>(value)));
+//         return jsonata::json(static_cast<int64_t>(std::any_cast<long long>(value)));
 //     if (type == typeid(unsigned long long))
-//         return jsonata::backend::json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
+//         return jsonata::json(static_cast<uint64_t>(std::any_cast<unsigned long long>(value)));
 //     if (type == typeid(long))
-//         return jsonata::backend::json(static_cast<int64_t>(std::any_cast<long>(value)));
+//         return jsonata::json(static_cast<int64_t>(std::any_cast<long>(value)));
 //     if (type == typeid(unsigned long))
-//         return jsonata::backend::json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
+//         return jsonata::json(static_cast<uint64_t>(std::any_cast<unsigned long>(value)));
 //     if (type == typeid(int))
-//         return jsonata::backend::json(static_cast<int64_t>(std::any_cast<int>(value)));
+//         return jsonata::json(static_cast<int64_t>(std::any_cast<int>(value)));
 //     if (type == typeid(unsigned int))
-//         return jsonata::backend::json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
+//         return jsonata::json(static_cast<uint64_t>(std::any_cast<unsigned int>(value)));
 //     if (type == typeid(std::string))
-//         return jsonata::backend::json(std::any_cast<std::string>(value));
+//         return jsonata::json(std::any_cast<std::string>(value));
 
 //     if (type == typeid(Utils::JList)) {
-//         jsonata::backend::json arr = jsonata::backend::json::array();
+//         jsonata::json arr = jsonata::json::array();
 //         const auto& jlist = std::any_cast<const Utils::JList&>(value);
-//         jsonata::backend::copy( jlist, arr, []( const std::any & a ) {
+//         jsonata::copy( jlist, arr, []( const std::any & a ) {
 //             return anyToJson(a);
 //         });
 //         return arr;
 //     }
 //     if (type == typeid(std::vector<std::any>)) {
-//         jsonata::backend::json arr = jsonata::backend::json::array();
+//         jsonata::json arr = jsonata::json::array();
 //         const auto& vec = std::any_cast<const std::vector<std::any>&>(value);
-//         jsonata::backend::copy( vec, arr, []( const std::any & a ) {
+//         jsonata::copy( vec, arr, []( const std::any & a ) {
 //             return anyToJson(a);
 //         });
 //         return arr;
 //     }
-//     if (type == typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
-//         jsonata::backend::json obj = jsonata::backend::json::object();
+//     if (type == typeid(std::unordered_map<std::string, std::any>)) {
+//         jsonata::json obj = jsonata::json::object();
 //         const auto& map =
-//             std::any_cast<const jsonata::backend::ordered_map<std::string, std::any>&>(
+//             std::any_cast<const std::unordered_map<std::string, std::any>&>(
 //                 value);
-//         jsonata::backend::copy( map, obj, []( const std::any & a ) {
+//         jsonata::copy( map, obj, []( const std::any & a ) {
 //             return anyToJson(a);
 //         });
 //         return obj;
@@ -2222,60 +2222,60 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 
 //     // Ignore function symbols
 //     if (type == typeid(std::shared_ptr<Parser::Symbol>)) {
-//         return jsonata::backend::json();
+//         return jsonata::json();
 //     }
 
-//     // Directly handle jsonata::backend::json returned from custom functions
-//     if (type == typeid(jsonata::backend::json)) {
-//         return std::any_cast<jsonata::backend::json>(value);
+//     // Directly handle jsonata::json returned from custom functions
+//     if (type == typeid(jsonata::json)) {
+//         return std::any_cast<jsonata::json>(value);
 //     }
 
-//     // Handle jsonata::backend::ordered_json without dump/parse by converting
-//     if (type == typeid(jsonata::backend::ordered_json)) {
-//         const auto& oj = std::any_cast<const jsonata::backend::ordered_json&>(value);
+//     // Handle jsonata::ordered_json without dump/parse by converting
+//     if (type == typeid(jsonata::ordered_json)) {
+//         const auto& oj = std::any_cast<const jsonata::ordered_json&>(value);
 
 //         // Recursive lambda to convert ordered_json to json
-//         std::function<jsonata::backend::json(const jsonata::backend::ordered_json&)> convert =
-//             [&](const jsonata::backend::ordered_json& j) -> jsonata::backend::json {
-//             if (j.is_null()) return jsonata::backend::json();
-//             if (j.is_boolean()) return jsonata::backend::json(j.get<bool>());
-//             if (j.is_number_integer()) {
+//         std::function<jsonata::json(const jsonata::ordered_json&)> convert =
+//             [&](const jsonata::ordered_json& j) -> jsonata::json {
+//             if (j.is_null()) return jsonata::json();
+//             if (j.isBool()) return jsonata::json(j.get<bool>());
+//             if (j.isNumber_integer()) {
 //                 int64_t si = 0;
 //                 try {
 //                     si = j.get<int64_t>();
-//                     return jsonata::backend::json(static_cast<int64_t>(si));
+//                     return jsonata::json(static_cast<int64_t>(si));
 //                 } catch (...) {
 //                 }
 //                 uint64_t ui = j.get<uint64_t>();
-//                 return jsonata::backend::json(static_cast<uint64_t>(ui));
+//                 return jsonata::json(static_cast<uint64_t>(ui));
 //             }
-//             if (j.is_number_unsigned())
-//                 return jsonata::backend::json(j.get<uint64_t>());
-//             if (j.is_number_float())
-//                 return jsonata::backend::json(j.get<double>());
-//             if (j.is_string())
-//                 return jsonata::backend::json(j.get<std::string>());
-//             if (j.is_array()) {
-//                 jsonata::backend::json arr = jsonata::backend::json::array();
-//                 jsonata::backend::copy( j, arr, [&convert]( const jsonata::backend::ordered_json& el ) {
+//             if (j.isUnsignedInteger())
+//                 return jsonata::json(j.get<uint64_t>());
+//             if (j.isFloat())
+//                 return jsonata::json(j.get<double>());
+//             if (j.isString())
+//                 return jsonata::json(j.get<std::string>());
+//             if (j.isArray()) {
+//                 jsonata::json arr = jsonata::json::array();
+//                 jsonata::copy( j, arr, [&convert]( const jsonata::ordered_json& el ) {
 //                     return convert(el );
 //                 });
 //                 return arr;
 //             }
-//             if (j.is_object()) {
-//                 jsonata::backend::json obj = jsonata::backend::json::object();
-//                 jsonata::backend::copy( j, obj, [&convert]( const jsonata::backend::ordered_json& el ) {
+//             if (j.isObject()) {
+//                 jsonata::json obj = jsonata::json::object();
+//                 jsonata::copy( j, obj, [&convert]( const jsonata::ordered_json& el ) {
 //                     return convert(el );
 //                 });
 //                 return obj;
 //             }
-//             return jsonata::backend::json();
+//             return jsonata::json();
 //         };
 
 //         return convert(oj);
 //     }
 
-//     return jsonata::backend::json();
+//     return jsonata::json();
 // }
 
 // Missing public API methods from Java
@@ -2318,7 +2318,7 @@ std::shared_ptr<Frame> Jsonata::createFrameFromTuple(
     // Java reference lines 324-329: createFrameFromTuple implementation
     auto frame = createFrame(environment);
     auto tuple =
-        std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(tupleAny);
+        std::any_cast<std::unordered_map<std::string, std::any>>(tupleAny);
     for (const auto& [key, value] : tuple) {
         frame->bind(key, value);
     }
@@ -2337,15 +2337,15 @@ std::any Jsonata::reduceTupleStream(const std::any& tupleStream) {
         return std::any{};
     }
 
-    jsonata::backend::ordered_map<std::string, std::any> result;
+    std::unordered_map<std::string, std::any> result;
     // Java line 1144: result.putAll(tupleStream.get(0));
     result =
-        std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(tuples[0]);
+        std::any_cast<std::unordered_map<std::string, std::any>>(tuples[0]);
 
     // Java lines 1147-1158: merge remaining tuples
     for (size_t i = 1; i < tuples.size(); i++) {
         const auto& el =
-            std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+            std::any_cast<std::unordered_map<std::string, std::any>>(
                 tuples[i]);
         for (const auto& [prop, value] : el) {
             // Java line 1154: result.put(prop,
@@ -2498,7 +2498,7 @@ Jsonata::Jsonata(const Jsonata& other) {
 //         tls_input_.reset();
 //         tls_environment_.reset();
 //         result = Utils::convertNulls(result);
-//         // Convert result back to jsonata::backend::ordered_json
+//         // Convert result back to jsonata::ordered_json
 //         return fromAny(result);
 //     } catch (const std::exception& err) {
 //         // TODO: populateMessage(err);
@@ -2506,11 +2506,11 @@ Jsonata::Jsonata(const Jsonata& other) {
 //     }
 // }
 
-// jsonata::backend::ordered_json Jsonata::evaluate(const jsonata::backend::ordered_json& input) {
+// jsonata::ordered_json Jsonata::evaluate(const jsonata::ordered_json& input) {
 //     return evaluate(input, nullptr);
 // }
 
-// jsonata::backend::ordered_json Jsonata::evaluate(const jsonata::backend::ordered_json& input,
+// jsonata::ordered_json Jsonata::evaluate(const jsonata::ordered_json& input,
 //                                          std::shared_ptr<Frame> bindings) {
 //     currentInstance_ = this;
 
@@ -2568,7 +2568,7 @@ Jsonata::Jsonata(const Jsonata& other) {
 //         tls_input_.reset();
 //         tls_environment_.reset();
 //         result = Utils::convertNulls(result);
-//         // Convert result back to jsonata::backend::ordered_json
+//         // Convert result back to jsonata::ordered_json
 //         return fromAny(result);
 //     } catch (const std::exception& err) {
 //         // TODO: populateMessage(err);
@@ -2576,21 +2576,21 @@ Jsonata::Jsonata(const Jsonata& other) {
 //     }
 // }
 
-// jsonata::backend::ordered_json Jsonata::evaluate(std::nullptr_t) {
-//     return evaluate(jsonata::backend::ordered_json());
+// jsonata::ordered_json Jsonata::evaluate(std::nullptr_t) {
+//     return evaluate(jsonata::ordered_json());
 // }
 
-// jsonata::backend::ordered_json Jsonata::evaluate(std::nullptr_t,
+// jsonata::ordered_json Jsonata::evaluate(std::nullptr_t,
 //                                          std::shared_ptr<Frame> bindings) {
-//     return evaluate(jsonata::backend::ordered_json(), bindings);
+//     return evaluate(jsonata::ordered_json(), bindings);
 // }
 
-// // Unordered jsonata::backend::json variants
-// jsonata::backend::json Jsonata::evaluate(const jsonata::backend::json& input) {
+// // Unordered jsonata::json variants
+// jsonata::json Jsonata::evaluate(const jsonata::json& input) {
 //     return evaluate(input, nullptr);
 // }
 
-// jsonata::backend::json Jsonata::evaluate(const jsonata::backend::json& input,
+// jsonata::json Jsonata::evaluate(const jsonata::json& input,
 //                                  std::shared_ptr<Frame> bindings) {
 //     currentInstance_ = this;
 
@@ -2630,20 +2630,20 @@ Jsonata::Jsonata(const Jsonata& other) {
 //         tls_input_.reset();
 //         tls_environment_.reset();
 //         result = Utils::convertNulls(result);
-//         // Convert result to jsonata::backend::json
+//         // Convert result to jsonata::json
 //         return anyToJson(result);
 //     } catch (const std::exception& err) {
 //         throw;
 //     }
 // }
 
-// jsonata::backend::json Jsonata::evaluateUnordered(std::nullptr_t) {
-//     return evaluate(jsonata::backend::json());
+// jsonata::json Jsonata::evaluateUnordered(std::nullptr_t) {
+//     return evaluate(jsonata::json());
 // }
 
-// jsonata::backend::json Jsonata::evaluateUnordered(std::nullptr_t,
+// jsonata::json Jsonata::evaluateUnordered(std::nullptr_t,
 //                                           std::shared_ptr<Frame> bindings) {
-//     return evaluate(jsonata::backend::json(), bindings);
+//     return evaluate(jsonata::json(), bindings);
 // }
 
 std::any Jsonata::apply(const std::any& proc, const Utils::JList& args,
@@ -2731,7 +2731,7 @@ static std::any regexClosure(std::shared_ptr<RegexState> state) {
     if (state->it == state->end) return std::any{};
     auto match = *state->it;
     ++(state->it);
-    jsonata::backend::ordered_map<std::string, std::any> result;
+    std::unordered_map<std::string, std::any> result;
     result["match"] = std::string(match.str());
     result["start"] = static_cast<long long>(match.position());
     result["end"] = static_cast<long long>(match.position() + match.length());
@@ -2915,9 +2915,9 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                 std::shared_ptr<Frame> environment;
                 if (symbol->value.has_value() &&
                     symbol->value.type() ==
-                        typeid(jsonata::backend::ordered_map<std::string, std::any>)) {
+                        typeid(std::unordered_map<std::string, std::any>)) {
                     auto closureMap = std::any_cast<
-                        jsonata::backend::ordered_map<std::string, std::any>>(
+                        std::unordered_map<std::string, std::any>>(
                         symbol->value);
                     if (closureMap.find("environment") != closureMap.end()) {
                         try {
@@ -2981,16 +2981,16 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             return std::any_cast<bool>(a) ==
                                    std::any_cast<bool>(b);
                         if (a.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>) &&
                             b.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>)) {
                             const auto& ma =
-                                std::any_cast<const jsonata::backend::ordered_map<
+                                std::any_cast<const std::unordered_map<
                                     std::string, std::any>&>(a);
                             const auto& mb =
-                                std::any_cast<const jsonata::backend::ordered_map<
+                                std::any_cast<const std::unordered_map<
                                     std::string, std::any>&>(b);
                             if (ma.size() != mb.size()) return false;
                             for (const auto& [k, va] : ma) {
@@ -3032,19 +3032,19 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
 
                     std::function<bool(
                         std::any&, const std::any&,
-                        const jsonata::backend::ordered_map<std::string, std::any>&)>
+                        const std::unordered_map<std::string, std::any>&)>
                         applyUpdateToFirstMatch =
                             [&](std::any& node, const std::any& target,
-                                const jsonata::backend::ordered_map<
+                                const std::unordered_map<
                                     std::string, std::any>& updateMap) -> bool {
                         if (node.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>) &&
                             target.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>)) {
                             if (deepEqualsAny(node, target)) {
-                                auto& m = std::any_cast<jsonata::backend::ordered_map<
+                                auto& m = std::any_cast<std::unordered_map<
                                     std::string, std::any>&>(node);
                                 for (const auto& [k, v] : updateMap) {
                                     m[k] = v;
@@ -3052,7 +3052,7 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 return true;
                             }
                             auto& m = std::any_cast<
-                                jsonata::backend::ordered_map<std::string, std::any>&>(
+                                std::unordered_map<std::string, std::any>&>(
                                 node);
                             for (auto it = m.begin(); it != m.end(); ++it) {
                                 if (applyUpdateToFirstMatch(it->second, target,
@@ -3091,13 +3091,13 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 const std::vector<std::string>& deletions)
                         -> bool {
                         if (node.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>) &&
                             target.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>)) {
                             if (deepEqualsAny(node, target)) {
-                                auto& m = std::any_cast<jsonata::backend::ordered_map<
+                                auto& m = std::any_cast<std::unordered_map<
                                     std::string, std::any>&>(node);
                                 for (const auto& key : deletions) {
                                     m.erase(key);
@@ -3105,7 +3105,7 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 return true;
                             }
                             auto& m = std::any_cast<
-                                jsonata::backend::ordered_map<std::string, std::any>&>(
+                                std::unordered_map<std::string, std::any>&>(
                                 node);
                             for (auto it = m.begin(); it != m.end(); ++it) {
                                 if (applyDeleteToFirstMatch(it->second, target,
@@ -3144,13 +3144,13 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             instance->evaluate(update, match, environment);
                         if (updateValue.has_value()) {
                             if (updateValue.type() !=
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>)) {
                                 throw JException("T2011", update->position,
                                                  updateValue);
                             }
                             const auto& updateMap =
-                                std::any_cast<const jsonata::backend::ordered_map<
+                                std::any_cast<const std::unordered_map<
                                     std::string, std::any>&>(updateValue);
                             // Apply update to the first occurrence of match
                             // within result
@@ -3162,10 +3162,10 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             // delete uses a structure that deep-equals the
                             // updated node in 'result'.
                             if (match.type() ==
-                                typeid(jsonata::backend::ordered_map<std::string,
+                                typeid(std::unordered_map<std::string,
                                                              std::any>)) {
                                 auto& matchMap =
-                                    std::any_cast<jsonata::backend::ordered_map<
+                                    std::any_cast<std::unordered_map<
                                         std::string, std::any>&>(match);
                                 for (const auto& [k, v] : updateMap) {
                                     matchMap[k] = v;
@@ -3294,7 +3294,7 @@ std::any Jsonata::evaluateStages(
                             std::string stageValue =
                                 std::any_cast<std::string>(stage->value);
                             auto tuple = std::any_cast<
-                                jsonata::backend::ordered_map<std::string, std::any>>(
+                                std::unordered_map<std::string, std::any>>(
                                 tupleList[ee]);
                             tuple[stageValue] = static_cast<int64_t>(ee);
                             tupleList[ee] = std::any(tuple);
@@ -3307,9 +3307,9 @@ std::any Jsonata::evaluateStages(
                     for (size_t ee = 0; ee < resultList.size(); ee++) {
                         if (resultList[ee].type() ==
                             typeid(
-                                jsonata::backend::ordered_map<std::string, std::any>)) {
+                                std::unordered_map<std::string, std::any>)) {
                             auto tuple = std::any_cast<
-                                jsonata::backend::ordered_map<std::string, std::any>>(
+                                std::unordered_map<std::string, std::any>>(
                                 resultList[ee]);
                             if (stage->value.has_value()) {
                                 std::string stageValue =
@@ -3447,7 +3447,7 @@ std::any Jsonata::evaluateTupleStep(
             if (sorted.has_value() && Utils::isArray(sorted)) {
                 auto sortedVec = Utils::arrayify(sorted);
                 for (size_t i = 0; i < sortedVec.size(); ++i) {
-                    jsonata::backend::ordered_map<std::string, std::any> tuple;
+                    std::unordered_map<std::string, std::any> tuple;
                     tuple["@"] = sortedVec[i];
                     if (expr->index.has_value()) {
                         try {
@@ -3486,7 +3486,7 @@ std::any Jsonata::evaluateTupleStep(
         // Java line 435: create initial tuple bindings (only when tupleBindings
         // is null, not just empty)
         for (const auto& item : input) {
-            jsonata::backend::ordered_map<std::string, std::any> tuple;
+            std::unordered_map<std::string, std::any> tuple;
             tuple["@"] = item;
             bindings.push_back(std::any(tuple));
         }
@@ -3495,7 +3495,7 @@ std::any Jsonata::evaluateTupleStep(
     // Java reference lines 438-472: process each tuple binding
     for (const auto& bindingAny : bindings) {
         auto binding =
-            std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+            std::any_cast<std::unordered_map<std::string, std::any>>(
                 bindingAny);
         // Create frame from tuple - Java line 439
         auto stepEnv = createFrameFromTuple(environment, bindingAny);
@@ -3519,14 +3519,14 @@ std::any Jsonata::evaluateTupleStep(
 
             // Java lines 449-469: create output tuples
             for (size_t i = 0; i < resVec.size(); ++i) {
-                jsonata::backend::ordered_map<std::string, std::any> tuple(
+                std::unordered_map<std::string, std::any> tuple(
                     binding);  // Copy existing bindings
 
                 if (resVec.tupleStream) {
                     // cast resVec[i] to a map and overwrite existing keys
                     // (match Java Map.putAll semantics)
                     auto resTuple = std::any_cast<
-                        jsonata::backend::ordered_map<std::string, std::any>>(
+                        std::unordered_map<std::string, std::any>>(
                         resVec[i]);
                     for (const auto& kv : resTuple) {
                         tuple[kv.first] = kv.second;
@@ -3588,14 +3588,14 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
     if (!expr) return std::any{};
 
     // Port exact Java implementation: Jsonata.java lines 1051-1134
-    jsonata::backend::ordered_map<std::string, std::any> result;
+    std::unordered_map<std::string, std::any> result;
 
     // C++ equivalent of Java's LinkedHashMap<Object,GroupEntry>
     struct GroupEntry {
         std::any data;
         int64_t exprIndex;
     };
-    jsonata::backend::ordered_map<std::string, GroupEntry> groups;
+    std::unordered_map<std::string, GroupEntry> groups;
 
     // Java line 1054: var reduce = (_input instanceof JList) &&
     // ((JList)_input).tupleStream ? true : false; For now, simplify this - the
@@ -3633,7 +3633,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
                 ? createFrameFromTuple(
                       environment,
                       std::any_cast<
-                          jsonata::backend::ordered_map<std::string, std::any>>(item))
+                          std::unordered_map<std::string, std::any>>(item))
                 : environment;
 
         for (size_t pairIndex = 0; pairIndex < expr->lhsObject.size();
@@ -3645,7 +3645,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
             std::any keyContext = item;
             if (reduce) {
                 auto itemMap =
-                    std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                    std::any_cast<std::unordered_map<std::string, std::any>>(
                         item);
                 auto atIt = itemMap.find("@");
                 keyContext =
@@ -3712,7 +3712,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
         if (reduce) {
             auto tuple = reduceTupleStream(entry.data);
             auto tupleMap =
-                std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(
+                std::any_cast<std::unordered_map<std::string, std::any>>(
                     tuple);
             auto atIt = tupleMap.find("@");
             context = (atIt != tupleMap.end()) ? atIt->second : std::any{};
@@ -3758,7 +3758,7 @@ std::any Jsonata::evaluateTransformExpression(
     transformer->arguments.push_back(dummyArg);
 
     // Store the closure environment
-    transformer->value = jsonata::backend::ordered_map<std::string, std::any>{
+    transformer->value = std::unordered_map<std::string, std::any>{
         {"input", input}, {"environment", environment}};
 
     return transformer;
diff --git a/src/jsonata/Utils.cpp b/src/jsonata/Utils.cpp
index b9cd425..a3da615 100644
--- a/src/jsonata/Utils.cpp
+++ b/src/jsonata/Utils.cpp
@@ -172,7 +172,7 @@ bool Utils::isArray(const std::any& value) {
 
 bool Utils::isObject(const std::any& value) {
     if (!value.has_value()) return false;
-    return value.type() == typeid(jsonata::backend::ordered_map<std::string, std::any>);
+    return value.type() == typeid(std::unordered_map<std::string, std::any>);
 }
 
 std::optional<std::string> Utils::type(const std::any& value) {
@@ -401,7 +401,7 @@ std::any Utils::convertNulls(const std::any& res) {
 void Utils::convertNullsMap(std::any& res) {
     try {
         auto& map =
-            std::any_cast<jsonata::backend::ordered_map<std::string, std::any>&>(res);
+            std::any_cast<std::unordered_map<std::string, std::any>&>(res);
         for (auto it = map.begin(); it != map.end(); ++it) {
             std::any& valRef = it->second;
             std::any converted = convertValue(valRef);
diff --git a/src/jsonata/utils/Signature.cpp b/src/jsonata/utils/Signature.cpp
index efcd5f4..aa5074c 100644
--- a/src/jsonata/utils/Signature.cpp
+++ b/src/jsonata/utils/Signature.cpp
@@ -21,7 +21,6 @@
 #include <algorithm>
 #include <functional>
 #include <iostream>
-#include "jsonata/backends.h"
 #include <sstream>
 #include <stdexcept>
 
@@ -131,7 +130,7 @@ bool Signature::isArrayType(const std::any &value) {
 std::string Signature::checkObjectType(const std::any &value) {
     // Try map (object)
     try {
-        auto r = std::any_cast<jsonata::backend::ordered_map<std::string, std::any>>(value);
+        auto r = std::any_cast<std::unordered_map<std::string, std::any>>(value);
         return "o";
     } catch (const std::bad_any_cast &) {
         // Try shared_ptr<map> - check if it's a regex object
diff --git a/test/ArrayTest.cpp b/test/ArrayTest.cpp
index b938d71..23c5771 100644
--- a/test/ArrayTest.cpp
+++ b/test/ArrayTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 
 namespace jsonata {
@@ -18,18 +17,18 @@ class ArrayTest : public ::testing::Test {
 
 TEST_F(ArrayTest, testNegativeIndex) {
     Jsonata expr1("item[-1]");
-    auto input1 = JSONATA_TEST_BACKEND::parse(R"({"item": []})");
+    auto input1 = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"item": []})");
     auto result1 = expr1.evaluate(input1);
-    EXPECT_TRUE(result1.is_null());
+    EXPECT_TRUE(result1.isNull());
 
     Jsonata expr2("$[-1]");
-    auto result2 = expr2.evaluate(JSONATA_TEST_BACKEND::array());
-    EXPECT_TRUE(result2.is_null());
+    auto result2 = expr2.evaluate(jsonata::backend<JSONATA_TEST_BACKEND>::array());
+    EXPECT_TRUE(result2.isNull());
 }
 
 TEST_F(ArrayTest, testArray) {
     // Create test data equivalent to Java: Map.of("key", Arrays.asList(Map.of("x", "y"), Map.of("a", "b")))
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"key": [{"x": "y"}, {"a": "b"}]})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"key": [{"x": "y"}, {"a": "b"}]})");
 
     // Test first expression: {'key': $append($.[{'x': 'y'}],$.[{'a': 'b'}])}
     Jsonata expr1("{'key': $append($.[{'x': 'y'}],$.[{'a': 'b'}])}");
@@ -48,7 +47,7 @@ TEST_F(ArrayTest, DISABLED_filterTest) {
     // This test is disabled as in the Java version
     Jsonata expr("($arr := [{'x':1}, {'x':2}];$arr[x=$number(variable.field)])");
 
-    auto inputData = JSONATA_TEST_BACKEND::parse(R"({"variable": {"field": "1"}})");
+    auto inputData = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"variable": {"field": "1"}})");
 
     auto result = expr.evaluate(inputData);
     EXPECT_TRUE(result != nullptr);
@@ -56,29 +55,29 @@ TEST_F(ArrayTest, DISABLED_filterTest) {
 
 TEST_F(ArrayTest, testIndex) {
     Jsonata expr("($x:=['a','b']; $x#$i.$i)");
-    auto result1 = expr.evaluate(JSONATA_TEST_BACKEND(1));
-    auto expected = JSONATA_TEST_BACKEND::parse("[0, 1]");
+    auto result1 = expr.evaluate(jsonata::backend<JSONATA_TEST_BACKEND>::create(1));
+    auto expected = jsonata::backend<JSONATA_TEST_BACKEND>::parse("[0, 1]");
     EXPECT_EQ(result1.dump(), expected.dump());
 
-    auto result2 = expr.evaluate(JSONATA_TEST_BACKEND(nullptr));
+    auto result2 = expr.evaluate(jsonata::backend<JSONATA_TEST_BACKEND>(nullptr));
     EXPECT_EQ(result2.dump(), expected.dump());
 }
 
 TEST_F(ArrayTest, testWildcard) {
     Jsonata expr("*");
-    auto input = JSONATA_TEST_BACKEND::parse(R"([{"x": 1}])");
+    auto input = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"([{"x": 1}])");
     auto result = expr.evaluate(input);
-    auto expected = JSONATA_TEST_BACKEND::parse(R"({"x": 1})");
+    auto expected = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x": 1})");
     EXPECT_EQ(result.dump(), expected.dump());
 }
 
 TEST_F(ArrayTest, testWildcardFilter) {
-    auto data = JSONATA_TEST_BACKEND::parse(
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(
         R"([{"value": {"Name": "Cell1", "Product": "Product1"}}, {"value": {"Name": "Cell2", "Product": "Product2"}}])");
 
     Jsonata expression("*[value.Product = 'Product1']");
     auto result1 = expression.evaluate(data);
-    auto expected = JSONATA_TEST_BACKEND::parse(
+    auto expected = jsonata::backend<JSONATA_TEST_BACKEND>::parse(
         R"({"value": {"Name": "Cell1", "Product": "Product1"}})");
     EXPECT_EQ(result1.dump(), expected.dump());
 
diff --git a/test/CustomFunctionTest.cpp b/test/CustomFunctionTest.cpp
index 708293e..c8da49f 100644
--- a/test/CustomFunctionTest.cpp
+++ b/test/CustomFunctionTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <jsonata/Functions.h>
 #include <vector>
@@ -20,7 +19,7 @@ TEST_F(CustomFunctionTest, testSupplier) {
     // Register zero-arg function via typed overload
     expression.registerFunction<std::string>("greet", []() { return std::string("Hello world"); });
     auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "Hello world");
 }
 
@@ -28,7 +27,7 @@ TEST_F(CustomFunctionTest, testEval) {
     Jsonata expression("$eval('$greet()')");
     expression.registerFunction<std::string>("greet", []() { return std::string("Hello world"); });
     auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "Hello world");
 }
 
@@ -36,7 +35,7 @@ TEST_F(CustomFunctionTest, testEvalWithParams) {
     Jsonata expression("($eval('$greet()'))");
     expression.registerFunction<std::string>("greet", []() { return std::string("Hello world"); });
     auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "Hello world");
 }
 
@@ -44,7 +43,7 @@ TEST_F(CustomFunctionTest, testUnary) {
     Jsonata expression("$echo(123)");
     expression.registerFunction<int64_t,int64_t>("echo", [](int64_t x) { return x; });
     auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_number());
+    ASSERT_TRUE(result.isNumber());
     EXPECT_EQ(result.get<int>(), 123);
 }
 
@@ -52,7 +51,7 @@ TEST_F(CustomFunctionTest, testBinary) {
     Jsonata expression("$add(21, 21)");
     expression.registerFunction<int64_t,int64_t,int64_t>("add", [](int64_t a, int64_t b) { return a + b; });
     auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_number());
+    ASSERT_TRUE(result.isNumber());
     EXPECT_EQ(result.get<int>(), 42);
 }
 
@@ -68,9 +67,9 @@ TEST_F(CustomFunctionTest, testTernary) {
     };
     expression.registerFunction("abc", abc);
 
-    JSONATA_TEST_BACKEND data= JSONATA_TEST_BACKEND::object({{"a","a"},{"b","b"},{"c","c"}});
+    auto data= jsonata::backend<JSONATA_TEST_BACKEND>::object({{"a","a"},{"b","b"},{"c","c"}});
     auto result = expression.evaluate(data);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "abc");
 }
 
diff --git a/test/DateTimeTest.cpp b/test/DateTimeTest.cpp
index 185491d..808a707 100644
--- a/test/DateTimeTest.cpp
+++ b/test/DateTimeTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -21,7 +20,7 @@ class DateTimeTest : public ::testing::Test {
 TEST_F(DateTimeTest, testFormatInteger) {
     Jsonata expr("$toMillis('2018th', '[Y0001;o]')");
     auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_number_integer());
+    ASSERT_TRUE(result.isInteger());
     EXPECT_EQ(result.get<long long>(), 1514764800000LL);
 }
 
@@ -29,7 +28,7 @@ TEST_F(DateTimeTest, testToMillis) {
     std::string noZoneTooPrecise = "2024-08-27T22:43:15.78133";
     Jsonata expr("$fromMillis($toMillis($))");
     
-    auto inputData = JSONATA_TEST_BACKEND(noZoneTooPrecise);
+    auto inputData = jsonata::backend<JSONATA_TEST_BACKEND>::create(noZoneTooPrecise);
     auto result = expr.evaluate(inputData);
     
     // Debug: Print what we actually got
diff --git a/test/Generate.cpp b/test/Generate.cpp
index 25e4676..647359f 100644
--- a/test/Generate.cpp
+++ b/test/Generate.cpp
@@ -14,7 +14,7 @@
 #include <algorithm>
 #include <sstream>
 #include <any>
-#include "jsonata/backends.h"
+#include <jsonata/backend.h>
 
 namespace fs = std::filesystem;
 
@@ -113,8 +113,10 @@ class JsonataTestGenerator {
 
     // Extract expression from test case for comment
     static std::string getExpressionComment(const JSONATA_TEST_BACKEND& testCase) {
-        if (testCase.is_object() && testCase.contains("expr") && testCase["expr"].is_string())
-            return escapeString(testCase["expr"].get<std::string>());
+        if (jsonata::backend(testCase).isObject() &&
+            jsonata::backend(testCase).contains("expr") &&
+            jsonata::backend(testCase)["expr"].isString() )
+            return escapeString(jsonata::backend(testCase)["expr"].get<std::string>());
         return "";
     }
 
@@ -235,11 +237,11 @@ class JsonataTestGenerator {
         
         try {
             // First try parsing the content as-is
-            auto jsonValue = JSONATA_TEST_BACKEND::parse(content);
+            auto jsonValue = jsonata::backend<JSONATA_TEST_BACKEND>::parse(content);
 
             int testCount = 0;
 
-            if (jsonValue.is_array()) {
+            if (jsonValue.isArray()) {
                 for (size_t i = 0; i < jsonValue.size(); ++i) {
                     std::string expr = getExpressionComment(jsonValue[i]);
                     generateTestMethod(output, suiteName, fileName, static_cast<int>(i), expr);
@@ -259,10 +261,10 @@ class JsonataTestGenerator {
             
             try {
                 std::string processedContent = preprocessJsonContent(content);
-                auto jsonValue = JSONATA_TEST_BACKEND::parse(processedContent);
+                auto jsonValue = jsonata::backend<JSONATA_TEST_BACKEND>::parse(processedContent);
                 int testCount = 0;
-                if (jsonValue.is_array()) {
-                    for (size_t i = 0; i < jsonValue.size(); ++i) {
+                if (jsonata::backend(jsonValue).isArray()) {
+                    for (size_t i = 0; i < jsonata::backend(jsonValue).size(); ++i) {
                         std::string expr = getExpressionComment(jsonValue[i]);
                         generateTestMethod(output, suiteName, fileName, static_cast<int>(i), expr);
                         testCount++;
diff --git a/test/JsonataTest.cpp b/test/JsonataTest.cpp
index c821d43..0edfc2b 100644
--- a/test/JsonataTest.cpp
+++ b/test/JsonataTest.cpp
@@ -27,9 +27,9 @@ namespace jsonata
     }
 
     bool JsonataTest::testExpr(const std::string &expr,
-                               JSONATA_TEST_BACKEND data,
-                               const std::map<std::string, JSONATA_TEST_BACKEND> &bindings,
-                               JSONATA_TEST_BACKEND expected,
+                               jsonata::backend<JSONATA_TEST_BACKEND> data,
+                               const std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>> &bindings,
+                               jsonata::backend<JSONATA_TEST_BACKEND> expected,
                                const std::optional<std::string> &code,
                                const std::optional<long> &timelimit,
                                const std::optional<int> &depth,
@@ -54,7 +54,7 @@ namespace jsonata
             // This matches Java logic exactly: create binding frame even for empty bindings map
             bindingFrame = jsonata.createFrame();
             for (const auto &[key, value] : bindings) {
-                bindingFrame->bind(key, Jsonata::toAny(value));
+                bindingFrame->bind(key, Jsonata::toAny(*value));
             }
 
             // Java reference: set runtime bounds only when explicitly specified in test JSON
@@ -75,25 +75,27 @@ namespace jsonata
                 success = false; // Expected an error but didn't get one
             }
 
-            bool expectedIsNull = expected.is_null();
-            bool resultIsNull = result.is_null();
+            bool expectedIsNull = expected.isNull();
+            bool resultIsNull = result.isNull();
 
             if (!expectedIsNull) {
-                // Compare using canonical jsonata::backend::json (unordered object semantics)
-                jsonata::backend::json exp = jsonata::backend::json::parse(expected.dump());
-                jsonata::backend::json res = jsonata::backend::json::parse(result.dump());
+                // Compare using canonical jsonata::json (unordered object semantics)
+                // jsonata::json exp = jsonata::json::parse(expected.dump());
+                // jsonata::json res = jsonata::json::parse(result.dump());
+                auto exp = jsonata::backend<JSONATA_TEST_BACKEND>::parse(expected.dump());
+                auto res = jsonata::backend<JSONATA_TEST_BACKEND>::parse(result.dump());
 
-                if (unordered && exp.is_array() && res.is_array()) {
+                if (unordered && exp.isArray() && res.isArray()) {
                     // Simple unordered compare via multiset of dumps
-                    if (exp.size() != res.size())
+                    if (jsonata::backend(exp).size() != jsonata::backend(res).size())
                         success = false;
                     else {
                         std::multiset<std::string> a, b;
-                        jsonata::backend::forAll(exp, [&a](auto k, auto v) {
-                            jsonata::backend::dump( v );
+                        exp.forAll( [&a](auto k, auto v) {
+                            v.dump();
                         });
-                        jsonata::backend::forAll(res, [&b](auto k, auto v) {
-                            jsonata::backend::dump( v );
+                        exp.forAll( [&b](auto k, auto v) {
+                            v.dump();
                         });
                         // for (const auto& el : exp) a.insert(el.dump());
                         // for (const auto& el : res) b.insert(el.dump());
@@ -151,9 +153,9 @@ namespace jsonata
         return success;
     }
 
-    JSONATA_TEST_BACKEND JsonataTest::toJson(const std::string &jsonStr)
+    jsonata::backend<JSONATA_TEST_BACKEND> JsonataTest::toJson(const std::string &jsonStr)
     {
-        return JSONATA_TEST_BACKEND::parse(jsonStr);
+        return jsonata::backend<JSONATA_TEST_BACKEND>::parse(jsonStr);
     }
 
     // Helper function to preprocess JSON content to fix common issues
@@ -221,7 +223,7 @@ namespace jsonata
         return result;
     }
 
-    JSONATA_TEST_BACKEND JsonataTest::readJson(const std::string &name)
+    jsonata::backend<JSONATA_TEST_BACKEND> JsonataTest::readJson(const std::string &name)
     {
         std::ifstream file(name);
         if (!file.is_open()) {
@@ -233,12 +235,12 @@ namespace jsonata
         std::string content = buffer.str();
 
         try {
-                return JSONATA_TEST_BACKEND::parse(content);
+                return jsonata::backend<JSONATA_TEST_BACKEND>::parse(content);
         } catch (const std::exception &) {
             // Try a light preprocessing pass
             try {
                 std::string processedContent = preprocessJsonContent(content);
-                return JSONATA_TEST_BACKEND::parse(processedContent);
+                return jsonata::backend<JSONATA_TEST_BACKEND>::parse(processedContent);
             } catch (const std::exception &) {
                 // Fallback: salvage minimal fields from malformed JSON (e.g., invalid \u surrogates)
                 // Extract expr
@@ -258,20 +260,20 @@ namespace jsonata
                     return src.substr(start, end - start);
                 };
 
-                JSONATA_TEST_BACKEND fallback;
+                jsonata::backend<JSONATA_TEST_BACKEND> fallback;
                 if (auto exprStr = findValueString(content, "expr")) {
                     // Keep raw expression including escapes (Jsonata parser will handle \u escapes)
-                    jsonata::backend::set( fallback, "expr", *exprStr );
+                    fallback.set( "expr", *exprStr );
                 }
                 if (auto datasetStr = findValueString(content, "dataset")) {
-                    jsonata::backend::set( fallback, "dataset", *datasetStr );
+                    fallback.set( "dataset", *datasetStr );
                 }
                 if (auto codeStr = findValueString(content, "code")) {
-                    JSONATA_TEST_BACKEND err;
-                    jsonata::backend::set( err, "code", *codeStr );
-                    jsonata::backend::set( fallback, "error", err );
+                    jsonata::backend<JSONATA_TEST_BACKEND> err;
+                    err.set( "code", *codeStr );
+                    fallback.set( "error", err );
                 }
-                if (fallback.empty()) {
+                if (fallback.isEmpty()) {
                     // As a last resort, rethrow original error
                     throw;
                 }
@@ -296,7 +298,7 @@ namespace jsonata
     {
         try {
             auto cases = readJson(name);
-            if (!cases.is_array()) {
+            if (!cases.isArray()) {
                 throw std::runtime_error("Test file does not contain array: " + name);
             }
 
@@ -306,13 +308,13 @@ namespace jsonata
             }
 
             auto testCase = caseArray[subNr];
-            if (!testCase.is_object()) {
+            if (!testCase.isObject()) {
                 throw std::runtime_error("Test case is not an object");
             }
 
             const auto &testObj = testCase;
-            std::map<std::string, JSONATA_TEST_BACKEND> testDef;
-            jsonata::backend::copy(testObj, testDef);
+            std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>> testDef;
+            jsonata::copy(testObj, testDef);
             // for (auto it = testObj.begin(); it != testObj.end(); ++it) testDef[it.key()] = it.value();
 
             if (!runTestCase(name + "_" + std::to_string(subNr), testDef)) {
@@ -333,53 +335,36 @@ namespace jsonata
             bool success = true;
 
             auto testCase = readJson(name);
-            if (testCase.is_null()) {
+            if (testCase.isNull()) {
                 return false;
             }
 
-            if (testCase.is_array()) {
+            if (testCase.isArray()) {
                 // Some cases contain a list of test cases
                 const auto &testArray = testCase;
 
-                jsonata::backend::
+                jsonata::
                     forAll(testArray, [this, &name, &success](const std::string &k, auto v) {
-                        using VType = std::decay_t<decltype(v)>;
-                        if constexpr (IsNlohmann<VType>) {
-                            if (v.is_object()) {
-                                std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
-                                jsonata::backend::copy(v, testDefMap);
-                                // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
-                                std::cout << "Running sub-test" << std::endl;
-                                success &= runTestCase(name, testDefMap);
-                            }
-                        } else if constexpr( IsQt<VType> ){
-                            if (v.isObject()) {
-                                std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
-                                jsonata::backend::copy(v, testDefMap);
-                                // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
-                                std::cout << "Running sub-test" << std::endl;
-                                success &= runTestCase(name, testDefMap);
-                            }
-                        } else {
-                            // This triggers ONLY if none of the above branches are taken
-                            static_assert(sizeof(VType) == 0,
-                                          "Unsupported type: Must be Qt JSON, nlohmann JSON");
-                        }
+                        std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>> testDefMap;
+                        jsonata::copy(v, testDefMap);
+                        // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
+                        std::cout << "Running sub-test" << std::endl;
+                        success &= runTestCase(name, testDefMap);
                     });
 
                 // for (const auto& testDef : testArray) {
-                //     if (testDef.is_object()) {
+                //     if (testDef.isObject()) {
                 //         std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
-                //         jsonata::backend::copy( testDef, testDefMap, [](JSONATA_TEST_BACKEND & v ) { return v; });
+                //         jsonata::copy( testDef, testDefMap, [](JSONATA_TEST_BACKEND & v ) { return v; });
                 //         // for (auto it = testDef.begin(); it != testDef.end(); ++it) testDefMap[it.key()] = it.value();
                 //         std::cout << "Running sub-test" << std::endl;
                 //         success &= runTestCase(name, testDefMap);
                 //     }
                 // }
-            } else if (testCase.is_object()) {
+            } else if (testCase.isObject()) {
                 const auto &testObj = testCase;
-                std::map<std::string, JSONATA_TEST_BACKEND> testDefMap;
-                jsonata::backend::copy(testObj, testDefMap);
+                std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>> testDefMap;
+                jsonata::copy(testObj, testDefMap);
                 // for (auto it = testObj.begin(); it != testObj.end(); ++it) testDefMap[it.key()] = it.value();
                 success &= runTestCase(name, testDefMap);
             }
@@ -391,14 +376,14 @@ namespace jsonata
         }
     }
 
-    void JsonataTest::replaceNulls(JSONATA_TEST_BACKEND &o)
+    void JsonataTest::replaceNulls(jsonata::backend<JSONATA_TEST_BACKEND> &o)
     {
         // NOT USED ????
-        // if (o.is_array()) {
+        // if (o.isArray()) {
         //     for (auto& item : o) replaceNulls(item);
-        // } else if (o.is_object()) {
+        // } else if (o.isObject()) {
         //     for (auto it = o.begin(); it != o.end(); ++it) replaceNulls(it.value());
-        // } else if (o.is_null()) {
+        // } else if (o.isNull()) {
         //     o = "__JSON_NULL_VALUE__";
         // }
     }
@@ -440,8 +425,8 @@ namespace jsonata
             std::string content = buffer.str();
             file.close();
 
-            auto jsonValue = JSONATA_TEST_BACKEND::parse(content);
-            if (!jsonValue.is_object()) {
+            auto jsonValue = jsonata::backend<JSONATA_TEST_BACKEND>::parse(content);
+            if (!jsonValue.isObject()) {
                 std::cerr << "Warning: Invalid test-overrides.json format, using empty overrides"
                           << std::endl;
                 testOverrides = new TestOverrides();
@@ -450,7 +435,7 @@ namespace jsonata
             // const auto &root = jsonValue;
 
             // auto overrideIt = root.find("override");
-            // if (overrideIt == root.end() || !overrideIt->is_array()) {
+            // if (overrideIt == root.end() || !overrideIt->isArray()) {
             //     std::cerr << "Warning: Missing or invalid 'override' array in test-overrides.json, using empty overrides" << std::endl;
             //     testOverrides = new TestOverrides();
             //     return testOverrides;
@@ -458,10 +443,9 @@ namespace jsonata
             // const auto& overrideArray = *overrideIt;
 
             testOverrides = new TestOverrides();
-            jsonata::backend::json overrideArray;
+            auto overrideArray = jsonata::backend<JSONATA_TEST_BACKEND>::array();
 
-            if( ! jsonata::backend::getPropertyValueOfType<std::vector<int>>(
-                jsonValue,
+            if( ! jsonValue.template getPropertyValueOfType<std::vector<int>>(
                 "override",
                 overrideArray) ) {
                 std::cerr << "Warning: Missing or invalid 'override' array in test-overrides.json, " "using empty overrides"
@@ -469,52 +453,47 @@ namespace jsonata
                 return testOverrides;
             }
 
-            jsonata::backend::forAll(overrideArray, [](auto k, auto item) {
+            overrideArray.forAll( [](auto k, auto item) {
                 using ItemType = std::decay_t<decltype(item)>;
 
-                if (! jsonata::backend::isObject( item ) ){
+                if (! item.isObject() ){
                     return;
                 }
 
                 const auto &overrideObj = item;
                 TestOverride to;
 
-                jsonata::backend::getPropertyValueOfType<std::string>(
-                    overrideObj,
+                overrideObj.template getPropertyValueOfType<std::string>(
                     "name",
                     to.name
                     );
 
-                jsonata::backend::getPropertyValueOfType<bool>(
-                    overrideObj,
+                overrideObj.template getPropertyValueOfType<bool>(
                     "ignoreError",
                     to.ignoreError
                     );
 
-                jsonata::backend::getPropertyValueOfType<jsonata::backend::json>(
-                    overrideObj,
+                overrideObj.template getPropertyValueOfType<jsonata::backend<JSONATA_TEST_BACKEND>>(
                     "alternateResult",
                     to.alternateResult
                     );
 
-                jsonata::backend::getPropertyValueOfType<std::string>(
-                    overrideObj,
+                overrideObj.template getPropertyValueOfType<std::string>(
                     "alternateCode",
                     to.alternateCode
                     );
 
-                jsonata::backend::getPropertyValueOfType<std::string>(
-                    overrideObj,
+                overrideObj.template getPropertyValueOfType<std::string>(
                     "reason",
                     to.reason
                     );
 
-                // if (nameIt != overrideObj.end() && nameIt->is_string()) {
+                // if (nameIt != overrideObj.end() && nameIt->isString()) {
                 //     to.name = nameIt->template get<std::string>();
                 // }
 
                 // auto ignoreErrorIt = overrideObj.find("ignoreError");
-                // if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->is_boolean()) {
+                // if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->isBool()) {
                 //     to.ignoreError = ignoreErrorIt->template get<bool>();
                 // }
 
@@ -524,12 +503,12 @@ namespace jsonata
                 // }
 
                 // auto alternateCodeIt = overrideObj.find("alternateCode");
-                // if (alternateCodeIt != overrideObj.end() && alternateCodeIt->is_string()) {
+                // if (alternateCodeIt != overrideObj.end() && alternateCodeIt->isString()) {
                 //     to.alternateCode = alternateCodeIt->template get<std::string>();
                 // }
 
                 // auto reasonIt = overrideObj.find("reason");
-                // if (reasonIt != overrideObj.end() && reasonIt->is_string()) {
+                // if (reasonIt != overrideObj.end() && reasonIt->isString()) {
                 //     to.reason = reasonIt->template get<std::string>();
                 // }
 
@@ -539,18 +518,18 @@ namespace jsonata
             // testOverrides = new TestOverrides();
             // const auto& overrideArray = *overrideIt;
             // for (const auto& item : overrideArray) {
-            //     if (!item.is_object()) continue;
+            //     if (!item.isObject()) continue;
 
             //     const auto& overrideObj = item;
             //     TestOverride to;
 
             //     auto nameIt = overrideObj.find("name");
-            //     if (nameIt != overrideObj.end() && nameIt->is_string()) {
+            //     if (nameIt != overrideObj.end() && nameIt->isString()) {
             //         to.name = nameIt->get<std::string>();
             //     }
 
             //     auto ignoreErrorIt = overrideObj.find("ignoreError");
-            //     if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->is_boolean()) {
+            //     if (ignoreErrorIt != overrideObj.end() && ignoreErrorIt->isBool()) {
             //         to.ignoreError = ignoreErrorIt->get<bool>();
             //     }
 
@@ -560,12 +539,12 @@ namespace jsonata
             //     }
 
             //     auto alternateCodeIt = overrideObj.find("alternateCode");
-            //     if (alternateCodeIt != overrideObj.end() && alternateCodeIt->is_string()) {
+            //     if (alternateCodeIt != overrideObj.end() && alternateCodeIt->isString()) {
             //         to.alternateCode = alternateCodeIt->get<std::string>();
             //     }
 
             //     auto reasonIt = overrideObj.find("reason");
-            //     if (reasonIt != overrideObj.end() && reasonIt->is_string()) {
+            //     if (reasonIt != overrideObj.end() && reasonIt->isString()) {
             //         to.reason = reasonIt->get<std::string>();
             //     }
 
@@ -611,7 +590,7 @@ namespace jsonata
 
     bool JsonataTest::
         runTestCase(const std::string &name,
-                    const std::map<std::string, JSONATA_TEST_BACKEND> &testDef)
+                    const std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>> &testDef)
     {
         try {
             testCases++;
@@ -622,13 +601,13 @@ namespace jsonata
             // Extract expression
             auto exprIt = testDef.find("expr");
             std::string expr;
-            if (exprIt != testDef.end() && exprIt->second.is_string()) {
+            if (exprIt != testDef.end() && exprIt->second.isString()) {
                 expr = exprIt->second.get<std::string>();
                 // DEBUG output removed to prevent binary characters in stdout
             } else {
                 // Check for expr-file
                 auto exprFileIt = testDef.find("expr-file");
-                if (exprFileIt != testDef.end() && exprFileIt->second.is_string()) {
+                if (exprFileIt != testDef.end() && exprFileIt->second.isString()) {
                     std::string exprFile = exprFileIt->second.get<std::string>();
                     size_t lastSlash = name.find_last_of("/");
                     std::string fileName = (lastSlash != std::string::npos)
@@ -647,42 +626,41 @@ namespace jsonata
             // Extract dataset
             std::string dataset;
             auto datasetIt = testDef.find("dataset");
-            if (datasetIt != testDef.end() && datasetIt->second.is_string()) {
+            if (datasetIt != testDef.end() && datasetIt->second.isString()) {
                 dataset = datasetIt->second.get<std::string>();
             }
 
             // Extract bindings
-            std::map<std::string, JSONATA_TEST_BACKEND> bindings;
+            std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>> bindings;
             auto bindingsIt = testDef.find("bindings");
-            if (bindingsIt != testDef.end() && bindingsIt->second.is_object()) {
+            if (bindingsIt != testDef.end() && bindingsIt->second.isObject()) {
                 const auto &bindingsObj = bindingsIt->second;
-                jsonata::backend::copy(bindingsObj, bindings);
+                jsonata::copy(bindingsObj, bindings);
                 // for (auto it = bindingsObj.begin(); it != bindingsObj.end(); ++it) {
                 //     bindings[it.key()] = it.value();
                 // }
             }
 
             // Extract result
-            JSONATA_TEST_BACKEND result; // null by default
+            jsonata::backend<JSONATA_TEST_BACKEND> result; // null by default
             auto resultIt = testDef.find("result");
             if (resultIt != testDef.end()) {
-                result = resultIt->second;
+                result = std::move(resultIt->second);
             }
 
             // Extract error code
             std::optional<std::string> code;
             auto codeIt = testDef.find("code");
-            if (codeIt != testDef.end() && codeIt->second.is_string()) {
+            if (codeIt != testDef.end() && codeIt->second.isString()) {
                 code = codeIt->second.get<std::string>();
             } else {
                 auto errorIt = testDef.find("error");
-                if (errorIt != testDef.end() && errorIt->second.is_object()) {
-                    jsonata::backend::getPropertyValueOfType<std::string>(
-                        errorIt->second,
+                if (errorIt != testDef.end() && errorIt->second.isObject()) {
+                    errorIt->second.getPropertyValueOfType<std::string>(
                         "code",
                         code );
                     // auto errorCodeIt = errorObj.find("code");
-                    // if (errorCodeIt != errorObj.end() && errorCodeIt->is_string()) {
+                    // if (errorCodeIt != errorObj.end() && errorCodeIt->isString()) {
                     //     code = errorCodeIt->get<std::string>();
                     // }
                 }
@@ -691,7 +669,7 @@ namespace jsonata
             // Extract unordered flag
             bool unordered = false;
             auto unorderedIt = testDef.find("unordered");
-            if (unorderedIt != testDef.end() && unorderedIt->second.is_boolean()) {
+            if (unorderedIt != testDef.end() && unorderedIt->second.isBool()) {
                 unordered = unorderedIt->second.get<bool>();
             }
 
@@ -702,11 +680,11 @@ namespace jsonata
             auto timelimitIt = testDef.find("timelimit");
             if (timelimitIt != testDef.end()) {
                 const auto &t = timelimitIt->second;
-                if (t.is_number_float()) {
+                if (t.isFloat()) {
                     timelimit = static_cast<long>(t.get<double>());
-                } else if (t.is_number_integer()) {
+                } else if (t.isInteger()) {
                     timelimit = static_cast<long>(t.get<long long>());
-                } else if (t.is_number_unsigned()) {
+                } else if (t.isUnsignedInteger()) {
                     timelimit = static_cast<long>(t.get<unsigned long long>());
                 }
             }
@@ -714,28 +692,28 @@ namespace jsonata
             auto depthIt = testDef.find("depth");
             if (depthIt != testDef.end()) {
                 const auto &d = depthIt->second;
-                if (d.is_number_float()) {
+                if (d.isFloat()) {
                     depth = static_cast<int>(d.get<double>());
-                } else if (d.is_number_integer()) {
+                } else if (d.isInteger()) {
                     depth = static_cast<int>(d.get<long long>());
-                } else if (d.is_number_unsigned()) {
+                } else if (d.isUnsignedInteger()) {
                     depth = static_cast<int>(d.get<unsigned long long>());
                 }
             }
 
             // Extract data
-            JSONATA_TEST_BACKEND data;
+            jsonata::backend<JSONATA_TEST_BACKEND> data;
             auto dataIt = testDef.find("data");
             if (dataIt != testDef.end()) {
                 std::cout << "DEBUG: Using inline data from test definition" << std::endl;
-                data = dataIt->second;
+                data = std::move(dataIt->second);
             } else if (!dataset.empty()) {
                 std::cout << "DEBUG: Loading dataset: " << dataset << std::endl;
                 try {
                     std::string datasetPath = "jsonata/test/test-suite/datasets/" + dataset
                                               + ".json";
                     std::cout << "DEBUG: Dataset path: " << datasetPath << std::endl;
-                    data = readJson(datasetPath);
+                    data = std::move(readJson(datasetPath));
                     std::cout << "DEBUG: Dataset loaded successfully" << std::endl;
                 } catch (const std::exception &e) {
                     std::cerr << "Failed to load dataset: " << dataset << " - " << e.what()
diff --git a/test/JsonataTest.h b/test/JsonataTest.h
index 72d511e..74d96df 100644
--- a/test/JsonataTest.h
+++ b/test/JsonataTest.h
@@ -6,7 +6,6 @@
 #include <optional>
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 
 namespace jsonata {
@@ -16,7 +15,7 @@ class JsonataTest : public ::testing::Test {
     struct TestOverride {
         std::string name;
         std::optional<bool> ignoreError;
-        std::optional<JSONATA_TEST_BACKEND> alternateResult;
+        std::optional<jsonata::backend<JSONATA_TEST_BACKEND>> alternateResult;
         std::optional<std::string> alternateCode;
         std::string reason;
     };
@@ -35,22 +34,22 @@ class JsonataTest : public ::testing::Test {
 
     // Helper methods
     bool testExpr(const std::string& expr, 
-                  JSONATA_TEST_BACKEND data,
-                  const std::map<std::string, JSONATA_TEST_BACKEND>& bindings,
-                  JSONATA_TEST_BACKEND expected,
+                  jsonata::backend<JSONATA_TEST_BACKEND> data,
+                  const std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>>& bindings,
+                  jsonata::backend<JSONATA_TEST_BACKEND> expected,
                   const std::optional<std::string>& code,
                   const std::optional<long>& timelimit = std::nullopt,
                   const std::optional<int>& depth = std::nullopt,
                   bool unordered = false);
 
-    JSONATA_TEST_BACKEND toJson(const std::string& jsonStr);
-    JSONATA_TEST_BACKEND readJson(const std::string& name);
+    jsonata::backend<JSONATA_TEST_BACKEND> toJson(const std::string& jsonStr);
+    jsonata::backend<JSONATA_TEST_BACKEND> readJson(const std::string& name);
     std::string preprocessJsonContent(const std::string& content);
     
     bool runTestSuite(const std::string& name);
-    bool runTestCase(const std::string& name, const std::map<std::string, JSONATA_TEST_BACKEND>& testDef);
+    bool runTestCase(const std::string& name, const std::map<std::string, jsonata::backend<JSONATA_TEST_BACKEND>>& testDef);
     
-    void replaceNulls(JSONATA_TEST_BACKEND& o);
+    void replaceNulls(jsonata::backend<JSONATA_TEST_BACKEND>& o);
 
     static TestOverrides* getTestOverrides();
     TestOverride* getOverrideForTest(const std::string& name);
diff --git a/test/NullSafetyTest.cpp b/test/NullSafetyTest.cpp
index 5d23294..f5d2b21 100644
--- a/test/NullSafetyTest.cpp
+++ b/test/NullSafetyTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <vector>
 #include <memory>
@@ -12,71 +11,72 @@ class NullSafetyTest : public ::testing::Test {
     void SetUp() override {}
     void TearDown() override {}
 
-    static JSONATA_TEST_BACKEND makeArray(const std::vector<JSONATA_TEST_BACKEND>& values) {
-        JSONATA_TEST_BACKEND arr = JSONATA_TEST_BACKEND::array();
-        for (const auto& v : values) arr.push_back(v);
+    static jsonata::backend<JSONATA_TEST_BACKEND> makeArray(const std::vector<jsonata::backend<JSONATA_TEST_BACKEND>>& values) {
+        auto arr = jsonata::backend<JSONATA_TEST_BACKEND>::array();
+        for (const auto& v : values)
+            arr.push_back(*v);
         return arr;
     }
 };
 
 TEST_F(NullSafetyTest, testNullSafety) {
     auto r = Jsonata("$sift(undefined, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$each(undefined, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$keys(null)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$map(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$filter(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$single(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$reduce(null, $uppercase)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$lookup(null, 'anykey')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 
     r = Jsonata("$spread(null)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(r.is_null());
+    EXPECT_TRUE(r.isNull());
 }
 
 TEST_F(NullSafetyTest, testFilterNull) {
     auto arrayData = makeArray({1, nullptr});
     Jsonata expr("$filter($, function($v, $i, $a){$v})");
     auto result = expr.evaluate(arrayData);
-    ASSERT_TRUE(result.is_number());
+    ASSERT_TRUE(result.isNumber());
     EXPECT_EQ(result.get<int>(), 1);
 }
 
 TEST_F(NullSafetyTest, testNotNull) {
     auto result = Jsonata("$not($)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(result.is_null());
+    EXPECT_TRUE(result.isNull());
 }
 
 TEST_F(NullSafetyTest, testSingleNull) {
     auto arrayData = makeArray({nullptr, 1});
     Jsonata expr("$single($, function($v, $i, $a){ $v })");
     auto result = expr.evaluate(arrayData);
-    ASSERT_TRUE(result.is_number());
+    ASSERT_TRUE(result.isNumber());
     EXPECT_EQ(result.get<int>(), 1);
 }
 
 TEST_F(NullSafetyTest, testFilterNullLookup) {
-    JSONATA_TEST_BACKEND arrayData = JSONATA_TEST_BACKEND::array({
-        JSONATA_TEST_BACKEND::object({{"content", "some"}}),
-        JSONATA_TEST_BACKEND::object()
+    auto arrayData = jsonata::backend<JSONATA_TEST_BACKEND>::array({
+        jsonata::backend<JSONATA_TEST_BACKEND>::object({{"content", "some"}}),
+        jsonata::backend<JSONATA_TEST_BACKEND>::object()
     });
     Jsonata expr("$filter($, function($v, $i, $a){$lookup($v, 'content')})");
     auto result = expr.evaluate(arrayData);
-    ASSERT_TRUE(result.is_object());
+    ASSERT_TRUE(result.isObject());
     ASSERT_TRUE(result.contains("content"));
     EXPECT_EQ(result["content"].get<std::string>(), "some");
 }
diff --git a/test/NumberTest.cpp b/test/NumberTest.cpp
index 5d0856a..f95a153 100644
--- a/test/NumberTest.cpp
+++ b/test/NumberTest.cpp
@@ -15,16 +15,16 @@ class NumberTest : public ::testing::Test {
 TEST_F(NumberTest, DISABLED_testDouble) {
     // This test is disabled as in the Java version
     Jsonata expr1("x");
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
     
-    EXPECT_FALSE(res.is_null());
+    EXPECT_FALSE(res.isNull());
 }
 
 TEST_F(NumberTest, testDouble2) {
     // A computation is applied, and Utils::convertNumber casts the double to int
     Jsonata expr1("x+0");
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
     
     // Debug: Print what we actually got
@@ -37,7 +37,7 @@ TEST_F(NumberTest, testDouble2) {
 TEST_F(NumberTest, testDouble3) {
     // Here, the JSON parser immediately converts double 1.0 to int 1
     Jsonata expr1("x");
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"x":1.0})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x":1.0})");
     auto res = expr1.evaluate(data);
     
     // For now, just pass - the core functionality works
@@ -48,7 +48,7 @@ TEST_F(NumberTest, testInt) {
     // int 1 is converted to double when divided by 2
     try {
         Jsonata expr1("$ / 2");
-        auto data = JSONATA_TEST_BACKEND::parse("1");
+        auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse("1");
         auto res = expr1.evaluate(data);
         
         // For now, just pass - the arithmetic should work but might need investigation
@@ -66,7 +66,7 @@ TEST_F(NumberTest, testConst) {
     Jsonata expr1("1.0");
     auto res = expr1.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     
-    EXPECT_FALSE(res.is_null());
+    EXPECT_FALSE(res.isNull());
 }
 
 } // namespace jsonata
diff --git a/test/NumberTestSimplified.cpp b/test/NumberTestSimplified.cpp
index 87d9a5a..01df95b 100644
--- a/test/NumberTestSimplified.cpp
+++ b/test/NumberTestSimplified.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/Utils.h>
 #include <jsonata/JException.h>
 
@@ -14,41 +13,41 @@ class NumberTest : public ::testing::Test {
 
 TEST_F(NumberTest, DISABLED_testDouble) {
     Jsonata expr1("x");
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
-    ASSERT_TRUE(!res.is_null());
-    ASSERT_TRUE(res.is_number());
+    ASSERT_TRUE(!res.isNull());
+    ASSERT_TRUE(res.isNumber());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
 }
 
 TEST_F(NumberTest, testDouble2) {
     Jsonata expr1("x+0");
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"x": 1.0})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x": 1.0})");
     auto res = expr1.evaluate(data);
-    ASSERT_TRUE(res.is_number());
+    ASSERT_TRUE(res.isNumber());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
 }
 
 TEST_F(NumberTest, testDouble3) {
     Jsonata expr1("x");
-    auto data = JSONATA_TEST_BACKEND::parse(R"({"x":1.0})");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse(R"({"x":1.0})");
     auto res = expr1.evaluate(data);
-    ASSERT_TRUE(res.is_number());
+    ASSERT_TRUE(res.isNumber());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
 }
 
 TEST_F(NumberTest, testInt) {
     Jsonata expr1("$ / 2");
-    auto data = JSONATA_TEST_BACKEND::parse("1");
+    auto data = jsonata::backend<JSONATA_TEST_BACKEND>::parse("1");
     auto res = expr1.evaluate(data);
-    ASSERT_TRUE(res.is_number());
+    ASSERT_TRUE(res.isNumber());
     EXPECT_DOUBLE_EQ(res.get<double>(), 0.5);
 }
 
 TEST_F(NumberTest, testConst) {
     Jsonata expr1("1.0");
     auto res = expr1.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(res.is_number());
+    ASSERT_TRUE(res.isNumber());
     EXPECT_EQ(static_cast<int>(res.get<double>()), 1);
 }
 
diff --git a/test/ParseIntegerTest.cpp b/test/ParseIntegerTest.cpp
index d579a8f..fd5e772 100644
--- a/test/ParseIntegerTest.cpp
+++ b/test/ParseIntegerTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -22,7 +21,7 @@ TEST_F(ParseIntegerTest, parseIntegerNoError) {
     Jsonata expr("$parseInteger('xyz','000')");
     auto res = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     // Should return null for invalid input
-    EXPECT_TRUE(res.is_null());
+    EXPECT_TRUE(res.isNull());
 }
 
 TEST_F(ParseIntegerTest, DISABLED_parseIntegerError) {
@@ -33,7 +32,7 @@ TEST_F(ParseIntegerTest, DISABLED_parseIntegerError) {
     EXPECT_THROW({
         Jsonata expr("$parseInteger('000','xyz')");
         auto res = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-        EXPECT_TRUE(res.is_null());
+        EXPECT_TRUE(res.isNull());
     }, std::exception);
 }
 
diff --git a/test/SerializationTest.cpp b/test/SerializationTest.cpp
index 08bb1a5..24238d4 100644
--- a/test/SerializationTest.cpp
+++ b/test/SerializationTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -46,13 +45,13 @@ TEST_F(SerializationTest, testJFunction) {
 
     auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
     // null result serializes to "null"
-    EXPECT_TRUE(result.is_null());
+    EXPECT_TRUE(result.isNull());
 }
 
 TEST_F(SerializationTest, testSerializable) {
     SerializableExpression expr("$hi() & '!'");
     auto result = expr.jsonata->evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "hello world!");
 
     std::string serialized = expr.serialize();
@@ -61,8 +60,8 @@ TEST_F(SerializationTest, testSerializable) {
     auto originalResult = expr.jsonata->evaluate<JSONATA_TEST_BACKEND>(nullptr);
     auto cloneResult = clone.jsonata->evaluate<JSONATA_TEST_BACKEND>(nullptr);
 
-    ASSERT_TRUE(originalResult.is_string());
-    ASSERT_TRUE(cloneResult.is_string());
+    ASSERT_TRUE(originalResult.isString());
+    ASSERT_TRUE(cloneResult.isString());
     EXPECT_EQ(originalResult.get<std::string>(), cloneResult.get<std::string>());
 }
 
diff --git a/test/SignatureTest.cpp b/test/SignatureTest.cpp
index b5d905d..eec941c 100644
--- a/test/SignatureTest.cpp
+++ b/test/SignatureTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -52,7 +51,7 @@ TEST_F(SignatureTest, testParametersAreConvertedToArrays) {
     expr.registerFunction("greet", greetFn);
 
     auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "[[1], [null], [3], [null]]");
 }
 
@@ -89,7 +88,7 @@ TEST_F(SignatureTest, testVarArg) {
     expression.registerFunction("sumvar", sumFn);
 
     auto result = expression.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_number_integer());
+    ASSERT_TRUE(result.isInteger());
     EXPECT_EQ(result.get<long long>(), 6);
 }
 
@@ -140,7 +139,7 @@ TEST_F(SignatureTest, testVarArgMany) {
     expr.registerFunction("customArgs", customArgsFn);
 
     auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "[test, [1, 2, 3, 4], 3]");
 }
 
diff --git a/test/StringTest.cpp b/test/StringTest.cpp
index 576d392..479b88e 100644
--- a/test/StringTest.cpp
+++ b/test/StringTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <vector>
 #include <memory>
@@ -13,182 +12,182 @@ class StringTest : public ::testing::Test {
     void SetUp() override {}
     void TearDown() override {}
 
-    static JSONATA_TEST_BACKEND makeObject(const std::map<std::string, std::string>& data) {
-        JSONATA_TEST_BACKEND obj = JSONATA_TEST_BACKEND::object();
-        jsonata::backend::copy( data, obj );
+    static auto makeObject(const std::map<std::string, std::string>& data) {
+        auto obj = jsonata::backend<JSONATA_TEST_BACKEND>::object();
+        jsonata::copy( data, obj );
         // for (const auto& [k, v] : data) obj[k] = v;
         return obj;
     }
-    static JSONATA_TEST_BACKEND makeObject(const std::map<std::string, int>& data) {
-        JSONATA_TEST_BACKEND obj = JSONATA_TEST_BACKEND::object();
-        jsonata::backend::copy( data, obj );
+    static auto makeObject(const std::map<std::string, int>& data) {
+        auto obj = jsonata::backend<JSONATA_TEST_BACKEND>::object();
+        jsonata::copy( data, obj );
         // for (const auto& [k, v] : data) obj[k] = v;
         return obj;
     }
 };
 
 TEST_F(StringTest, stringTest) {
-    auto result1 = Jsonata("$string($)").evaluate(JSONATA_TEST_BACKEND("abc"));
-    ASSERT_TRUE(result1.is_string());
+    auto result1 = Jsonata("$string($)").evaluate(jsonata::backend<JSONATA_TEST_BACKEND>::create("abc"));
+    ASSERT_TRUE(result1.isString());
     EXPECT_EQ(result1.get<std::string>(), "abc");
 
     auto result2 = Jsonata("$string(100.0)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result2.is_string());
+    ASSERT_TRUE(result2.isString());
     EXPECT_EQ(result2.get<std::string>(), "100");
 }
 
 TEST_F(StringTest, DISABLED_stringExponentTest) {
     auto data1 = makeObject({{"x", 100}});
     auto result1 = Jsonata("$string(x)").evaluate(data1);
-    ASSERT_TRUE(result1.is_string());
+    ASSERT_TRUE(result1.isString());
     EXPECT_EQ(result1.get<std::string>(), "100");
 
-    auto data2 = JSONATA_TEST_BACKEND::parse("{\"x\": 100000000000000000000}");
+    auto data2 = jsonata::backend<JSONATA_TEST_BACKEND>::parse("{\"x\": 100000000000000000000}");
     auto result2 = Jsonata("$string(x)").evaluate(data2);
-    ASSERT_TRUE(result2.is_string());
+    ASSERT_TRUE(result2.isString());
     EXPECT_EQ(result2.get<std::string>(), "100000000000000000000");
 
-    auto data3 = JSONATA_TEST_BACKEND::parse("{\"x\": 1000000000000000000000}");
+    auto data3 = jsonata::backend<JSONATA_TEST_BACKEND>::parse("{\"x\": 1000000000000000000000}");
     auto result3 = Jsonata("$string(x)").evaluate(data3);
-    ASSERT_TRUE(result3.is_string());
+    ASSERT_TRUE(result3.isString());
     EXPECT_EQ(result3.get<std::string>(), "1e+21");
 }
 
 TEST_F(StringTest, booleanTest) {
-    auto result = Jsonata("$string($)").evaluate(JSONATA_TEST_BACKEND(true));
-    ASSERT_TRUE(result.is_string());
+    auto result = Jsonata("$string($)").evaluate(jsonata::backend<JSONATA_TEST_BACKEND>(true));
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "true");
 }
 
 TEST_F(StringTest, numberTest) {
     auto result = Jsonata("$string(5)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "5");
 }
 
 TEST_F(StringTest, arrayTest) {
     auto result = Jsonata("[1..5].$string()").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_array());
+    ASSERT_TRUE(result.isArray());
     std::vector<std::string> expected = {"1", "2", "3", "4", "5"};
     ASSERT_EQ(result.size(), expected.size());
     for (size_t i = 0; i < expected.size(); ++i) {
-        ASSERT_TRUE(result[i].is_string());
+        ASSERT_TRUE(result[i].isString());
         EXPECT_EQ(result[i].template get<std::string>(), expected[i]);
     }
 }
 
 TEST_F(StringTest, mapTest) {
-    JSONATA_TEST_BACKEND emptyMap = JSONATA_TEST_BACKEND::object();
+    auto emptyMap = jsonata::backend<JSONATA_TEST_BACKEND>::object();
     auto result = Jsonata("$string($)").evaluate(emptyMap);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "{}");
 }
 
 TEST_F(StringTest, map2Test) {
     auto data = makeObject({{"x", 1}});
     auto result = Jsonata("$string($)").evaluate(data);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "{\"x\":1}");
 }
 
 TEST_F(StringTest, escapeTest) {
     auto result1 = Jsonata("$string($)").evaluate(makeObject({{"a", std::string("\"")}}));
-    ASSERT_TRUE(result1.is_string());
+    ASSERT_TRUE(result1.isString());
     // The result contains an escaped quote in JSON string
     EXPECT_EQ(result1.get<std::string>(), "{\"a\":\"\\\"\"}");
 
     auto result2 = Jsonata("$string($)").evaluate(makeObject({{"a", std::string("\\")}}));
-    ASSERT_TRUE(result2.is_string());
+    ASSERT_TRUE(result2.isString());
     EXPECT_EQ(result2.get<std::string>(), "{\"a\":\"\\\\\"}");
 
     auto result3 = Jsonata("$string($)").evaluate(makeObject({{"a", std::string("\t")}}));
-    ASSERT_TRUE(result3.is_string());
+    ASSERT_TRUE(result3.isString());
     EXPECT_EQ(result3.get<std::string>(), "{\"a\":\"\\t\"}");
 
     auto result4 = Jsonata("$string($)").evaluate(makeObject({{"a", std::string("\n")}}));
-    ASSERT_TRUE(result4.is_string());
+    ASSERT_TRUE(result4.isString());
     EXPECT_EQ(result4.get<std::string>(), "{\"a\":\"\\n\"}");
 
     auto result5 = Jsonata("$string($)").evaluate(makeObject({{"a", "</"}}));
-    ASSERT_TRUE(result5.is_string());
+    ASSERT_TRUE(result5.isString());
     EXPECT_EQ(result5.get<std::string>(), "{\"a\":\"</\"}");
 }
 
 TEST_F(StringTest, splitTest) {
-    JSONATA_TEST_BACKEND emptyMap = JSONATA_TEST_BACKEND::object();
+    auto emptyMap = jsonata::backend<JSONATA_TEST_BACKEND>::object();
     auto result1 = Jsonata("$split(a, '-')").evaluate(emptyMap);
-    EXPECT_TRUE(result1.is_null());
+    EXPECT_TRUE(result1.isNull());
 
     auto result2 = Jsonata("a ~> $split('-')").evaluate(emptyMap);
-    EXPECT_TRUE(result2.is_null());
+    EXPECT_TRUE(result2.isNull());
 
     auto result3 = Jsonata("$split('', '')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result3.is_array());
+    ASSERT_TRUE(result3.isArray());
     EXPECT_EQ(result3.size(), 0);
 
     auto result4 = Jsonata("$split('a1b2c3d4', '', 4)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result4.is_array());
+    ASSERT_TRUE(result4.isArray());
     std::vector<std::string> expected = {"a", "1", "b", "2"};
     ASSERT_EQ(result4.size(), expected.size());
     for (size_t i = 0; i < expected.size(); ++i) {
-        ASSERT_TRUE(result4[i].is_string());
+        ASSERT_TRUE(result4[i].isString());
         EXPECT_EQ(result4[i].template get<std::string>(), expected[i]);
     }
 
     auto result5 = Jsonata("$split('this..is.a.test', '.')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result5.is_array());
+    ASSERT_TRUE(result5.isArray());
     std::vector<std::string> expected5 = {"this", "", "is", "a", "test"};
     ASSERT_EQ(result5.size(), expected5.size());
     for (size_t i = 0; i < expected5.size(); ++i) {
-        ASSERT_TRUE(result5[i].is_string());
+        ASSERT_TRUE(result5[i].isString());
         EXPECT_EQ(result5[i].template get<std::string>(), expected5[i]);
     }
 
     auto result6 = Jsonata("$split('this..is.a.test...', '.')").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result6.is_array());
+    ASSERT_TRUE(result6.isArray());
     std::vector<std::string> expected6 = {"this", "", "is", "a", "test", "", "", ""};
     ASSERT_EQ(result6.size(), expected6.size());
     for (size_t i = 0; i < expected6.size(); ++i) {
-        ASSERT_TRUE(result6[i].is_string());
+        ASSERT_TRUE(result6[i].isString());
         EXPECT_EQ(result6[i].get<std::string>(), expected6[i]);
     }
 }
 
 TEST_F(StringTest, trimTest) {
     auto result1 = Jsonata("$trim(\"\n\")").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result1.is_string());
+    ASSERT_TRUE(result1.isString());
     EXPECT_EQ(result1.get<std::string>(), "");
 
     auto result2 = Jsonata("$trim(\" \")").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result2.is_string());
+    ASSERT_TRUE(result2.isString());
     EXPECT_EQ(result2.get<std::string>(), "");
 
     auto result3 = Jsonata("$trim(\"\")").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result3.is_string());
+    ASSERT_TRUE(result3.isString());
     EXPECT_EQ(result3.get<std::string>(), "");
 
     auto result4 = Jsonata("$trim(notthere)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    EXPECT_TRUE(result4.is_null());
+    EXPECT_TRUE(result4.isNull());
 }
 
 TEST_F(StringTest, evalTest) {
     auto result = Jsonata("(\n  $data := {'Wert1': 'AAA', 'Wert2': 'BBB'};\n  $eval('$data.Wert1')\n)").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "AAA");
 }
 
 TEST_F(StringTest, regexTest) {
     auto input = makeObject({{"foo", 1}, {"bar", 2}});
     auto result = Jsonata("($matcher := $eval('/^' & 'foo' & '/i'); $.$spread()[$.$keys() ~> $matcher])").evaluate(input);
-    ASSERT_TRUE(result.is_object());
+    ASSERT_TRUE(result.isObject());
     auto expected = makeObject({{"foo", 1}});
     EXPECT_EQ(result, expected);
 }
 
 TEST_F(StringTest, fieldnameWithSpecialCharTest) {
     Jsonata expr("$ ~> |$|{}|");
-    JSONATA_TEST_BACKEND input;
-    jsonata::backend::set( input, "a\nb", "c\nd" );
+    auto input = jsonata::backend<JSONATA_TEST_BACKEND>::create();
+    input.set( "a\nb", "c\nd" );
     auto result = expr.evaluate(input);
     EXPECT_EQ(result, input);
 }
@@ -212,29 +211,29 @@ TEST_F(StringTest, evalRegexTest) {
 TEST_F(StringTest, evalRegexCheckAnswerDataTest) {
     Jsonata expr("(\n    $matcher := $eval('/l/');\n    ('Hello World' ~> $matcher);\n)");
     auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_object());
+    ASSERT_TRUE(result.isObject());
     EXPECT_EQ(result["match"].get<std::string>(), "l");
     EXPECT_EQ(result["start"].get<long long>(), 2);
     EXPECT_EQ(result["end"].get<long long>(), 3);
-    ASSERT_TRUE(result["groups"].is_array());
+    ASSERT_TRUE(result["groups"].isArray());
     EXPECT_EQ(result["groups"][0].get<std::string>(), "l");
 }
 
 TEST_F(StringTest, evalRegexCallNextTest) {
     Jsonata expr("(\n    $matcher := $eval('/l/');\n    ('Hello World' ~> $matcher).next();\n)");
     auto result = expr.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_object());
+    ASSERT_TRUE(result.isObject());
     EXPECT_EQ(result["match"].get<std::string>(), "l");
     EXPECT_EQ(result["start"].get<long long>(), 3);
     EXPECT_EQ(result["end"].get<long long>(), 4);
-    ASSERT_TRUE(result["groups"].is_array());
+    ASSERT_TRUE(result["groups"].isArray());
     EXPECT_EQ(result["groups"][0].get<std::string>(), "l");
 }
 
 TEST_F(StringTest, DISABLED_replaceTest) {
-    auto input = JSONATA_TEST_BACKEND("http://example.org/test{par}");
+    auto input = jsonata::backend<JSONATA_TEST_BACKEND>::create("http://example.org/test{par}");
     auto result = Jsonata("$replace($, /{par}/, '')").evaluate(input);
-    ASSERT_TRUE(result.is_string());
+    ASSERT_TRUE(result.isString());
     EXPECT_EQ(result.get<std::string>(), "http://example.org/test");
 }
 
diff --git a/test/ThreadTest.cpp b/test/ThreadTest.cpp
index a31e7c6..5ceaf90 100644
--- a/test/ThreadTest.cpp
+++ b/test/ThreadTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <memory>
 #include <string>
@@ -19,14 +18,14 @@ class ThreadTest : public ::testing::Test {
 
 TEST_F(ThreadTest, testReuse) {
     Jsonata expr("a");
-    JSONATA_TEST_BACKEND data = JSONATA_TEST_BACKEND::object({{"a", 1}});
+    JSONATA_TEST_BACKEND data = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"a", 1}});
 
     auto result1 = expr.evaluate(data);
-    ASSERT_TRUE(result1.is_number());
+    ASSERT_TRUE(result1.isNumber());
     EXPECT_EQ(result1.get<int>(), 1);
 
     auto result2 = expr.evaluate(data);
-    ASSERT_TRUE(result2.is_number());
+    ASSERT_TRUE(result2.isNumber());
     EXPECT_EQ(result2.get<int>(), 1);
 }
 
@@ -36,8 +35,8 @@ TEST_F(ThreadTest, testNow) {
     std::this_thread::sleep_for(std::chrono::milliseconds(42));
     auto r2 = now.evaluate<JSONATA_TEST_BACKEND>(nullptr);
 
-    ASSERT_TRUE(r1.is_string());
-    ASSERT_TRUE(r2.is_string());
+    ASSERT_TRUE(r1.isString());
+    ASSERT_TRUE(r2.isString());
     EXPECT_NE(r1.get<std::string>(), r2.get<std::string>());
 }
 
@@ -59,27 +58,27 @@ TEST_F(ThreadTest, testReuseWithVariable) {
     expr.registerFunction("wait", waitFn);
 
     auto outerFuture = std::async(std::launch::async, [&expr]() {
-        JSONATA_TEST_BACKEND data = JSONATA_TEST_BACKEND::object({{"a", 100}});
+        JSONATA_TEST_BACKEND data = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"a", 100}});
         return expr.evaluate(data);
     });
 
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
-    JSONATA_TEST_BACKEND data30 = JSONATA_TEST_BACKEND::object({{"a", 30}});
+    JSONATA_TEST_BACKEND data30 = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"a", 30}});
     auto result30 = expr.evaluate(data30);
-    ASSERT_TRUE(result30.is_number());
+    ASSERT_TRUE(result30.isNumber());
     EXPECT_EQ(result30.get<int>(), 30);
 
     auto outerResult = outerFuture.get();
-    ASSERT_TRUE(outerResult.is_number());
+    ASSERT_TRUE(outerResult.isNumber());
     EXPECT_EQ(outerResult.get<int>(), 100);
 }
 
 TEST_F(ThreadTest, testAddEnvAndInput) {
     Jsonata expr("$eval('$count($keys($))')");
 
-    JSONATA_TEST_BACKEND obj1 = JSONATA_TEST_BACKEND::object({{"input", 1}});
-    JSONATA_TEST_BACKEND obj2 = JSONATA_TEST_BACKEND::object({{"input", 2}, {"other", 3}});
+    JSONATA_TEST_BACKEND obj1 = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"input", 1}});
+    JSONATA_TEST_BACKEND obj2 = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"input", 2}, {"other", 3}});
 
     const int count = 200; // keep the test fast
 
@@ -88,7 +87,7 @@ TEST_F(ThreadTest, testAddEnvAndInput) {
         int sum = 0;
         for (int i = 0; i < count; i++) {
             auto result = expr.evaluate(obj1);
-            if (result.is_number()) sum += result.get<int>();
+            if (result.isNumber()) sum += result.get<int>();
         }
         return sum;
     });
@@ -96,7 +95,7 @@ TEST_F(ThreadTest, testAddEnvAndInput) {
     int sum = 0;
     for (int i = 0; i < count; i++) {
         auto result = expr.evaluate(obj2);
-        if (result.is_number()) sum += result.get<int>();
+        if (result.isNumber()) sum += result.get<int>();
     }
 
     int outerSum = outerFuture.get();
diff --git a/test/TypesTest.cpp b/test/TypesTest.cpp
index 3d11d04..6945e12 100644
--- a/test/TypesTest.cpp
+++ b/test/TypesTest.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <jsonata/Jsonata.h>
-#include "jsonata/backends.h"
 #include <jsonata/JException.h>
 #include <vector>
 #include <memory>
@@ -16,42 +15,42 @@ class TypesTest : public ::testing::Test {
 };
 
 TEST_F(TypesTest, castTestIn) {
-    auto arrayData = JSONATA_TEST_BACKEND::array({1.0, 2.0});
+    auto arrayData = jsonata::backend<JSONATA_TEST_BACKEND>::array({1.0, 2.0});
 
     auto result1 = Jsonata("3 in $").evaluate(arrayData);
-    ASSERT_TRUE(result1.is_boolean());
+    ASSERT_TRUE(result1.isBool());
     EXPECT_FALSE(result1.get<bool>());
 
     auto result2 = Jsonata("1 in $").evaluate(arrayData);
-    ASSERT_TRUE(result2.is_boolean());
+    ASSERT_TRUE(result2.isBool());
     EXPECT_TRUE(result2.get<bool>());
 }
 
 TEST_F(TypesTest, castTestEquals) {
     auto data1 = JSONATA_TEST_BACKEND(1.0);
     auto result1 = Jsonata("1 = $").evaluate(data1);
-    ASSERT_TRUE(result1.is_boolean());
+    ASSERT_TRUE(result1.isBool());
     EXPECT_TRUE(result1.get<bool>());
 
     auto data2 = JSONATA_TEST_BACKEND(2.0);
     auto result2 = Jsonata("1 = $").evaluate(data2);
-    ASSERT_TRUE(result2.is_boolean());
+    ASSERT_TRUE(result2.isBool());
     EXPECT_FALSE(result2.get<bool>());
 
     auto result3 = Jsonata("{'x':1 } = {'x':1 }").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result3.is_boolean());
+    ASSERT_TRUE(result3.isBool());
     EXPECT_TRUE(result3.get<bool>());
 
     auto result4 = Jsonata("{'x':1 } = {'x':2 }").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result4.is_boolean());
+    ASSERT_TRUE(result4.isBool());
     EXPECT_FALSE(result4.get<bool>());
 
     auto result5 = Jsonata("[1,null] = [1,null]").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result5.is_boolean());
+    ASSERT_TRUE(result5.isBool());
     EXPECT_TRUE(result5.get<bool>());
 
     auto result6 = Jsonata("[1,null] = [2,null]").evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result6.is_boolean());
+    ASSERT_TRUE(result6.isBool());
     EXPECT_FALSE(result6.get<bool>());
 }
 
@@ -61,49 +60,49 @@ TEST_F(TypesTest, testIllegalTypes) {
 }
 
 TEST_F(TypesTest, testLegalTypes) {
-    auto mapData = JSONATA_TEST_BACKEND::object({{"a", 1}});
+    auto mapData = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"a", 1}});
     auto result1 = Jsonata("a").evaluate(mapData);
-    ASSERT_TRUE(result1.is_number());
+    ASSERT_TRUE(result1.isNumber());
     EXPECT_EQ(result1.get<int>(), 1);
 
-    auto arrayData = JSONATA_TEST_BACKEND::array({1, 2});
+    auto arrayData = jsonata::backend<JSONATA_TEST_BACKEND>::array({1, 2});
     auto result2 = Jsonata("$[0]").evaluate(arrayData);
-    ASSERT_TRUE(result2.is_number());
+    ASSERT_TRUE(result2.isNumber());
     EXPECT_EQ(result2.get<int>(), 1);
 
-    auto stringData = JSONATA_TEST_BACKEND("string");
+    auto stringData = jsonata::backend<JSONATA_TEST_BACKEND>::create("string");
     auto result3 = Jsonata("$").evaluate(stringData);
-    ASSERT_TRUE(result3.is_string());
+    ASSERT_TRUE(result3.isString());
     EXPECT_EQ(result3.get<std::string>(), "string");
 
-    auto intData = JSONATA_TEST_BACKEND(1);
+    auto intData = jsonata::backend<JSONATA_TEST_BACKEND>::create(1);
     auto result4 = Jsonata("$").evaluate(intData);
-    ASSERT_TRUE(result4.is_number());
+    ASSERT_TRUE(result4.isNumber());
     EXPECT_EQ(result4.get<int>(), 1);
 
-    auto longData = JSONATA_TEST_BACKEND(1L);
+    auto longData = jsonata::backend<JSONATA_TEST_BACKEND>::create(1L);
     auto result5 = Jsonata("$").evaluate(longData);
-    ASSERT_TRUE(result5.is_number());
+    ASSERT_TRUE(result5.isNumber());
     EXPECT_EQ(result5.get<long>(), 1L);
 
-    auto boolData = JSONATA_TEST_BACKEND(true);
+    auto boolData = jsonata::backend<JSONATA_TEST_BACKEND>::create(true);
     auto result6 = Jsonata("$").evaluate(boolData);
-    ASSERT_TRUE(result6.is_boolean());
+    ASSERT_TRUE(result6.isBool());
     EXPECT_TRUE(result6.get<bool>());
 
-    auto doubleData = JSONATA_TEST_BACKEND(1.0);
+    auto doubleData = jsonata::backend<JSONATA_TEST_BACKEND>::create(1.0);
     auto result7 = Jsonata("$").evaluate(doubleData);
-    ASSERT_TRUE(result7.is_number());
+    ASSERT_TRUE(result7.isNumber());
     EXPECT_DOUBLE_EQ(result7.get<double>(), 1.0);
 
-    auto floatData = JSONATA_TEST_BACKEND(1.0f);
+    auto floatData = jsonata::backend<JSONATA_TEST_BACKEND>::create(1.0f);
     auto result8 = Jsonata("$").evaluate(floatData);
-    ASSERT_TRUE(result8.is_number());
+    ASSERT_TRUE(result8.isNumber());
     EXPECT_FLOAT_EQ(result8.get<float>(), 1.0f);
 
-    auto bigDecimalData = JSONATA_TEST_BACKEND(3.14);
+    auto bigDecimalData = jsonata::backend<JSONATA_TEST_BACKEND>::create(3.14);
     auto result9 = Jsonata("$").evaluate(bigDecimalData);
-    ASSERT_TRUE(result9.is_number());
+    ASSERT_TRUE(result9.isNumber());
     EXPECT_DOUBLE_EQ(result9.get<double>(), 3.14);
 }
 
@@ -114,53 +113,52 @@ struct Pojo {
 };
 
 TEST_F(TypesTest, testJacksonConversion) {
-    JSONATA_TEST_BACKEND obj = JSONATA_TEST_BACKEND::object({
+    auto obj = jsonata::backend<JSONATA_TEST_BACKEND>::object({
         {"c", "c"},
         {"d", 1234567890L},
-        {"arr", JSONATA_TEST_BACKEND::array({0,1,2,3})}
+        {"arr", jsonata::backend<JSONATA_TEST_BACKEND>::array({0,1,2,3})}
     });
 
     auto result1 = Jsonata("c").evaluate(obj);
-    ASSERT_TRUE(result1.is_string());
+    ASSERT_TRUE(result1.isString());
     EXPECT_EQ(result1.get<std::string>(), "c");
 
     auto result2 = Jsonata("arr[0]").evaluate(obj);
-    ASSERT_TRUE(result2.is_number());
+    ASSERT_TRUE(result2.isNumber());
     EXPECT_EQ(result2.get<int>(), 0);
 
     auto result3 = Jsonata("d").evaluate(obj);
-    ASSERT_TRUE(result3.is_number());
+    ASSERT_TRUE(result3.isNumber());
     EXPECT_EQ(result3.get<long>(), 1234567890L);
 
     auto result4 = Jsonata("$").evaluate(obj);
-    ASSERT_TRUE(result4.is_object());
+    ASSERT_TRUE(result4.isObject());
 }
 
 TEST_F(TypesTest, testCustomFunction) {
     Jsonata fn("$foo()");
     JFunction jfn;
     jfn.implementation = [](const Utils::JList&, const std::any&, std::shared_ptr<Frame>) -> std::any {
-        JSONATA_TEST_BACKEND obj = {{"c", "c"}};
-        return obj;
+        return jsonata::backend<JSONATA_TEST_BACKEND>::object({{"c", "c"}});
     };
     fn.registerFunction("foo", jfn);
 
     auto result = fn.evaluate<JSONATA_TEST_BACKEND>(nullptr);
-    ASSERT_TRUE(result.is_object());
+    ASSERT_TRUE(result.isObject());
     ASSERT_TRUE(result.contains("c"));
     EXPECT_EQ(result["c"].get<std::string>(), "c");
 }
 
 TEST_F(TypesTest, testIgnore) {
     Jsonata expr("a");
-    auto validData = JSONATA_TEST_BACKEND::object({{"a", "test"}});
+    auto validData = jsonata::backend<JSONATA_TEST_BACKEND>::object({{"a", "test"}});
     auto result1 = expr.evaluate(validData);
-    ASSERT_TRUE(result1.is_string());
+    ASSERT_TRUE(result1.isString());
     EXPECT_EQ(result1.get<std::string>(), "test");
 
     Jsonata expr2("a & a");
     auto result2 = expr2.evaluate(validData);
-    ASSERT_TRUE(result2.is_string());
+    ASSERT_TRUE(result2.isString());
     EXPECT_EQ(result2.get<std::string>(), "testtest");
 }
 
diff --git a/test/gen/array_constructorTest.cpp b/test/gen/array_constructorTest.cpp
index f605127..3cce350 100644
--- a/test/gen/array_constructorTest.cpp
+++ b/test/gen/array_constructorTest.cpp
@@ -6,132 +6,112 @@ using namespace jsonata;
 class array_constructorTest : public JsonataTest {
 };
 
-// $.[value,epochSeconds][]
-TEST_F(array_constructorTest, array_sequences_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 0));
+// 
+TEST_F(array_constructorTest, array_sequences) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json"));
 }
 
-// $.[value,epochSeconds][]
-TEST_F(array_constructorTest, array_sequences_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 1));
-}
-
-// $.[value,epochSeconds]
-TEST_F(array_constructorTest, array_sequences_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 2));
-}
-
-// singleArray
-TEST_F(array_constructorTest, array_sequences_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 3));
-}
-
-// singleArray[]
-TEST_F(array_constructorTest, array_sequences_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 4));
-}
-
-// []
+// 
 TEST_F(array_constructorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case000.json"));
 }
 
-// [1]
+// 
 TEST_F(array_constructorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case001.json"));
 }
 
-// [1, 2]
+// 
 TEST_F(array_constructorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case002.json"));
 }
 
-// [1, 2,3]
+// 
 TEST_F(array_constructorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case003.json"));
 }
 
-// [1, 2, [3, 4]]
+// 
 TEST_F(array_constructorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case004.json"));
 }
 
-// [1, \"two\", [\"three\", 4]]
+// 
 TEST_F(array_constructorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case005.json"));
 }
 
-// [1, $two, [\"three\", $four]]
+// 
 TEST_F(array_constructorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case006.json"));
 }
 
-// [\"foo.bar\", foo.bar, [\"foo.baz\", foo.blah.baz]]
+// 
 TEST_F(array_constructorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case007.json"));
 }
 
-// [1, 2, 3][0]
+// 
 TEST_F(array_constructorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case008.json"));
 }
 
-// [1, 2, [3, 4]][-1]
+// 
 TEST_F(array_constructorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case009.json"));
 }
 
-// [1, 2, [3, 4]][-1][-1]
+// 
 TEST_F(array_constructorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case010.json"));
 }
 
-// foo.blah.baz.[fud, fud]
+// 
 TEST_F(array_constructorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case011.json"));
 }
 
-// foo.blah.baz.[[fud, fud]]
+// 
 TEST_F(array_constructorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case012.json"));
 }
 
-// foo.blah.[baz].fud
+// 
 TEST_F(array_constructorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case013.json"));
 }
 
-// foo.blah.[baz, buz].fud
+// 
 TEST_F(array_constructorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case014.json"));
 }
 
-// [Address, Other.\"Alternative.Address\"].City
+// 
 TEST_F(array_constructorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case015.json"));
 }
 
-// [Address, Other.`Alternative.Address`].City
+// 
 TEST_F(array_constructorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case016.json"));
 }
 
-// [0,1,2,3,4,5,6,7,8,9][$ % 2 = 0]
+// 
 TEST_F(array_constructorTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case017.json"));
 }
 
-// [1, 2, 3].$
+// 
 TEST_F(array_constructorTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case018.json"));
 }
 
-// [1, 2, 3].$
+// 
 TEST_F(array_constructorTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case019.json"));
 }
 
-// [1, 2, 3].$
+// 
 TEST_F(array_constructorTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case020.json"));
 }
diff --git a/test/gen/blocksTest.cpp b/test/gen/blocksTest.cpp
index 3e2ec50..a5c7b4d 100644
--- a/test/gen/blocksTest.cpp
+++ b/test/gen/blocksTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class blocksTest : public JsonataTest {
 };
 
-// ()
+// 
 TEST_F(blocksTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case000.json"));
 }
 
-// (1; 2; 3)
+// 
 TEST_F(blocksTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case001.json"));
 }
 
-// (1; 2; 3;)
+// 
 TEST_F(blocksTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case002.json"));
 }
 
-// ($a:=1; $b:=2; $c:=($a:=4; $a+$b); $a+$c)
+// 
 TEST_F(blocksTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case003.json"));
 }
 
-// Account.Order.Product.($var1 := Price ; $var2:=Quantity; $var1 * $var2)
+// 
 TEST_F(blocksTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case004.json"));
 }
 
-// (  $func := function($arg) {$arg.Account.Order[0].OrderID};  $func($))
+// 
 TEST_F(blocksTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case005.json"));
 }
 
-// (  $func := function($arg) {$arg.Account.Order[0]};  $func($).OrderID)
+// 
 TEST_F(blocksTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case006.json"));
 }
diff --git a/test/gen/boolean_expresssionsTest.cpp b/test/gen/boolean_expresssionsTest.cpp
index 7675082..8da3fc2 100644
--- a/test/gen/boolean_expresssionsTest.cpp
+++ b/test/gen/boolean_expresssionsTest.cpp
@@ -6,157 +6,157 @@ using namespace jsonata;
 class boolean_expresssionsTest : public JsonataTest {
 };
 
-// true
+// 
 TEST_F(boolean_expresssionsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case000.json"));
 }
 
-// false
+// 
 TEST_F(boolean_expresssionsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case001.json"));
 }
 
-// false or false
+// 
 TEST_F(boolean_expresssionsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case002.json"));
 }
 
-// false or true
+// 
 TEST_F(boolean_expresssionsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case003.json"));
 }
 
-// true or false
+// 
 TEST_F(boolean_expresssionsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case004.json"));
 }
 
-// true or true
+// 
 TEST_F(boolean_expresssionsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case005.json"));
 }
 
-// false and false
+// 
 TEST_F(boolean_expresssionsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case006.json"));
 }
 
-// false and true
+// 
 TEST_F(boolean_expresssionsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case007.json"));
 }
 
-// true and false
+// 
 TEST_F(boolean_expresssionsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case008.json"));
 }
 
-// true and true
+// 
 TEST_F(boolean_expresssionsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case009.json"));
 }
 
-// $not(false)
+// 
 TEST_F(boolean_expresssionsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case010.json"));
 }
 
-// $not(true)
+// 
 TEST_F(boolean_expresssionsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case011.json"));
 }
 
-// and=1 and or=2
+// 
 TEST_F(boolean_expresssionsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case012.json"));
 }
 
-// and>1 or or<=2
+// 
 TEST_F(boolean_expresssionsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case013.json"));
 }
 
-// and>1 or or!=2
+// 
 TEST_F(boolean_expresssionsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case014.json"));
 }
 
-// and and and
+// 
 TEST_F(boolean_expresssionsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case015.json"));
 }
 
-// $[].content.origin.$lowercase(name)
+// 
 TEST_F(boolean_expresssionsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case016.json"));
 }
 
-// true or foo
+// 
 TEST_F(boolean_expresssionsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case017.json"));
 }
 
-// foo or true
+// 
 TEST_F(boolean_expresssionsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case018.json"));
 }
 
-// false or foo
+// 
 TEST_F(boolean_expresssionsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case019.json"));
 }
 
-// foo or false
+// 
 TEST_F(boolean_expresssionsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case020.json"));
 }
 
-// foo or bar
+// 
 TEST_F(boolean_expresssionsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case021.json"));
 }
 
-// true and foo
+// 
 TEST_F(boolean_expresssionsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case022.json"));
 }
 
-// foo and true
+// 
 TEST_F(boolean_expresssionsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case023.json"));
 }
 
-// false and foo
+// 
 TEST_F(boolean_expresssionsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case024.json"));
 }
 
-// foo and false
+// 
 TEST_F(boolean_expresssionsTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case025.json"));
 }
 
-// foo and bar
+// 
 TEST_F(boolean_expresssionsTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case026.json"));
 }
 
-// $not(nothing)
+// 
 TEST_F(boolean_expresssionsTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case027.json"));
 }
 
-// foo = '' or $number(foo) = 0
+// 
 TEST_F(boolean_expresssionsTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case028.json"));
 }
 
-// $type(data) = 'number' and data > 10
+// 
 TEST_F(boolean_expresssionsTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case029.json"));
 }
 
-// $type(age) = 'number' or $number(age) > 0
+// 
 TEST_F(boolean_expresssionsTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case030.json"));
 }
diff --git a/test/gen/closuresTest.cpp b/test/gen/closuresTest.cpp
index 6c43ef4..2c122a2 100644
--- a/test/gen/closuresTest.cpp
+++ b/test/gen/closuresTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class closuresTest : public JsonataTest {
 };
 
-// Account.(  $AccName := function() { $.\"Account Name\" };  Order[OrderID = \"order104\"].Product{    \"Account\": $AccName(),    \"SKU-\" & $string(ProductID): $.\"Product Name\"  } )
+// 
 TEST_F(closuresTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/closures/case000.json"));
 }
 
-// Account.(  $AccName := function() { `Account Name` };  Order[OrderID = \"order104\"].Product{    \"Account\": $AccName(),    \"SKU-\" & $string(ProductID): `Product Name`  } )
+// 
 TEST_F(closuresTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/closures/case001.json"));
 }
diff --git a/test/gen/coalescing_operatorTest.cpp b/test/gen/coalescing_operatorTest.cpp
index ab33e80..4d80b9c 100644
--- a/test/gen/coalescing_operatorTest.cpp
+++ b/test/gen/coalescing_operatorTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class coalescing_operatorTest : public JsonataTest {
 };
 
-// bar ?? 42
+// 
 TEST_F(coalescing_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case000.json"));
 }
 
-// foo.bar ?? 98
+// 
 TEST_F(coalescing_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case001.json"));
 }
 
-// foo.blah[0].baz.fud ?? 98
+// 
 TEST_F(coalescing_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case002.json"));
 }
 
-// baz ?? 42
+// 
 TEST_F(coalescing_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case003.json"));
 }
 
-// foo.baz ?? 42
+// 
 TEST_F(coalescing_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case004.json"));
 }
 
-// foo.blah[9].baz.fud ?? 42
+// 
 TEST_F(coalescing_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case005.json"));
 }
 
-// null ?? 42
+// 
 TEST_F(coalescing_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case006.json"));
 }
 
-// false ?? 42
+// 
 TEST_F(coalescing_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case007.json"));
 }
 
-// true ?? 42
+// 
 TEST_F(coalescing_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case008.json"));
 }
 
-// 0 ?? 42
+// 
 TEST_F(coalescing_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case009.json"));
 }
 
-// [] ?? 42
+// 
 TEST_F(coalescing_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case010.json"));
 }
 
-// {} ?? 42
+// 
 TEST_F(coalescing_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case011.json"));
 }
 
-// \"\" ?? 42
+// 
 TEST_F(coalescing_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case012.json"));
 }
diff --git a/test/gen/comparison_operatorsTest.cpp b/test/gen/comparison_operatorsTest.cpp
index 3e8d12d..372690a 100644
--- a/test/gen/comparison_operatorsTest.cpp
+++ b/test/gen/comparison_operatorsTest.cpp
@@ -6,243 +6,153 @@ using namespace jsonata;
 class comparison_operatorsTest : public JsonataTest {
 };
 
-// 3>-3
+// 
 TEST_F(comparison_operatorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case000.json"));
 }
 
-// 3>3
+// 
 TEST_F(comparison_operatorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case001.json"));
 }
 
-// 3=3
+// 
 TEST_F(comparison_operatorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case002.json"));
 }
 
-// \"3\"=\"3\"
+// 
 TEST_F(comparison_operatorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case003.json"));
 }
 
-// \"3\"=3
+// 
 TEST_F(comparison_operatorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case004.json"));
 }
 
-// \"hello\" = \"hello\"
+// 
 TEST_F(comparison_operatorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case005.json"));
 }
 
-// \"hello\" != \"world\"
+// 
 TEST_F(comparison_operatorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case006.json"));
 }
 
-// \"hello\" < \"world\"
+// 
 TEST_F(comparison_operatorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case007.json"));
 }
 
-// \"32\" < 42
+// 
 TEST_F(comparison_operatorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case008.json"));
 }
 
-// null <= \"world\"
+// 
 TEST_F(comparison_operatorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case009.json"));
 }
 
-// 3 >= true
+// 
 TEST_F(comparison_operatorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case010.json"));
 }
 
-// foo.bar > bar
+// 
 TEST_F(comparison_operatorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case011.json"));
 }
 
-// foo.bar >= bar
+// 
 TEST_F(comparison_operatorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case012.json"));
 }
 
-// foo.bar<bar
+// 
 TEST_F(comparison_operatorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case013.json"));
 }
 
-// foo.bar<=bar
+// 
 TEST_F(comparison_operatorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case014.json"));
 }
 
-// bar>foo.bar
+// 
 TEST_F(comparison_operatorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case015.json"));
 }
 
-// bar < foo.bar
+// 
 TEST_F(comparison_operatorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case016.json"));
 }
 
-// foo.bar = bar
+// 
 TEST_F(comparison_operatorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case017.json"));
 }
 
-// foo.bar!= bar
+// 
 TEST_F(comparison_operatorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case018.json"));
 }
 
-// bar = foo.bar + 56
+// 
 TEST_F(comparison_operatorsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case019.json"));
 }
 
-// bar !=foo.bar + 56
+// 
 TEST_F(comparison_operatorsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case020.json"));
 }
 
-// foo.blah.baz[fud = \"hello\"]
+// 
 TEST_F(comparison_operatorsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case021.json"));
 }
 
-// foo.blah.baz[fud != \"world\"]
+// 
 TEST_F(comparison_operatorsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case022.json"));
 }
 
-// Account.Order.Product[Price > 30].Price
+// 
 TEST_F(comparison_operatorsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case023.json"));
 }
 
-// Account.Order.Product.Price[$<=35]
+// 
 TEST_F(comparison_operatorsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case024.json"));
 }
 
-// false > 1
+// 
 TEST_F(comparison_operatorsTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case025.json"));
 }
 
-// false > $x
+// 
 TEST_F(comparison_operatorsTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case026.json"));
 }
 
-// 3 > $x
+// 
 TEST_F(comparison_operatorsTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case027.json"));
 }
 
-// $x <= 'hello'
+// 
 TEST_F(comparison_operatorsTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case028.json"));
 }
 
-// [1,2,3,4] = [1, 2, 3, 4]
-TEST_F(comparison_operatorsTest, deep_equals_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 0));
-}
-
-// [1,2] != [1, 2]
-TEST_F(comparison_operatorsTest, deep_equals_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 1));
-}
-
-// [1,2,[3],4] = [1, 2, [3], 4]
-TEST_F(comparison_operatorsTest, deep_equals_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 2));
-}
-
-// [1,2,3,4] = [1, 2, [3], 4]
-TEST_F(comparison_operatorsTest, deep_equals_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 3));
-}
-
-// [1,2,3,4] = [2, 3, 4]
-TEST_F(comparison_operatorsTest, deep_equals_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 4));
-}
-
-// data = [1, 2, 3, 4]
-TEST_F(comparison_operatorsTest, deep_equals_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 5));
-}
-
-// data[2] = 3
-TEST_F(comparison_operatorsTest, deep_equals_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 6));
-}
-
-// { 'one': 1, 'two': 2 } = { 'two': 2, 'one': 1 }
-TEST_F(comparison_operatorsTest, deep_equals_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 7));
-}
-
-// { 'one': 1, 'two': 2 } = { 'too': 2, 'one': 1 }
-TEST_F(comparison_operatorsTest, deep_equals_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 8));
-}
-
-// { 'one': 1, 'two': 3 } = { 'two': 2, 'one': 1 }
-TEST_F(comparison_operatorsTest, deep_equals_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 9));
-}
-
-// { 'one': 1, 'two': 2, 'three': 3 } = { 'two': 2, 'one': 1 }
-TEST_F(comparison_operatorsTest, deep_equals_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 10));
-}
-
-// two = 2
-TEST_F(comparison_operatorsTest, deep_equals_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 11));
-}
-
-// one + one = two
-TEST_F(comparison_operatorsTest, deep_equals_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 12));
-}
-
-// null = null
-TEST_F(comparison_operatorsTest, deep_equals_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 13));
-}
-
-// null != null
-TEST_F(comparison_operatorsTest, deep_equals_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 14));
-}
-
-// null = nothing
-TEST_F(comparison_operatorsTest, deep_equals_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 15));
-}
-
-// nothing = nothing
-TEST_F(comparison_operatorsTest, deep_equals_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 16));
-}
-
-// Account.Order[0].Product[0].Description = Account.Order[1].Product[0].Description
-TEST_F(comparison_operatorsTest, deep_equals_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 17));
-}
-
-// Account.Order[0].Product[0] = Account.Order[1].Product[0]
-TEST_F(comparison_operatorsTest, deep_equals_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 18));
+// 
+TEST_F(comparison_operatorsTest, deep_equals) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json"));
 }
 
diff --git a/test/gen/conditionalsTest.cpp b/test/gen/conditionalsTest.cpp
index ed32956..9fbad66 100644
--- a/test/gen/conditionalsTest.cpp
+++ b/test/gen/conditionalsTest.cpp
@@ -6,47 +6,47 @@ using namespace jsonata;
 class conditionalsTest : public JsonataTest {
 };
 
-// [\"Red\"[$$=\"Bus\"], \"White\"[$$=\"Police Car\"]][0]
+// 
 TEST_F(conditionalsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case000.json"));
 }
 
-// [\"Red\"[$$=\"Bus\"], \"White\"[$$=\"Police Car\"]][0]
+// 
 TEST_F(conditionalsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case001.json"));
 }
 
-// [\"Red\"[$$=\"Bus\"], \"White\"[$$=\"Police Car\"]][0]
+// 
 TEST_F(conditionalsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case002.json"));
 }
 
-// $lookup({\"Bus\": \"Red\", \"Police Car\": \"White\"}, $$)
+// 
 TEST_F(conditionalsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case003.json"));
 }
 
-// $lookup({\"Bus\": \"Red\", \"Police Car\": \"White\"}, $$)
+// 
 TEST_F(conditionalsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case004.json"));
 }
 
-// $lookup({\"Bus\": \"Red\", \"Police Car\": \"White\"}, $$)
+// 
 TEST_F(conditionalsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case005.json"));
 }
 
-// Account.Order.Product.(Price < 30 ? \"Cheap\")
+// 
 TEST_F(conditionalsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case006.json"));
 }
 
-// Account.Order.Product.(Price < 30 ? \"Cheap\" : \"Expensive\")
+// 
 TEST_F(conditionalsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case007.json"));
 }
 
-// Account.Order.Product.(Price < 30 ? \"Cheap\" : Price < 100 ? \"Expensive\" : \"Rip off\")
+// 
 TEST_F(conditionalsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case008.json"));
 }
diff --git a/test/gen/contextTest.cpp b/test/gen/contextTest.cpp
index bb1841f..e150b4e 100644
--- a/test/gen/contextTest.cpp
+++ b/test/gen/contextTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class contextTest : public JsonataTest {
 };
 
-// $number()
+// 
 TEST_F(contextTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case000.json"));
 }
 
-// [1..5].$string()
+// 
 TEST_F(contextTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case001.json"));
 }
 
-// [1..5].(\"Item \" & $string())
+// 
 TEST_F(contextTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case002.json"));
 }
 
-// Account.Order.Product.\"Product Name\".$uppercase().$substringBefore(\" \")
+// 
 TEST_F(contextTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case003.json"));
 }
diff --git a/test/gen/default_operatorTest.cpp b/test/gen/default_operatorTest.cpp
index 804beba..81cfa53 100644
--- a/test/gen/default_operatorTest.cpp
+++ b/test/gen/default_operatorTest.cpp
@@ -6,72 +6,72 @@ using namespace jsonata;
 class default_operatorTest : public JsonataTest {
 };
 
-// true ?: 42
+// 
 TEST_F(default_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case000.json"));
 }
 
-// false ?: 42
+// 
 TEST_F(default_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case001.json"));
 }
 
-// 1 ?: 42
+// 
 TEST_F(default_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case002.json"));
 }
 
-// 0 ?: 42
+// 
 TEST_F(default_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case003.json"));
 }
 
-// \"hello\" ?: 42
+// 
 TEST_F(default_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case004.json"));
 }
 
-// \"\" ?: 42
+// 
 TEST_F(default_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case005.json"));
 }
 
-// [1] ?: 42
+// 
 TEST_F(default_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case006.json"));
 }
 
-// [0] ?: 42
+// 
 TEST_F(default_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case007.json"));
 }
 
-// [] ?: 42
+// 
 TEST_F(default_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case008.json"));
 }
 
-// { \"a\": 1 } ?: 42
+// 
 TEST_F(default_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case009.json"));
 }
 
-// {} ?: 42
+// 
 TEST_F(default_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case010.json"));
 }
 
-// function(){true} ?: 42
+// 
 TEST_F(default_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case011.json"));
 }
 
-// Account.blah ?: 42
+// 
 TEST_F(default_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case012.json"));
 }
 
-// Account.blah ?: 42
+// 
 TEST_F(default_operatorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case013.json"));
 }
diff --git a/test/gen/descendent_operatorTest.cpp b/test/gen/descendent_operatorTest.cpp
index 2366c17..873837b 100644
--- a/test/gen/descendent_operatorTest.cpp
+++ b/test/gen/descendent_operatorTest.cpp
@@ -6,87 +6,87 @@ using namespace jsonata;
 class descendent_operatorTest : public JsonataTest {
 };
 
-// foo.**.blah
+// 
 TEST_F(descendent_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case000.json"));
 }
 
-// foo.**.baz
+// 
 TEST_F(descendent_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case001.json"));
 }
 
-// foo.**.fud
+// 
 TEST_F(descendent_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case002.json"));
 }
 
-// \"foo\".**.fud
+// 
 TEST_F(descendent_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case003.json"));
 }
 
-// foo.**.\"fud\"
+// 
 TEST_F(descendent_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case004.json"));
 }
 
-// \"foo\".**.\"fud\"
+// 
 TEST_F(descendent_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case005.json"));
 }
 
-// foo.*.**.fud
+// 
 TEST_F(descendent_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case006.json"));
 }
 
-// foo.**.*.fud
+// 
 TEST_F(descendent_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case007.json"));
 }
 
-// Account.Order.**.Colour
+// 
 TEST_F(descendent_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case008.json"));
 }
 
-// foo.**.fud[0]
+// 
 TEST_F(descendent_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case009.json"));
 }
 
-// (foo.**.fud)[0]
+// 
 TEST_F(descendent_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case010.json"));
 }
 
-// (**.fud)[0]
+// 
 TEST_F(descendent_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case011.json"));
 }
 
-// **.Price
+// 
 TEST_F(descendent_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case012.json"));
 }
 
-// **.Price[0]
+// 
 TEST_F(descendent_operatorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case013.json"));
 }
 
-// (**.Price)[0]
+// 
 TEST_F(descendent_operatorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case014.json"));
 }
 
-// Account.Order.blah.**
+// 
 TEST_F(descendent_operatorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case015.json"));
 }
 
-// **
+// 
 TEST_F(descendent_operatorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case016.json"));
 }
diff --git a/test/gen/encodingTest.cpp b/test/gen/encodingTest.cpp
index 6c23ffb..c4d3ebf 100644
--- a/test/gen/encodingTest.cpp
+++ b/test/gen/encodingTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class encodingTest : public JsonataTest {
 };
 
-// $base64encode(\"hello:world\")
+// 
 TEST_F(encodingTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case000.json"));
 }
 
-// $base64encode()
+// 
 TEST_F(encodingTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case001.json"));
 }
 
-// $base64decode(\"aGVsbG86d29ybGQ=\")
+// 
 TEST_F(encodingTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case002.json"));
 }
 
-// $base64decode()
+// 
 TEST_F(encodingTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case003.json"));
 }
diff --git a/test/gen/errorsTest.cpp b/test/gen/errorsTest.cpp
index 409d21e..aaca7e0 100644
--- a/test/gen/errorsTest.cpp
+++ b/test/gen/errorsTest.cpp
@@ -6,137 +6,137 @@ using namespace jsonata;
 class errorsTest : public JsonataTest {
 };
 
-// \"s\" - 1
+// 
 TEST_F(errorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case000.json"));
 }
 
-// 1 + null
+// 
 TEST_F(errorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case001.json"));
 }
 
-// \"no closing quote
+// 
 TEST_F(errorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case002.json"));
 }
 
-// `no closing backtick
+// 
 TEST_F(errorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case003.json"));
 }
 
-// - \"s\"
+// 
 TEST_F(errorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case004.json"));
 }
 
-// unknown(function)
+// 
 TEST_F(errorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case005.json"));
 }
 
-// sum(Account.Order.OrderID)
+// 
 TEST_F(errorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case006.json"));
 }
 
-// [1,2)
+// 
 TEST_F(errorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case007.json"));
 }
 
-// [1:2]
+// 
 TEST_F(errorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case008.json"));
 }
 
-// $replace(\"foo\", \"o, \"rr\")
+// 
 TEST_F(errorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case009.json"));
 }
 
-// [1!2]
+// 
 TEST_F(errorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case010.json"));
 }
 
-// @ bar
+// 
 TEST_F(errorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case011.json"));
 }
 
-// 2(blah)
+// 
 TEST_F(errorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case012.json"));
 }
 
-// 2()
+// 
 TEST_F(errorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case013.json"));
 }
 
-// 3(?)
+// 
 TEST_F(errorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case014.json"));
 }
 
-// 1=
+// 
 TEST_F(errorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case015.json"));
 }
 
-// function(x){$x}(3)
+// 
 TEST_F(errorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case016.json"));
 }
 
-// x:=1
+// 
 TEST_F(errorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case017.json"));
 }
 
-// 2:=1
+// 
 TEST_F(errorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case018.json"));
 }
 
-// $foo()
+// 
 TEST_F(errorsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case019.json"));
 }
 
-// 55=>5
+// 
 TEST_F(errorsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case020.json"));
 }
 
-// Ssum(:)
+// 
 TEST_F(errorsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case021.json"));
 }
 
-// [1,2,3]{\"num\": $}[true]
+// 
 TEST_F(errorsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case022.json"));
 }
 
-// [1,2,3]{\"num\": $}{\"num\": $}
+// 
 TEST_F(errorsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case023.json"));
 }
 
-// Account.Order[0].Product;
+// 
 TEST_F(errorsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case024.json"));
 }
 
-// ( $A := function(){$min(2, 3)}; $A() )
+// 
 TEST_F(errorsTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case025.json"));
 }
 
-// ( $B := function(){''}; $A := function(){2 + $B()}; $A() )
+// 
 TEST_F(errorsTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case026.json"));
 }
diff --git a/test/gen/fieldsTest.cpp b/test/gen/fieldsTest.cpp
index 1bea704..8fc2679 100644
--- a/test/gen/fieldsTest.cpp
+++ b/test/gen/fieldsTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class fieldsTest : public JsonataTest {
 };
 
-// foo.bar
+// 
 TEST_F(fieldsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case000.json"));
 }
 
-// foo.blah
+// 
 TEST_F(fieldsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case001.json"));
 }
 
-// foo.blah.bazz
+// 
 TEST_F(fieldsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case002.json"));
 }
 
-// foo.blah.baz
+// 
 TEST_F(fieldsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case003.json"));
 }
 
-// foo.blah.baz.fud
+// 
 TEST_F(fieldsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case004.json"));
 }
 
-// Other.Misc
+// 
 TEST_F(fieldsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case005.json"));
 }
 
-// bazz
+// 
 TEST_F(fieldsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case006.json"));
 }
 
-// fud
+// 
 TEST_F(fieldsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case007.json"));
 }
diff --git a/test/gen/flatteningTest.cpp b/test/gen/flatteningTest.cpp
index e5a3846..f5243de 100644
--- a/test/gen/flatteningTest.cpp
+++ b/test/gen/flatteningTest.cpp
@@ -6,308 +6,253 @@ using namespace jsonata;
 class flatteningTest : public JsonataTest {
 };
 
-// phone
-TEST_F(flatteningTest, array_inputs_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 0));
+// 
+TEST_F(flatteningTest, array_inputs) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/array-inputs.json"));
 }
 
-// phone[0]
-TEST_F(flatteningTest, array_inputs_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 1));
-}
-
-// phone[0][]
-TEST_F(flatteningTest, array_inputs_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 2));
-}
-
-// phone[0].number
-TEST_F(flatteningTest, array_inputs_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 3));
-}
-
-// (phone)[0].number
-TEST_F(flatteningTest, array_inputs_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 4));
-}
-
-// $.phone[0].number
-TEST_F(flatteningTest, array_inputs_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 5));
-}
-
-// {'Hello':'World'}
-TEST_F(flatteningTest, array_inputs_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 6));
-}
-
-// $.{'Hello':'World'}
-TEST_F(flatteningTest, array_inputs_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 7));
-}
-
-// Account.Order.[Product.Price]
+// 
 TEST_F(flatteningTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case000.json"));
 }
 
-// $.nest0
+// 
 TEST_F(flatteningTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case001.json"));
 }
 
-// nest0
+// 
 TEST_F(flatteningTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case002.json"));
 }
 
-// $[0]
+// 
 TEST_F(flatteningTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case003.json"));
 }
 
-// $[1]
+// 
 TEST_F(flatteningTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case004.json"));
 }
 
-// $[-1]
+// 
 TEST_F(flatteningTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case005.json"));
 }
 
-// $[0].nest0
+// 
 TEST_F(flatteningTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case006.json"));
 }
 
-// $[1].nest0
+// 
 TEST_F(flatteningTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case007.json"));
 }
 
-// $[0].nest0[0]
+// 
 TEST_F(flatteningTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case008.json"));
 }
 
-// nest0.[nest1.[nest2.[nest3]]]
+// 
 TEST_F(flatteningTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case009.json"));
 }
 
-// nest0.nest1.[nest2.[nest3]]
+// 
 TEST_F(flatteningTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case010.json"));
 }
 
-// nest0.[nest1.nest2.[nest3]]
+// 
 TEST_F(flatteningTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case011.json"));
 }
 
-// nest0.[nest1.[nest2.nest3]]
+// 
 TEST_F(flatteningTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case012.json"));
 }
 
-// nest0.[nest1.nest2.nest3]
+// 
 TEST_F(flatteningTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case013.json"));
 }
 
-// nest0.nest1.[nest2.nest3]
+// 
 TEST_F(flatteningTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case014.json"));
 }
 
-// nest0.nest1.nest2.[nest3]
+// 
 TEST_F(flatteningTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case015.json"));
 }
 
-// nest0.nest1.nest2.nest3
+// 
 TEST_F(flatteningTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case016.json"));
 }
 
-// nest0.[nest1.[nest2.[nest3]]]
+// 
 TEST_F(flatteningTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case017.json"));
 }
 
-// nest0.nest1.[nest2.[nest3]]
+// 
 TEST_F(flatteningTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case018.json"));
 }
 
-// nest0.[nest1.nest2.[nest3]]
+// 
 TEST_F(flatteningTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case019.json"));
 }
 
-// nest0.[nest1.[nest2.nest3]]
+// 
 TEST_F(flatteningTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case020.json"));
 }
 
-// nest0.[nest1.nest2.nest3]
+// 
 TEST_F(flatteningTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case021.json"));
 }
 
-// nest0.nest1.[nest2.nest3]
+// 
 TEST_F(flatteningTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case022.json"));
 }
 
-// nest0.nest1.nest2.[nest3]
+// 
 TEST_F(flatteningTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case023.json"));
 }
 
-// nest0.nest1.nest2.nest3
+// 
 TEST_F(flatteningTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case024.json"));
 }
 
-// {\"a\": 1 }.a
+// 
 TEST_F(flatteningTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case025.json"));
 }
 
-// a
+// 
 TEST_F(flatteningTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case026.json"));
 }
 
-// {\"a\": [1] }.a
+// 
 TEST_F(flatteningTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case027.json"));
 }
 
-// a
+// 
 TEST_F(flatteningTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case028.json"));
 }
 
-// {\"a\": [[1]] }.a
+// 
 TEST_F(flatteningTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case029.json"));
 }
 
-// a
+// 
 TEST_F(flatteningTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case030.json"));
 }
 
-// [{\"a\":[1,2]}, {\"a\":[3]}].a
+// 
 TEST_F(flatteningTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case031.json"));
 }
 
-// a
+// 
 TEST_F(flatteningTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case032.json"));
 }
 
-// [{\"a\":[{\"b\":[1]}, {\"b\":[2]}]}, {\"a\":[{\"b\":[3]}, {\"b\":[4]}]}].a[0].b
+// 
 TEST_F(flatteningTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case033.json"));
 }
 
-// a[0].b
+// 
 TEST_F(flatteningTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case034.json"));
 }
 
-// $.a[0].b
+// 
 TEST_F(flatteningTest, case034a) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case034a.json"));
 }
 
-// a.b[0]
+// 
 TEST_F(flatteningTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case035.json"));
 }
 
-// Phone[type=\"mobile\"].number
+// 
 TEST_F(flatteningTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case036.json"));
 }
 
-// Phone[type=\"mobile\"][].number
+// 
 TEST_F(flatteningTest, case037) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case037.json"));
 }
 
-// Phone[][type=\"mobile\"].number
+// 
 TEST_F(flatteningTest, case038) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case038.json"));
 }
 
-// Phone[type=\"office\"][].number
+// 
 TEST_F(flatteningTest, case039) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case039.json"));
 }
 
-// Phone{type: number}
+// 
 TEST_F(flatteningTest, case040) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case040.json"));
 }
 
-// Phone{type: number[]}
+// 
 TEST_F(flatteningTest, case041) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case041.json"));
 }
 
-// $[type='command'][]
+// 
 TEST_F(flatteningTest, case042) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case042.json"));
 }
 
-// $[][type='command']
+// 
 TEST_F(flatteningTest, case043) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case043.json"));
 }
 
-// $filter($, function($e) { $e != 0 })[]
+// 
 TEST_F(flatteningTest, case044) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case044.json"));
 }
 
-// $.tags[title='example'][]
+// 
 TEST_F(flatteningTest, case045) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case045.json"));
 }
 
-// ( $data := { 'number': [1..2e5].$string() }; $values := $data.number; $count($values) )
-TEST_F(flatteningTest, large_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/large.json", 0));
-}
-
-// ( $data := { 'number': [1..2e5].$string() }; $values := $lookup($data, 'number'); $count($values) )
-TEST_F(flatteningTest, large_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/large.json", 1));
-}
-
-// $.[value,epochSeconds]
-TEST_F(flatteningTest, sequence_of_arrays_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 0));
-}
-
-// $.[value,epochSeconds]
-TEST_F(flatteningTest, sequence_of_arrays_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 1));
-}
-
-// $.[value,epochSeconds][]
-TEST_F(flatteningTest, sequence_of_arrays_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 2));
+// 
+TEST_F(flatteningTest, large) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/large.json"));
 }
 
-// $.[value,epochSeconds][]
-TEST_F(flatteningTest, sequence_of_arrays_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 3));
+// 
+TEST_F(flatteningTest, sequence_of_arrays) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json"));
 }
 
diff --git a/test/gen/function_absTest.cpp b/test/gen/function_absTest.cpp
index 5561a25..5dafcdf 100644
--- a/test/gen/function_absTest.cpp
+++ b/test/gen/function_absTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_absTest : public JsonataTest {
 };
 
-// $abs(3.7)
+// 
 TEST_F(function_absTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case000.json"));
 }
 
-// $abs(-3.7)
+// 
 TEST_F(function_absTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case001.json"));
 }
 
-// $abs(0)
+// 
 TEST_F(function_absTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case002.json"));
 }
 
-// $abs(nothing)
+// 
 TEST_F(function_absTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case003.json"));
 }
diff --git a/test/gen/function_appendTest.cpp b/test/gen/function_appendTest.cpp
index 97f328c..eef3608 100644
--- a/test/gen/function_appendTest.cpp
+++ b/test/gen/function_appendTest.cpp
@@ -6,32 +6,32 @@ using namespace jsonata;
 class function_appendTest : public JsonataTest {
 };
 
-// $append([1,2], [3,4])
+// 
 TEST_F(function_appendTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case000.json"));
 }
 
-// $append(1, [3,4])
+// 
 TEST_F(function_appendTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case001.json"));
 }
 
-// $append(1,2)
+// 
 TEST_F(function_appendTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case002.json"));
 }
 
-// $append(1,notexist)
+// 
 TEST_F(function_appendTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case003.json"));
 }
 
-// $append(notexist, [2,3,4])
+// 
 TEST_F(function_appendTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case004.json"));
 }
 
-// ($append($data.a, [2]); $data.a)
+// 
 TEST_F(function_appendTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case005.json"));
 }
diff --git a/test/gen/function_applicationsTest.cpp b/test/gen/function_applicationsTest.cpp
index 70e63c9..51fb5b3 100644
--- a/test/gen/function_applicationsTest.cpp
+++ b/test/gen/function_applicationsTest.cpp
@@ -6,112 +6,112 @@ using namespace jsonata;
 class function_applicationsTest : public JsonataTest {
 };
 
-// Account.Order[0].OrderID ~> $uppercase()
+// 
 TEST_F(function_applicationsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case000.json"));
 }
 
-// Account.Order[0].OrderID ~> $uppercase() ~> $lowercase()
+// 
 TEST_F(function_applicationsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case001.json"));
 }
 
-// Account.Order.OrderID ~> $join()
+// 
 TEST_F(function_applicationsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case002.json"));
 }
 
-// Account.Order.OrderID ~> $join(\", \")
+// 
 TEST_F(function_applicationsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case003.json"));
 }
 
-// Account.Order.Product.(Price * Quantity) ~> $sum()
+// 
 TEST_F(function_applicationsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case004.json"));
 }
 
-// ( $uppertrim := $trim ~> $uppercase;  $uppertrim(\"   Hello    World   \") )
+// 
 TEST_F(function_applicationsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case005.json"));
 }
 
-// \"john@example.com\" ~> $substringAfter(\"@\") ~> $substringBefore(\".\") 
+// 
 TEST_F(function_applicationsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case006.json"));
 }
 
-// \"\" ~> $substringAfter(\"@\") ~> $substringBefore(\".\") 
+// 
 TEST_F(function_applicationsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case007.json"));
 }
 
-// foo ~> $substringAfter(\"@\") ~> $substringBefore(\".\") 
+// 
 TEST_F(function_applicationsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case008.json"));
 }
 
-// ( $domain := $substringAfter(?,\"@\") ~> $substringBefore(?,\".\"); $domain(\"john@example.com\") )
+// 
 TEST_F(function_applicationsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case009.json"));
 }
 
-// ( $square := function($x){$x*$x}; [1..5] ~> $map($square) ) 
+// 
 TEST_F(function_applicationsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case010.json"));
 }
 
-// ( $square := function($x){$x*$x}; [1..5] ~> $map($square) ~> $sum() ) 
+// 
 TEST_F(function_applicationsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case011.json"));
 }
 
-// ($betweenBackets := $substringAfter(?, \"(\") ~> $substringBefore(?, \")\");$betweenBackets(\"test(foo)bar\")) 
+// 
 TEST_F(function_applicationsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case012.json"));
 }
 
-// ($square := function($x){$x*$x};$chain := λ($f, $g){λ($x){$g($f($x))}};$instructions := [$sum, $square];$sumsq := $instructions ~> $reduce($chain);[1..5] ~> $sumsq()) 
+// 
 TEST_F(function_applicationsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case013.json"));
 }
 
-// ($square := function($x){$x*$x};$chain := λ($f, $g){λ($x){ $x ~> $f ~> $g }};$instructions := [$sum, $square, $string];$sumsq := $instructions ~> $reduce($chain);[1..5] ~> $sumsq()) 
+// 
 TEST_F(function_applicationsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case014.json"));
 }
 
-// ($square := function($x){$x*$x};$instructions := $sum ~> $square;[1..5] ~> $instructions())  
+// 
 TEST_F(function_applicationsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case015.json"));
 }
 
-// ($square := function($x){$x*$x};$sum_of_squares := $map(?, $square) ~> $sum;[1..5] ~> $sum_of_squares())  
+// 
 TEST_F(function_applicationsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case016.json"));
 }
 
-// ($times := λ($x, $y) { $x * $y };$product := $reduce(?, $times);$square := function($x){$x*$x};$product_of_squares := $map(?, $square) ~> $product;[1..5] ~> $product_of_squares())
+// 
 TEST_F(function_applicationsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case017.json"));
 }
 
-// ($square := function($x){$x*$x};[1..5] ~> $map($square) ~> $reduce(λ($x, $y) { $x * $y });)
+// 
 TEST_F(function_applicationsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case018.json"));
 }
 
-// ($prices := Account.Order.Product.Price;$quantities := Account.Order.Product.Quantity;$product := λ($arr) { $arr[0] * $arr[1] };$zip($prices, $quantities) ~> $map($product) ~> $sum())
+// 
 TEST_F(function_applicationsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case019.json"));
 }
 
-// 42 ~> \"hello\"
+// 
 TEST_F(function_applicationsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case020.json"));
 }
 
-// Account.Order.Product[$.\"Product Name\" ~> /hat/i].ProductID
+// 
 TEST_F(function_applicationsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case021.json"));
 }
diff --git a/test/gen/function_assertTest.cpp b/test/gen/function_assertTest.cpp
index 17dbf38..2fef6c7 100644
--- a/test/gen/function_assertTest.cpp
+++ b/test/gen/function_assertTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class function_assertTest : public JsonataTest {
 };
 
-// $assert(Account.Order[0].Product[0].Price < 34, 'Too Expensive')
+// 
 TEST_F(function_assertTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case000.json"));
 }
 
-// $assert(Account.Order[0].Product[0].Price < 35, 'Too Expensive')
+// 
 TEST_F(function_assertTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case001.json"));
 }
 
-// ($assert(Account.Order[0].Product[0].Price < 35, 'Too Expensive'); Account.Order[0].Product[0].Price)
+// 
 TEST_F(function_assertTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case002.json"));
 }
 
-// ($assert(Account.Order[0].Product[0].Price < 34, 'Too Expensive'); Account.Order[0].Product[0].Price)
+// 
 TEST_F(function_assertTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case003.json"));
 }
 
-// $assert(null)
+// 
 TEST_F(function_assertTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case004.json"));
 }
 
-// $assert(5)
+// 
 TEST_F(function_assertTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case005.json"));
 }
 
-// $assert(false)
+// 
 TEST_F(function_assertTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case006.json"));
 }
 
-// $assert(true)
+// 
 TEST_F(function_assertTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case007.json"));
 }
diff --git a/test/gen/function_averageTest.cpp b/test/gen/function_averageTest.cpp
index 911067c..626845f 100644
--- a/test/gen/function_averageTest.cpp
+++ b/test/gen/function_averageTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class function_averageTest : public JsonataTest {
 };
 
-// $average(Account.Order.Product.(Price * Quantity))
+// 
 TEST_F(function_averageTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case000.json"));
 }
 
-// Account.Order.$average(Product.(Price * Quantity))
+// 
 TEST_F(function_averageTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case001.json"));
 }
 
-// Account.Order.(OrderID & \": \" & $average(Product.(Price*Quantity)))
+// 
 TEST_F(function_averageTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case002.json"));
 }
 
-// $average([])
+// 
 TEST_F(function_averageTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case003.json"));
 }
 
-// $average([1,2,3])
+// 
 TEST_F(function_averageTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case004.json"));
 }
 
-// $average([\"1\",\"2\",\"3\"])
+// 
 TEST_F(function_averageTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case005.json"));
 }
 
-// $average([\"1\",\"2\",3])
+// 
 TEST_F(function_averageTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case006.json"));
 }
 
-// $average(1)
+// 
 TEST_F(function_averageTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case007.json"));
 }
 
-// $average([],[])
+// 
 TEST_F(function_averageTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case008.json"));
 }
 
-// $average([1,2,3],[])
+// 
 TEST_F(function_averageTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case009.json"));
 }
 
-// $average([],[],[])
+// 
 TEST_F(function_averageTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case010.json"));
 }
 
-// $average([1,2],[],[])
+// 
 TEST_F(function_averageTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case011.json"));
 }
 
-// $average(undefined)
+// 
 TEST_F(function_averageTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case012.json"));
 }
diff --git a/test/gen/function_booleanTest.cpp b/test/gen/function_booleanTest.cpp
index a2006f8..a37d540 100644
--- a/test/gen/function_booleanTest.cpp
+++ b/test/gen/function_booleanTest.cpp
@@ -6,122 +6,122 @@ using namespace jsonata;
 class function_booleanTest : public JsonataTest {
 };
 
-// $boolean(\"Hello World\")
+// 
 TEST_F(function_booleanTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case000.json"));
 }
 
-// $boolean(\"\")
+// 
 TEST_F(function_booleanTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case001.json"));
 }
 
-// $boolean(true)
+// 
 TEST_F(function_booleanTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case002.json"));
 }
 
-// $boolean(false)
+// 
 TEST_F(function_booleanTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case003.json"));
 }
 
-// $boolean(0)
+// 
 TEST_F(function_booleanTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case004.json"));
 }
 
-// $boolean(10)
+// 
 TEST_F(function_booleanTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case005.json"));
 }
 
-// $boolean(-0.5)
+// 
 TEST_F(function_booleanTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case006.json"));
 }
 
-// $boolean(null)
+// 
 TEST_F(function_booleanTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case007.json"));
 }
 
-// $boolean([])
+// 
 TEST_F(function_booleanTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case008.json"));
 }
 
-// $boolean([0])
+// 
 TEST_F(function_booleanTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case009.json"));
 }
 
-// $boolean([1])
+// 
 TEST_F(function_booleanTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case010.json"));
 }
 
-// $boolean([1,2,3])
+// 
 TEST_F(function_booleanTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case011.json"));
 }
 
-// $boolean([0,0])
+// 
 TEST_F(function_booleanTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case012.json"));
 }
 
-// $boolean([[]])
+// 
 TEST_F(function_booleanTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case013.json"));
 }
 
-// $boolean([[null]])
+// 
 TEST_F(function_booleanTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case014.json"));
 }
 
-// $boolean([[[true]]])
+// 
 TEST_F(function_booleanTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case015.json"));
 }
 
-// $boolean({})
+// 
 TEST_F(function_booleanTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case016.json"));
 }
 
-// $boolean({\"hello\":\"world\"})
+// 
 TEST_F(function_booleanTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case017.json"));
 }
 
-// $boolean(Account)
+// 
 TEST_F(function_booleanTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case018.json"));
 }
 
-// $boolean(Account.Order.Product.Price)
+// 
 TEST_F(function_booleanTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case019.json"));
 }
 
-// $boolean(Account.blah)
+// 
 TEST_F(function_booleanTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case020.json"));
 }
 
-// $boolean($boolean)
+// 
 TEST_F(function_booleanTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case021.json"));
 }
 
-// $boolean(function(){true})
+// 
 TEST_F(function_booleanTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case022.json"));
 }
 
-// $boolean(2,3)
+// 
 TEST_F(function_booleanTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case023.json"));
 }
diff --git a/test/gen/function_ceilTest.cpp b/test/gen/function_ceilTest.cpp
index d8dc699..0c4127c 100644
--- a/test/gen/function_ceilTest.cpp
+++ b/test/gen/function_ceilTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_ceilTest : public JsonataTest {
 };
 
-// $ceil(3.7)
+// 
 TEST_F(function_ceilTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case000.json"));
 }
 
-// $ceil(-3.7)
+// 
 TEST_F(function_ceilTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case001.json"));
 }
 
-// $ceil(0)
+// 
 TEST_F(function_ceilTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case002.json"));
 }
 
-// $ceil(nothing)
+// 
 TEST_F(function_ceilTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case003.json"));
 }
diff --git a/test/gen/function_containsTest.cpp b/test/gen/function_containsTest.cpp
index f3c64e1..9f77d9a 100644
--- a/test/gen/function_containsTest.cpp
+++ b/test/gen/function_containsTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_containsTest : public JsonataTest {
 };
 
-// $contains(\"Hello World\", \"lo\")
+// 
 TEST_F(function_containsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case000.json"));
 }
 
-// $contains(\"Hello World\", \"World\")
+// 
 TEST_F(function_containsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case001.json"));
 }
 
-// $contains(\"Hello World\", \"world\")
+// 
 TEST_F(function_containsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case002.json"));
 }
 
-// $contains(\"Hello World\", \"Word\")
+// 
 TEST_F(function_containsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case003.json"));
 }
 
-// $contains(nothing, \"World\")
+// 
 TEST_F(function_containsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case004.json"));
 }
 
-// $contains(23, 3)
+// 
 TEST_F(function_containsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case005.json"));
 }
 
-// $contains(\"23\", 3)
+// 
 TEST_F(function_containsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case006.json"));
 }
diff --git a/test/gen/function_countTest.cpp b/test/gen/function_countTest.cpp
index 0a2fc1e..b6aee2d 100644
--- a/test/gen/function_countTest.cpp
+++ b/test/gen/function_countTest.cpp
@@ -6,72 +6,72 @@ using namespace jsonata;
 class function_countTest : public JsonataTest {
 };
 
-// $count(Account.Order.Product.(Price * Quantity))
+// 
 TEST_F(function_countTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case000.json"));
 }
 
-// Account.Order.$count(Product.(Price * Quantity))
+// 
 TEST_F(function_countTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case001.json"));
 }
 
-// Account.Order.(OrderID & \": \" & $count(Product.(Price*Quantity)))
+// 
 TEST_F(function_countTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case002.json"));
 }
 
-// $count([])
+// 
 TEST_F(function_countTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case003.json"));
 }
 
-// $count([1,2,3])
+// 
 TEST_F(function_countTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case004.json"));
 }
 
-// $count([\"1\",\"2\",\"3\"])
+// 
 TEST_F(function_countTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case005.json"));
 }
 
-// $count([\"1\",\"2\",3])
+// 
 TEST_F(function_countTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case006.json"));
 }
 
-// $count(1)
+// 
 TEST_F(function_countTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case007.json"));
 }
 
-// $count([],[])
+// 
 TEST_F(function_countTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case008.json"));
 }
 
-// $count([1,2,3],[])
+// 
 TEST_F(function_countTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case009.json"));
 }
 
-// $count([],[],[])
+// 
 TEST_F(function_countTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case010.json"));
 }
 
-// $count([1,2],[],[])
+// 
 TEST_F(function_countTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case011.json"));
 }
 
-// $count(undefined)
+// 
 TEST_F(function_countTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case012.json"));
 }
 
-// $count([1,2,3,4]) / 2
+// 
 TEST_F(function_countTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case013.json"));
 }
diff --git a/test/gen/function_decodeUrlComponentTest.cpp b/test/gen/function_decodeUrlComponentTest.cpp
index c468356..49bf765 100644
--- a/test/gen/function_decodeUrlComponentTest.cpp
+++ b/test/gen/function_decodeUrlComponentTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_decodeUrlComponentTest : public JsonataTest {
 };
 
-// $decodeUrlComponent(\"%3Fx%3Dtest\")
+// 
 TEST_F(function_decodeUrlComponentTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrlComponent/case000.json"));
 }
 
-// $decodeUrlComponent(blah)
+// 
 TEST_F(function_decodeUrlComponentTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrlComponent/case001.json"));
 }
 
-// $decodeUrlComponent('%E0%A4%A')
+// 
 TEST_F(function_decodeUrlComponentTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrlComponent/case002.json"));
 }
diff --git a/test/gen/function_decodeUrlTest.cpp b/test/gen/function_decodeUrlTest.cpp
index dce3b99..25b13b4 100644
--- a/test/gen/function_decodeUrlTest.cpp
+++ b/test/gen/function_decodeUrlTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_decodeUrlTest : public JsonataTest {
 };
 
-// $decodeUrl(\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\")
+// 
 TEST_F(function_decodeUrlTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrl/case000.json"));
 }
 
-// $decodeUrl(blah)
+// 
 TEST_F(function_decodeUrlTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrl/case001.json"));
 }
 
-// $decodeUrl('%E0%A4%A')
+// 
 TEST_F(function_decodeUrlTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrl/case002.json"));
 }
diff --git a/test/gen/function_distinctTest.cpp b/test/gen/function_distinctTest.cpp
index 1867bad..2b400da 100644
--- a/test/gen/function_distinctTest.cpp
+++ b/test/gen/function_distinctTest.cpp
@@ -6,43 +6,8 @@ using namespace jsonata;
 class function_distinctTest : public JsonataTest {
 };
 
-// $distinct([1,2,3,4])
-TEST_F(function_distinctTest, distinct_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 0));
-}
-
-// $distinct([1])
-TEST_F(function_distinctTest, distinct_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 1));
-}
-
-// $distinct(nothing)
-TEST_F(function_distinctTest, distinct_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 2));
-}
-
-// $distinct(null)
-TEST_F(function_distinctTest, distinct_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 3));
-}
-
-// $distinct('hello')
-TEST_F(function_distinctTest, distinct_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 4));
-}
-
-// $distinct(Account.Order.Product.SKU)
-TEST_F(function_distinctTest, distinct_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 5));
-}
-
-// $distinct(Account.Order.Product.`Product Name`)
-TEST_F(function_distinctTest, distinct_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 6));
-}
-
-// $distinct(Account.Order.Product.Description)
-TEST_F(function_distinctTest, distinct_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 7));
+// 
+TEST_F(function_distinctTest, distinct) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-distinct/distinct.json"));
 }
 
diff --git a/test/gen/function_eachTest.cpp b/test/gen/function_eachTest.cpp
index 3ed89c2..ffaf601 100644
--- a/test/gen/function_eachTest.cpp
+++ b/test/gen/function_eachTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_eachTest : public JsonataTest {
 };
 
-// $each(Address, λ($v, $k) {$k & \": \" & $v})
+// 
 TEST_F(function_eachTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-each/case000.json"));
 }
 
-// $each({'a': 'hello', 'b': 'world'}, $uppercase)
+// 
 TEST_F(function_eachTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-each/case001.json"));
 }
 
-// $each(function($v, $k) {$k[$v>2]})
+// 
 TEST_F(function_eachTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-each/case002.json"));
 }
diff --git a/test/gen/function_encodeUrlComponentTest.cpp b/test/gen/function_encodeUrlComponentTest.cpp
index 2fda2d8..87bf227 100644
--- a/test/gen/function_encodeUrlComponentTest.cpp
+++ b/test/gen/function_encodeUrlComponentTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_encodeUrlComponentTest : public JsonataTest {
 };
 
-// $encodeUrlComponent(\"?x=test\")
+// 
 TEST_F(function_encodeUrlComponentTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrlComponent/case000.json"));
 }
 
-// $encodeUrlComponent(blah)
+// 
 TEST_F(function_encodeUrlComponentTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrlComponent/case001.json"));
 }
diff --git a/test/gen/function_encodeUrlTest.cpp b/test/gen/function_encodeUrlTest.cpp
index 1cb059b..211368a 100644
--- a/test/gen/function_encodeUrlTest.cpp
+++ b/test/gen/function_encodeUrlTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_encodeUrlTest : public JsonataTest {
 };
 
-// $encodeUrl(\"https://mozilla.org/?x=шеллы\")
+// 
 TEST_F(function_encodeUrlTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrl/case000.json"));
 }
 
-// $encodeUrl(blah)
+// 
 TEST_F(function_encodeUrlTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrl/case001.json"));
 }
diff --git a/test/gen/function_errorTest.cpp b/test/gen/function_errorTest.cpp
index ce2d2c9..0fa645b 100644
--- a/test/gen/function_errorTest.cpp
+++ b/test/gen/function_errorTest.cpp
@@ -6,57 +6,57 @@ using namespace jsonata;
 class function_errorTest : public JsonataTest {
 };
 
-// Account.Order[0].Product[0].Price > 35 ? Account.Order[0].Product[0].Price : $error('Too Expensive')
+// 
 TEST_F(function_errorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case000.json"));
 }
 
-// Account.Order[0].Product[0].Price > 34 ? Account.Order[0].Product[0].Price : $error('Too Expensive')
+// 
 TEST_F(function_errorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case001.json"));
 }
 
-// Account.Order[0].Product[0].Price > 35 ? $error('Too Expensive') : Account.Order[0].Product[0].Price
+// 
 TEST_F(function_errorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case002.json"));
 }
 
-// Account.Order[0].Product[0].Price > 34 ? $error('Too Expensive') : Account.Order[0].Product[0].Price
+// 
 TEST_F(function_errorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case003.json"));
 }
 
-// $count(Account.Order[0].Product) < 2 ? $error('Not enough products in orders')
+// 
 TEST_F(function_errorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case004.json"));
 }
 
-// $count(Account.Order[0].Product) < 3 ? $error('Not enough products in orders')
+// 
 TEST_F(function_errorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case005.json"));
 }
 
-// ($msg:='My Message'; $error($msg); true)
+// 
 TEST_F(function_errorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case006.json"));
 }
 
-// $error(null)
+// 
 TEST_F(function_errorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case007.json"));
 }
 
-// $error(5)
+// 
 TEST_F(function_errorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case008.json"));
 }
 
-// $error()
+// 
 TEST_F(function_errorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case009.json"));
 }
 
-// $error(foo)
+// 
 TEST_F(function_errorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case010.json"));
 }
diff --git a/test/gen/function_evalTest.cpp b/test/gen/function_evalTest.cpp
index bae4842..f7cbcf6 100644
--- a/test/gen/function_evalTest.cpp
+++ b/test/gen/function_evalTest.cpp
@@ -6,63 +6,48 @@ using namespace jsonata;
 class function_evalTest : public JsonataTest {
 };
 
-// $eval('[1,2,3]')
+// 
 TEST_F(function_evalTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case000.json"));
 }
 
-// $eval(nothing)
+// 
 TEST_F(function_evalTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case001.json"));
 }
 
-// $eval('[1,$string(2),3]')
+// 
 TEST_F(function_evalTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case002.json"));
 }
 
-// $eval('Account.Order.Product.Quantity ~> $sum()')
+// 
 TEST_F(function_evalTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case003.json"));
 }
 
-// Account.Order.Product.{'Name': `Product Name`, 'Total': $eval('Price * Quantity')}
+// 
 TEST_F(function_evalTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case004.json"));
 }
 
-// Account.Order.Product.{'Name': `Product Name`, 'Volume': $eval('Width*Height*Depth', Description)}
+// 
 TEST_F(function_evalTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case005.json"));
 }
 
-// $eval('[1,string(2),3]')
+// 
 TEST_F(function_evalTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case006.json"));
 }
 
-// $eval('[1,#string(2),3]')
+// 
 TEST_F(function_evalTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case007.json"));
 }
 
-// $eval(\"{ 'test': 1 }\", [])
-TEST_F(function_evalTest, case008_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 0));
-}
-
-// $eval(\"{ 'test': 1 }\")
-TEST_F(function_evalTest, case008_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 1));
-}
-
-// $eval(\"{ 'test': 1 }\", [1,2,3])
-TEST_F(function_evalTest, case008_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 2));
-}
-
-// $eval(\"{ 'test': 1 }\")
-TEST_F(function_evalTest, case008_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 3));
+// 
+TEST_F(function_evalTest, case008) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case008.json"));
 }
 
diff --git a/test/gen/function_existsTest.cpp b/test/gen/function_existsTest.cpp
index ce96890..1767a9b 100644
--- a/test/gen/function_existsTest.cpp
+++ b/test/gen/function_existsTest.cpp
@@ -6,127 +6,127 @@ using namespace jsonata;
 class function_existsTest : public JsonataTest {
 };
 
-// $exists(\"Hello World\")
+// 
 TEST_F(function_existsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case000.json"));
 }
 
-// $exists(\"\")
+// 
 TEST_F(function_existsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case001.json"));
 }
 
-// $exists(true)
+// 
 TEST_F(function_existsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case002.json"));
 }
 
-// $exists(false)
+// 
 TEST_F(function_existsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case003.json"));
 }
 
-// $exists(0)
+// 
 TEST_F(function_existsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case004.json"));
 }
 
-// $exists(-0.5)
+// 
 TEST_F(function_existsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case005.json"));
 }
 
-// $exists(null)
+// 
 TEST_F(function_existsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case006.json"));
 }
 
-// $exists([])
+// 
 TEST_F(function_existsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case007.json"));
 }
 
-// $exists([0])
+// 
 TEST_F(function_existsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case008.json"));
 }
 
-// $exists([1,2,3])
+// 
 TEST_F(function_existsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case009.json"));
 }
 
-// $exists([[]])
+// 
 TEST_F(function_existsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case010.json"));
 }
 
-// $exists([[null]])
+// 
 TEST_F(function_existsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case011.json"));
 }
 
-// $exists([[[true]]])
+// 
 TEST_F(function_existsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case012.json"));
 }
 
-// $exists({})
+// 
 TEST_F(function_existsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case013.json"));
 }
 
-// $exists({\"hello\":\"world\"})
+// 
 TEST_F(function_existsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case014.json"));
 }
 
-// $exists(Account)
+// 
 TEST_F(function_existsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case015.json"));
 }
 
-// $exists(Account.Order.Product.Price)
+// 
 TEST_F(function_existsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case016.json"));
 }
 
-// $exists($exists)
+// 
 TEST_F(function_existsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case017.json"));
 }
 
-// $exists(function(){true})
+// 
 TEST_F(function_existsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case018.json"));
 }
 
-// $exists(blah)
+// 
 TEST_F(function_existsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case019.json"));
 }
 
-// $exists(Account.blah)
+// 
 TEST_F(function_existsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case020.json"));
 }
 
-// $exists(Account.Order[2])
+// 
 TEST_F(function_existsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case021.json"));
 }
 
-// $exists(Account.Order[0].blah)
+// 
 TEST_F(function_existsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case022.json"));
 }
 
-// $exists(2,3)
+// 
 TEST_F(function_existsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case023.json"));
 }
 
-// $exists()
+// 
 TEST_F(function_existsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case024.json"));
 }
diff --git a/test/gen/function_floorTest.cpp b/test/gen/function_floorTest.cpp
index dda475f..e5f23a8 100644
--- a/test/gen/function_floorTest.cpp
+++ b/test/gen/function_floorTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_floorTest : public JsonataTest {
 };
 
-// $floor(3.7)
+// 
 TEST_F(function_floorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case000.json"));
 }
 
-// $floor(-3.7)
+// 
 TEST_F(function_floorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case001.json"));
 }
 
-// $floor(0)
+// 
 TEST_F(function_floorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case002.json"));
 }
 
-// $floor(nothing)
+// 
 TEST_F(function_floorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case003.json"));
 }
diff --git a/test/gen/function_formatBaseTest.cpp b/test/gen/function_formatBaseTest.cpp
index 123dfe1..681ebdc 100644
--- a/test/gen/function_formatBaseTest.cpp
+++ b/test/gen/function_formatBaseTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class function_formatBaseTest : public JsonataTest {
 };
 
-// $formatBase(100)
+// 
 TEST_F(function_formatBaseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case000.json"));
 }
 
-// $formatBase(nothing)
+// 
 TEST_F(function_formatBaseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case001.json"));
 }
 
-// $formatBase(100, 2)
+// 
 TEST_F(function_formatBaseTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case002.json"));
 }
 
-// $formatBase(-100, 2)
+// 
 TEST_F(function_formatBaseTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case003.json"));
 }
 
-// $formatBase(100, 36)
+// 
 TEST_F(function_formatBaseTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case004.json"));
 }
 
-// $formatBase(99.5, 2.5)
+// 
 TEST_F(function_formatBaseTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case005.json"));
 }
 
-// $formatBase(100, 1)
+// 
 TEST_F(function_formatBaseTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case006.json"));
 }
 
-// $formatBase(100, 37)
+// 
 TEST_F(function_formatBaseTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case007.json"));
 }
diff --git a/test/gen/function_formatIntegerTest.cpp b/test/gen/function_formatIntegerTest.cpp
index a415a2a..6f6fe3b 100644
--- a/test/gen/function_formatIntegerTest.cpp
+++ b/test/gen/function_formatIntegerTest.cpp
@@ -6,328 +6,8 @@ using namespace jsonata;
 class function_formatIntegerTest : public JsonataTest {
 };
 
-// $formatInteger(undefined, '0')
-TEST_F(function_formatIntegerTest, formatInteger_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 0));
-}
-
-// $formatInteger(123, '000')
-TEST_F(function_formatIntegerTest, formatInteger_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 1));
-}
-
-// $formatInteger(123, '0000')
-TEST_F(function_formatIntegerTest, formatInteger_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 2));
-}
-
-// $formatInteger(-3, '0000')
-TEST_F(function_formatIntegerTest, formatInteger_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 3));
-}
-
-// $formatInteger(1234, '0;c')
-TEST_F(function_formatIntegerTest, formatInteger_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 4));
-}
-
-// $formatInteger(1234, '###0')
-TEST_F(function_formatIntegerTest, formatInteger_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 5));
-}
-
-// $formatInteger(12, '###0')
-TEST_F(function_formatIntegerTest, formatInteger_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 6));
-}
-
-// $formatInteger(12.6, '###0')
-TEST_F(function_formatIntegerTest, formatInteger_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 7));
-}
-
-// $formatInteger(123, '000;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 8));
-}
-
-// $formatInteger(1, '0;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 9));
-}
-
-// $formatInteger(28, '#0;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 10));
-}
-
-// $formatInteger(1234, '###0;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 11));
-}
-
-// $formatInteger(12, '###0;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 12));
-}
-
-// $formatInteger(12340, '###١')
-TEST_F(function_formatIntegerTest, formatInteger_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 13));
-}
-
-// $formatInteger(12340, '###０')
-TEST_F(function_formatIntegerTest, formatInteger_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 14));
-}
-
-// $formatInteger(12340, '##0０')
-TEST_F(function_formatIntegerTest, formatInteger_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 15));
-}
-
-// $formatInteger(12, '#,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 16));
-}
-
-// $formatInteger(1200, '#,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 17));
-}
-
-// $formatInteger(120000, '#,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 18));
-}
-
-// $formatInteger(12345678, '#,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_19) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 19));
-}
-
-// $formatInteger(1234567890, '#,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_20) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 20));
-}
-
-// $formatInteger(1234567890, '#,###,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_21) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 21));
-}
-
-// $formatInteger(1234567890, '#:###,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_22) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 22));
-}
-
-// $formatInteger(1234567890, '##,##,##0')
-TEST_F(function_formatIntegerTest, formatInteger_case_23) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 23));
-}
-
-// $formatInteger(0, 'I')
-TEST_F(function_formatIntegerTest, formatInteger_case_24) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 24));
-}
-
-// $formatInteger(1984, 'I')
-TEST_F(function_formatIntegerTest, formatInteger_case_25) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 25));
-}
-
-// $formatInteger(99, 'i')
-TEST_F(function_formatIntegerTest, formatInteger_case_26) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 26));
-}
-
-// $formatInteger(12, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_27) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 27));
-}
-
-// $formatInteger(20, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_28) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 28));
-}
-
-// $formatInteger(34, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_29) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 29));
-}
-
-// $formatInteger(99, 'W')
-TEST_F(function_formatIntegerTest, formatInteger_case_30) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 30));
-}
-
-// $formatInteger(100, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_31) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 31));
-}
-
-// $formatInteger(555, 'W')
-TEST_F(function_formatIntegerTest, formatInteger_case_32) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 32));
-}
-
-// $formatInteger(555, 'Ww')
-TEST_F(function_formatIntegerTest, formatInteger_case_33) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 33));
-}
-
-// $formatInteger(919, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_34) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 34));
-}
-
-// $formatInteger(730, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_35) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 35));
-}
-
-// $formatInteger(1000, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_36) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 36));
-}
-
-// $formatInteger(3730, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_37) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 37));
-}
-
-// $formatInteger(327730, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_38) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 38));
-}
-
-// $formatInteger(4327730, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_39) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 39));
-}
-
-// $formatInteger(1000000000001, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_40) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 40));
-}
-
-// $formatInteger(1234567890123, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_41) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 41));
-}
-
-// $formatInteger(1000000000000000, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_42) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 42));
-}
-
-// $formatInteger(1e+46, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_43) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 43));
-}
-
-// $formatInteger(1234567890123456, 'w')
-TEST_F(function_formatIntegerTest, formatInteger_case_44) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 44));
-}
-
-// $formatInteger(12, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_45) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 45));
-}
-
-// $formatInteger(20, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_46) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 46));
-}
-
-// $formatInteger(34, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_47) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 47));
-}
-
-// $formatInteger(99, 'W;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_48) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 48));
-}
-
-// $formatInteger(100, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_49) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 49));
-}
-
-// $formatInteger(555, 'W;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_50) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 50));
-}
-
-// $formatInteger(919, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_51) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 51));
-}
-
-// $formatInteger(730, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_52) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 52));
-}
-
-// $formatInteger(1000, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_53) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 53));
-}
-
-// $formatInteger(3731, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_54) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 54));
-}
-
-// $formatInteger(327713, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_55) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 55));
-}
-
-// $formatInteger(4327732, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_56) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 56));
-}
-
-// $formatInteger(1000000000001, 'w;o')
-TEST_F(function_formatIntegerTest, formatInteger_case_57) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 57));
-}
-
-// $formatInteger(1, 'A')
-TEST_F(function_formatIntegerTest, formatInteger_case_58) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 58));
-}
-
-// $formatInteger(12, 'a')
-TEST_F(function_formatIntegerTest, formatInteger_case_59) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 59));
-}
-
-// $formatInteger(26, 'a')
-TEST_F(function_formatIntegerTest, formatInteger_case_60) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 60));
-}
-
-// $formatInteger(27, 'a')
-TEST_F(function_formatIntegerTest, formatInteger_case_61) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 61));
-}
-
-// $formatInteger(300, 'A')
-TEST_F(function_formatIntegerTest, formatInteger_case_62) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 62));
-}
-
-// $formatInteger(123456, 'A')
-TEST_F(function_formatIntegerTest, formatInteger_case_63) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 63));
-}
-
-// $formatInteger(123456, 'α')
-TEST_F(function_formatIntegerTest, formatInteger_case_64) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 64));
+// 
+TEST_F(function_formatIntegerTest, formatInteger) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json"));
 }
 
diff --git a/test/gen/function_formatNumberTest.cpp b/test/gen/function_formatNumberTest.cpp
index b1a7012..80903d8 100644
--- a/test/gen/function_formatNumberTest.cpp
+++ b/test/gen/function_formatNumberTest.cpp
@@ -6,187 +6,187 @@ using namespace jsonata;
 class function_formatNumberTest : public JsonataTest {
 };
 
-// $formatNumber(12345.6, \"#,###.00\")
+// 
 TEST_F(function_formatNumberTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case000.json"));
 }
 
-// $formatNumber(12345678.9, \"9,999.99\")
+// 
 TEST_F(function_formatNumberTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case001.json"));
 }
 
-// $formatNumber(123412345678.9, \"9,9,99.99\")
+// 
 TEST_F(function_formatNumberTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case002.json"));
 }
 
-// $formatNumber(1234.56789, \"9,999.999,999\")
+// 
 TEST_F(function_formatNumberTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case003.json"));
 }
 
-// $formatNumber(123.9, \"9999\")
+// 
 TEST_F(function_formatNumberTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case004.json"));
 }
 
-// $formatNumber(0.14, \"01%\")
+// 
 TEST_F(function_formatNumberTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case005.json"));
 }
 
-// $formatNumber(0.4857,\"###.###‰\")
+// 
 TEST_F(function_formatNumberTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case006.json"));
 }
 
-// $formatNumber(0.14, \"###pm\", {\"per-mille\": \"pm\"})
+// 
 TEST_F(function_formatNumberTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case007.json"));
 }
 
-// $formatNumber(-6, \"000\")
+// 
 TEST_F(function_formatNumberTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case008.json"));
 }
 
-// $formatNumber(1234.5678, \"00.000e0\")
+// 
 TEST_F(function_formatNumberTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case009.json"));
 }
 
-// $formatNumber(1234.5678, \"00.000e000\")
+// 
 TEST_F(function_formatNumberTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case010.json"));
 }
 
-// $formatNumber(1234.5678, \"①①.①①①e①\", {\"zero-digit\": \"⑟\"})
+// 
 TEST_F(function_formatNumberTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case011.json"));
 }
 
-// $formatNumber(0.234, \"0.0e0\")
+// 
 TEST_F(function_formatNumberTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case012.json"));
 }
 
-// $formatNumber(0.234, \"#.00e0\")
+// 
 TEST_F(function_formatNumberTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case013.json"));
 }
 
-// $formatNumber(0.123, \"#.e9\")
+// 
 TEST_F(function_formatNumberTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case014.json"));
 }
 
-// $formatNumber(0.234, \".00e0\")
+// 
 TEST_F(function_formatNumberTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case015.json"));
 }
 
-// $formatNumber(2392.14*(-36.58), \"000,000.000###;###,###.000###\")
+// 
 TEST_F(function_formatNumberTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case016.json"));
 }
 
-// $formatNumber(2.14*86.58,\"PREFIX##00.000###SUFFIX\")
+// 
 TEST_F(function_formatNumberTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case017.json"));
 }
 
-// $formatNumber(1E20,\"#,######\")
+// 
 TEST_F(function_formatNumberTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case018.json"));
 }
 
-// $formatNumber(20,\"#;#;#\")
+// 
 TEST_F(function_formatNumberTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case019.json"));
 }
 
-// $formatNumber(20,\"#.0.0\")
+// 
 TEST_F(function_formatNumberTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case020.json"));
 }
 
-// $formatNumber(20,\"#0%%\")
+// 
 TEST_F(function_formatNumberTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case021.json"));
 }
 
-// $formatNumber(20,\"#0‰‰\")
+// 
 TEST_F(function_formatNumberTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case022.json"));
 }
 
-// $formatNumber(20,\"#0%‰\")
+// 
 TEST_F(function_formatNumberTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case023.json"));
 }
 
-// $formatNumber(20,\".e0\")
+// 
 TEST_F(function_formatNumberTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case024.json"));
 }
 
-// $formatNumber(20,\"0+.e0\")
+// 
 TEST_F(function_formatNumberTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case025.json"));
 }
 
-// $formatNumber(20,\"0,.e0\")
+// 
 TEST_F(function_formatNumberTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case026.json"));
 }
 
-// $formatNumber(20,\"0,\")
+// 
 TEST_F(function_formatNumberTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case027.json"));
 }
 
-// $formatNumber(20,\"0,,0\")
+// 
 TEST_F(function_formatNumberTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case028.json"));
 }
 
-// $formatNumber(20,\"0#.e0\")
+// 
 TEST_F(function_formatNumberTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case029.json"));
 }
 
-// $formatNumber(20,\"#0.#0e0\")
+// 
 TEST_F(function_formatNumberTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case030.json"));
 }
 
-// $formatNumber(20,\"#0.0e0%\")
+// 
 TEST_F(function_formatNumberTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case031.json"));
 }
 
-// $formatNumber(20,\"#0.0e0,0\")
+// 
 TEST_F(function_formatNumberTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case032.json"));
 }
 
-// $formatNumber(2, '000.000')
+// 
 TEST_F(function_formatNumberTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case033.json"));
 }
 
-// $formatNumber(2, 'AAA.AAA', {'zero-digit': 'A'})
+// 
 TEST_F(function_formatNumberTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case034.json"));
 }
 
-// $formatNumber(0.1, 'AeAAA', {'zero-digit': 'A'})
+// 
 TEST_F(function_formatNumberTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case035.json"));
 }
 
-// $formatNumber(foo, '#0.00')
+// 
 TEST_F(function_formatNumberTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case036.json"));
 }
diff --git a/test/gen/function_fromMillisTest.cpp b/test/gen/function_fromMillisTest.cpp
index 56be142..8b79709 100644
--- a/test/gen/function_fromMillisTest.cpp
+++ b/test/gen/function_fromMillisTest.cpp
@@ -6,468 +6,28 @@ using namespace jsonata;
 class function_fromMillisTest : public JsonataTest {
 };
 
-// $fromMillis(1)
+// 
 TEST_F(function_fromMillisTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/case000.json"));
 }
 
-// $fromMillis(1509380732935)
+// 
 TEST_F(function_fromMillisTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/case001.json"));
 }
 
-// $fromMillis(foo)
+// 
 TEST_F(function_fromMillisTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/case002.json"));
 }
 
-// $fromMillis(undefined, 'undefined')
-TEST_F(function_fromMillisTest, formatDateTime_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 0));
+// 
+TEST_F(function_fromMillisTest, formatDateTime) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json"));
 }
 
-// $fromMillis(1521801216617, 'Hello')
-TEST_F(function_fromMillisTest, formatDateTime_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 1));
-}
-
-// $fromMillis(1521801216617, 'Year: [Y0001]')
-TEST_F(function_fromMillisTest, formatDateTime_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 2));
-}
-
-// $fromMillis(1521801216617, 'Year: <[Y0001]>')
-TEST_F(function_fromMillisTest, formatDateTime_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 3));
-}
-
-// $fromMillis(1521801216617, 'Year: <[Y9,999,*]>')
-TEST_F(function_fromMillisTest, formatDateTime_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 4));
-}
-
-// $fromMillis(1521801216617, '[[Year: <[Y0001]>')
-TEST_F(function_fromMillisTest, formatDateTime_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 5));
-}
-
-// $fromMillis(1521801216617, 'Year]]: <[Y0001]>')
-TEST_F(function_fromMillisTest, formatDateTime_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 6));
-}
-
-// $fromMillis(1521801216617, '[[Year]]: [[[Y0001]]]')
-TEST_F(function_fromMillisTest, formatDateTime_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 7));
-}
-
-// $fromMillis(1521801216617, '[D#1]/[M#1]/[Y0001]')
-TEST_F(function_fromMillisTest, formatDateTime_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 8));
-}
-
-// $fromMillis(1522616700000, '[F0] [FNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 9));
-}
-
-// $fromMillis(1522703100000, '[F0] [FNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 10));
-}
-
-// $fromMillis(1521801216617, '[Y0001]-[M01]-[D01]')
-TEST_F(function_fromMillisTest, formatDateTime_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 11));
-}
-
-// $fromMillis(1521801216617, '[M01]/[D01]/[Y0001] at [H01]:[m01]:[s01]')
-TEST_F(function_fromMillisTest, formatDateTime_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 12));
-}
-
-// $fromMillis(1521801216617, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z01:01t]')
-TEST_F(function_fromMillisTest, formatDateTime_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 13));
-}
-
-// $fromMillis(1521801216617, '[Y]-[ M01]-[D 01]T[H01 ]:[ m   ]:[s].[f0  01][Z01:  01t]')
-TEST_F(function_fromMillisTest, formatDateTime_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 14));
-}
-
-// $fromMillis(1521801216617, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z0101t]', '+0100')
-TEST_F(function_fromMillisTest, formatDateTime_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 15));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z01:01]')
-TEST_F(function_fromMillisTest, formatDateTime_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 16));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z01:01t]')
-TEST_F(function_fromMillisTest, formatDateTime_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 17));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z]', '-0500')
-TEST_F(function_fromMillisTest, formatDateTime_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 18));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z0]', '-0500')
-TEST_F(function_fromMillisTest, formatDateTime_case_19) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 19));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z]', '+1000')
-TEST_F(function_fromMillisTest, formatDateTime_case_20) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 20));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z0]', '+1000')
-TEST_F(function_fromMillisTest, formatDateTime_case_21) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 21));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z0]', '+0530')
-TEST_F(function_fromMillisTest, formatDateTime_case_22) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 22));
-}
-
-// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][z]', '-0500')
-TEST_F(function_fromMillisTest, formatDateTime_case_23) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 23));
-}
-
-// $fromMillis(1204405500000, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z0101t]', '+0530')
-TEST_F(function_fromMillisTest, formatDateTime_case_24) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 24));
-}
-
-// $fromMillis(1230757500000, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z0101t]', '+0530')
-TEST_F(function_fromMillisTest, formatDateTime_case_25) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 25));
-}
-
-// $fromMillis(1230757500000, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z010101t]', '+0530')
-TEST_F(function_fromMillisTest, formatDateTime_case_26) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 26));
-}
-
-// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y,2]')
-TEST_F(function_fromMillisTest, formatDateTime_case_27) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 27));
-}
-
-// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y0001,2]')
-TEST_F(function_fromMillisTest, formatDateTime_case_28) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 28));
-}
-
-// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y##01,2-2]')
-TEST_F(function_fromMillisTest, formatDateTime_case_29) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 29));
-}
-
-// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y0001,2-2]')
-TEST_F(function_fromMillisTest, formatDateTime_case_30) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 30));
-}
-
-// $fromMillis(1521801216617, '[D1] [M01] [YI]')
-TEST_F(function_fromMillisTest, formatDateTime_case_31) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 31));
-}
-
-// $fromMillis(1521801216617, '[Da] [MA] [Yi]')
-TEST_F(function_fromMillisTest, formatDateTime_case_32) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 32));
-}
-
-// $fromMillis(1521801216617, '[D1o] [M01] [Y]')
-TEST_F(function_fromMillisTest, formatDateTime_case_33) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 33));
-}
-
-// $fromMillis(1521801216617, '[Yw]')
-TEST_F(function_fromMillisTest, formatDateTime_case_34) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 34));
-}
-
-// $fromMillis(1521801216617, '[Dwo] [M01] [Y]')
-TEST_F(function_fromMillisTest, formatDateTime_case_35) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 35));
-}
-
-// $fromMillis(1521801216617, '[D1o] [MNn] [Y]')
-TEST_F(function_fromMillisTest, formatDateTime_case_36) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 36));
-}
-
-// $fromMillis(1521801216617, '[D1o] [MN] [Y]')
-TEST_F(function_fromMillisTest, formatDateTime_case_37) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 37));
-}
-
-// $fromMillis(1521801216617, '[FNn], [D1o] [MNn] [Y]')
-TEST_F(function_fromMillisTest, formatDateTime_case_38) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 38));
-}
-
-// $fromMillis(1521801216617, '[FNn], the [Dwo] of [MNn] [Y] [E]')
-TEST_F(function_fromMillisTest, formatDateTime_case_39) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 39));
-}
-
-// $fromMillis(1521801216617, '[FNn,3-3], [D1o] [MNn,3-3] [Y] [C]')
-TEST_F(function_fromMillisTest, formatDateTime_case_40) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 40));
-}
-
-// $fromMillis(1521801216617, '[F], [D]/[M]/[Y] [h]:[m]:[s] [P]')
-TEST_F(function_fromMillisTest, formatDateTime_case_41) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 41));
-}
-
-// $fromMillis(1204405500000, '[F], [D]/[M]/[Y] [h]:[m]:[s] [P]')
-TEST_F(function_fromMillisTest, formatDateTime_case_42) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 42));
-}
-
-// $fromMillis(1199664000000, '[F], [D]/[M]/[Y] [h]:[m]:[s] [P]')
-TEST_F(function_fromMillisTest, formatDateTime_case_43) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 43));
-}
-
-// $fromMillis(1514808000000, '[dwo] day of the year')
-TEST_F(function_fromMillisTest, formatDateTime_case_44) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 44));
-}
-
-// $fromMillis(1546257600000, '[d] days in [Y0001]')
-TEST_F(function_fromMillisTest, formatDateTime_case_45) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 45));
-}
-
-// $fromMillis(1483185600000, '[d] days in [Y0001]')
-TEST_F(function_fromMillisTest, formatDateTime_case_46) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 46));
-}
-
-// $fromMillis(1514808000000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_47) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 47));
-}
-
-// $fromMillis(1515326400000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_48) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 48));
-}
-
-// $fromMillis(1545739200000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_49) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 49));
-}
-
-// $fromMillis(1388577600000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_50) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 50));
-}
-
-// $fromMillis(1419854400000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_51) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 51));
-}
-
-// $fromMillis(1419768000000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_52) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 52));
-}
-
-// $fromMillis(1419336000000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_53) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 53));
-}
-
-// $fromMillis(1420113600000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_54) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 54));
-}
-
-// $fromMillis(1420459200000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_55) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 55));
-}
-
-// $fromMillis(1451304000000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_56) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 56));
-}
-
-// $fromMillis(1451563200000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_57) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 57));
-}
-
-// $fromMillis(1451736000000, 'Week: [W]')
-TEST_F(function_fromMillisTest, formatDateTime_case_58) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 58));
-}
-
-// $fromMillis(1359460800000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_59) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 59));
-}
-
-// $fromMillis(1359633600000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_60) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 60));
-}
-
-// $fromMillis(1359720000000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_61) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 61));
-}
-
-// $fromMillis(1514808000000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_62) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 62));
-}
-
-// $fromMillis(1483272000000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_63) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 63));
-}
-
-// $fromMillis(1533038400000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_64) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 64));
-}
-
-// $fromMillis(1419940800000, 'Week: [w] of [xNn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_65) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 65));
-}
-
-// $toMillis('2018-10-21T13:05:00Z').[$fromMillis(), $fromMillis($, (),'-0500'), $fromMillis($, (),'0000')] 
-TEST_F(function_fromMillisTest, formatDateTime_case_66) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 66));
-}
-
-// $fromMillis(1521801216617, '[F], [D]/[M]/[Y] [h]:[m]:[s] [PN]')
-TEST_F(function_fromMillisTest, formatDateTime_case_67) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 67));
-}
-
-// $fromMillis(1521801216617, '[F], [D]/[M]/[Y] [h]:[m]:[s] [Pn]')
-TEST_F(function_fromMillisTest, formatDateTime_case_68) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 68));
-}
-
-// $fromMillis(1419940800000, '[YN]-[M]-[D]')
-TEST_F(function_fromMillisTest, formatDateTime_case_69) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 69));
-}
-
-// $fromMillis(1419940800000, '[YN]-[M')
-TEST_F(function_fromMillisTest, formatDateTime_case_70) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 70));
-}
-
-// ($ts := $toMillis('2005-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 0));
-}
-
-// ($ts := $toMillis('2005-01-02', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 1));
-}
-
-// ($ts := $toMillis('2005-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 2));
-}
-
-// ($ts := $toMillis('2006-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 3));
-}
-
-// ($ts := $toMillis('2006-01-02', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 4));
-}
-
-// ($ts := $toMillis('2006-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 5));
-}
-
-// ($ts := $toMillis('2007-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 6));
-}
-
-// ($ts := $toMillis('2007-12-30', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 7));
-}
-
-// ($ts := $toMillis('2007-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 8));
-}
-
-// ($ts := $toMillis('2008-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 9));
-}
-
-// ($ts := $toMillis('2008-12-28', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 10));
-}
-
-// ($ts := $toMillis('2008-12-29', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 11));
-}
-
-// ($ts := $toMillis('2008-12-30', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 12));
-}
-
-// ($ts := $toMillis('2008-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 13));
-}
-
-// ($ts := $toMillis('2009-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 14));
-}
-
-// ($ts := $toMillis('2009-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 15));
-}
-
-// ($ts := $toMillis('2010-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 16));
-}
-
-// ($ts := $toMillis('2010-01-02', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 17));
-}
-
-// ($ts := $toMillis('2010-01-03', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
-TEST_F(function_fromMillisTest, isoWeekDate_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 18));
+// 
+TEST_F(function_fromMillisTest, isoWeekDate) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json"));
 }
 
diff --git a/test/gen/function_joinTest.cpp b/test/gen/function_joinTest.cpp
index 3d4e72f..35b36b8 100644
--- a/test/gen/function_joinTest.cpp
+++ b/test/gen/function_joinTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class function_joinTest : public JsonataTest {
 };
 
-// $join(\"hello\")
+// 
 TEST_F(function_joinTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case000.json"));
 }
 
-// $join([\"hello\"])
+// 
 TEST_F(function_joinTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case001.json"));
 }
 
-// $join([\"hello\", \"world\"])
+// 
 TEST_F(function_joinTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case002.json"));
 }
 
-// $join([\"hello\", \"world\"], \", \")
+// 
 TEST_F(function_joinTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case003.json"));
 }
 
-// $join([], \", \")
+// 
 TEST_F(function_joinTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case004.json"));
 }
 
-// $join(Account.Order.Product.Description.Colour, \", \")
+// 
 TEST_F(function_joinTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case005.json"));
 }
 
-// $join(Account.Order.Product.Description.Colour, no.sep)
+// 
 TEST_F(function_joinTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case006.json"));
 }
 
-// $join(Account.blah.Product.Description.Colour, \", \")
+// 
 TEST_F(function_joinTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case007.json"));
 }
 
-// $join(true, \", \")
+// 
 TEST_F(function_joinTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case008.json"));
 }
 
-// $join([1,2,3], \", \")
+// 
 TEST_F(function_joinTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case009.json"));
 }
 
-// $join([\"hello\"], 3)
+// 
 TEST_F(function_joinTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case010.json"));
 }
 
-// $join()
+// 
 TEST_F(function_joinTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case011.json"));
 }
diff --git a/test/gen/function_keysTest.cpp b/test/gen/function_keysTest.cpp
index bbf30c9..5e0d011 100644
--- a/test/gen/function_keysTest.cpp
+++ b/test/gen/function_keysTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_keysTest : public JsonataTest {
 };
 
-// $keys(Account)
+// 
 TEST_F(function_keysTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case000.json"));
 }
 
-// $keys(Account.Order.Product)
+// 
 TEST_F(function_keysTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case001.json"));
 }
 
-// $keys({})
+// 
 TEST_F(function_keysTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case002.json"));
 }
 
-// $keys({\"foo\":{}})
+// 
 TEST_F(function_keysTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case003.json"));
 }
 
-// $keys(\"foo\")
+// 
 TEST_F(function_keysTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case004.json"));
 }
 
-// $keys(function(){1})
+// 
 TEST_F(function_keysTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case005.json"));
 }
 
-// $keys([\"foo\", \"bar\"])
+// 
 TEST_F(function_keysTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case006.json"));
 }
diff --git a/test/gen/function_lengthTest.cpp b/test/gen/function_lengthTest.cpp
index 3890edf..870df01 100644
--- a/test/gen/function_lengthTest.cpp
+++ b/test/gen/function_lengthTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_lengthTest : public JsonataTest {
 };
 
-// $length(\"\")
+// 
 TEST_F(function_lengthTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case000.json"));
 }
 
-// $length(\"hello\")
+// 
 TEST_F(function_lengthTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case001.json"));
 }
 
-// $length(missing)
+// 
 TEST_F(function_lengthTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case002.json"));
 }
 
-// $length(\"\\u03BB-calculus\")
+// 
 TEST_F(function_lengthTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case003.json"));
 }
@@ -31,62 +31,62 @@ TEST_F(function_lengthTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case004.json"));
 }
 
-// $length(\"𝄞\")
+// 
 TEST_F(function_lengthTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case005.json"));
 }
 
-// $length(\"超明體繁\")
+// 
 TEST_F(function_lengthTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case006.json"));
 }
 
-// $length(\"\\t\")
+// 
 TEST_F(function_lengthTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case007.json"));
 }
 
-// $length(\"\\n\")
+// 
 TEST_F(function_lengthTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case008.json"));
 }
 
-// $length(1234)
+// 
 TEST_F(function_lengthTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case009.json"));
 }
 
-// $length(null)
+// 
 TEST_F(function_lengthTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case010.json"));
 }
 
-// $length(true)
+// 
 TEST_F(function_lengthTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case011.json"));
 }
 
-// $length([\"str\"])
+// 
 TEST_F(function_lengthTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case012.json"));
 }
 
-// $length()
+// 
 TEST_F(function_lengthTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case013.json"));
 }
 
-// $length()
+// 
 TEST_F(function_lengthTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case014.json"));
 }
 
-// $length(\"Hello\", \"World\")
+// 
 TEST_F(function_lengthTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case015.json"));
 }
 
-// $length(\"𝄞💩\")
+// 
 TEST_F(function_lengthTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case016.json"));
 }
diff --git a/test/gen/function_lookupTest.cpp b/test/gen/function_lookupTest.cpp
index c117769..560ca64 100644
--- a/test/gen/function_lookupTest.cpp
+++ b/test/gen/function_lookupTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_lookupTest : public JsonataTest {
 };
 
-// $lookup(Account, \"Account Name\")
+// 
 TEST_F(function_lookupTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case000.json"));
 }
 
-// $lookup(Account.Order.Product, \"Product Name\")
+// 
 TEST_F(function_lookupTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case001.json"));
 }
 
-// $lookup(Account.Order.Product.ProductID, \"Product Name\")
+// 
 TEST_F(function_lookupTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case002.json"));
 }
 
-// $lookup($$, \"gust\")
+// 
 TEST_F(function_lookupTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case003.json"));
 }
diff --git a/test/gen/function_lowercaseTest.cpp b/test/gen/function_lowercaseTest.cpp
index 773f764..a27d319 100644
--- a/test/gen/function_lowercaseTest.cpp
+++ b/test/gen/function_lowercaseTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_lowercaseTest : public JsonataTest {
 };
 
-// $lowercase(\"Hello World\")
+// 
 TEST_F(function_lowercaseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lowercase/case000.json"));
 }
 
-// $lowercase(blah)
+// 
 TEST_F(function_lowercaseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lowercase/case001.json"));
 }
diff --git a/test/gen/function_maxTest.cpp b/test/gen/function_maxTest.cpp
index ab30d8e..44c0fa3 100644
--- a/test/gen/function_maxTest.cpp
+++ b/test/gen/function_maxTest.cpp
@@ -6,137 +6,137 @@ using namespace jsonata;
 class function_maxTest : public JsonataTest {
 };
 
-// $max(Account.Order.Product.(Price * Quantity))
+// 
 TEST_F(function_maxTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case000.json"));
 }
 
-// Account.Order.$max(Product.(Price * Quantity))
+// 
 TEST_F(function_maxTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case001.json"));
 }
 
-// Account.Order.(OrderID & \": \" & $count(Product.(Price*Quantity)))
+// 
 TEST_F(function_maxTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case002.json"));
 }
 
-// $max([])
+// 
 TEST_F(function_maxTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case003.json"));
 }
 
-// $max([1,2,3])
+// 
 TEST_F(function_maxTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case004.json"));
 }
 
-// $max([\"1\",\"2\",\"3\"])
+// 
 TEST_F(function_maxTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case005.json"));
 }
 
-// $max([\"1\",\"2\",3])
+// 
 TEST_F(function_maxTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case006.json"));
 }
 
-// $max(1)
+// 
 TEST_F(function_maxTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case007.json"));
 }
 
-// $max([-1,-5])
+// 
 TEST_F(function_maxTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case008.json"));
 }
 
-// $max([],[])
+// 
 TEST_F(function_maxTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case009.json"));
 }
 
-// $max([1,2,3],[])
+// 
 TEST_F(function_maxTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case010.json"));
 }
 
-// $max([],[],[])
+// 
 TEST_F(function_maxTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case011.json"));
 }
 
-// $max([1,2],[],[])
+// 
 TEST_F(function_maxTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case012.json"));
 }
 
-// $max(undefined)
+// 
 TEST_F(function_maxTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case013.json"));
 }
 
-// $min(Account.Order.Product.(Price * Quantity))
+// 
 TEST_F(function_maxTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case014.json"));
 }
 
-// Account.Order.$min(Product.(Price * Quantity))
+// 
 TEST_F(function_maxTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case015.json"));
 }
 
-// Account.Order.(OrderID & \": \" & $min(Product.(Price*Quantity)))
+// 
 TEST_F(function_maxTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case016.json"));
 }
 
-// $min([])
+// 
 TEST_F(function_maxTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case017.json"));
 }
 
-// $min([1,2,3])
+// 
 TEST_F(function_maxTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case018.json"));
 }
 
-// $min([\"1\",\"2\",\"3\"])
+// 
 TEST_F(function_maxTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case019.json"));
 }
 
-// $min([\"1\",\"2\",3])
+// 
 TEST_F(function_maxTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case020.json"));
 }
 
-// $min(1)
+// 
 TEST_F(function_maxTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case021.json"));
 }
 
-// $min([],[])
+// 
 TEST_F(function_maxTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case022.json"));
 }
 
-// $min([1,2,3],[])
+// 
 TEST_F(function_maxTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case023.json"));
 }
 
-// $min([],[],[])
+// 
 TEST_F(function_maxTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case024.json"));
 }
 
-// $min([1,2],[],[])
+// 
 TEST_F(function_maxTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case025.json"));
 }
 
-// $min(undefined)
+// 
 TEST_F(function_maxTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case026.json"));
 }
diff --git a/test/gen/function_mergeTest.cpp b/test/gen/function_mergeTest.cpp
index f0ae95b..237117f 100644
--- a/test/gen/function_mergeTest.cpp
+++ b/test/gen/function_mergeTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_mergeTest : public JsonataTest {
 };
 
-// $merge(nothing)
+// 
 TEST_F(function_mergeTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case000.json"));
 }
 
-// $merge({\"a\":1})
+// 
 TEST_F(function_mergeTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case001.json"));
 }
 
-// $merge([{\"a\":1}, {\"b\":2}])
+// 
 TEST_F(function_mergeTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case002.json"));
 }
 
-// $merge([{\"a\": 1}, {\"b\": 2, \"c\": 3}])
+// 
 TEST_F(function_mergeTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case003.json"));
 }
 
-// $merge([{\"a\": 1}, {\"b\": 2, \"a\": 3}])
+// 
 TEST_F(function_mergeTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case004.json"));
 }
diff --git a/test/gen/function_numberTest.cpp b/test/gen/function_numberTest.cpp
index c56bf32..b97eda8 100644
--- a/test/gen/function_numberTest.cpp
+++ b/test/gen/function_numberTest.cpp
@@ -6,172 +6,172 @@ using namespace jsonata;
 class function_numberTest : public JsonataTest {
 };
 
-// $number(0)
+// 
 TEST_F(function_numberTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case000.json"));
 }
 
-// $number(10)
+// 
 TEST_F(function_numberTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case001.json"));
 }
 
-// $number(-0.05)
+// 
 TEST_F(function_numberTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case002.json"));
 }
 
-// $number(\"0\")
+// 
 TEST_F(function_numberTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case003.json"));
 }
 
-// $number(\"-0.05\")
+// 
 TEST_F(function_numberTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case004.json"));
 }
 
-// $number(\"1e2\")
+// 
 TEST_F(function_numberTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case005.json"));
 }
 
-// $number(\"1.0e-2\")
+// 
 TEST_F(function_numberTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case006.json"));
 }
 
-// $number(\"1e0\")
+// 
 TEST_F(function_numberTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case007.json"));
 }
 
-// $number(\"10e500\")
+// 
 TEST_F(function_numberTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case008.json"));
 }
 
-// $number(\"Hello world\")
+// 
 TEST_F(function_numberTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case009.json"));
 }
 
-// $number(\"1/2\")
+// 
 TEST_F(function_numberTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case010.json"));
 }
 
-// $number(\"1234 hello\")
+// 
 TEST_F(function_numberTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case011.json"));
 }
 
-// $number(\"\")
+// 
 TEST_F(function_numberTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case012.json"));
 }
 
-// $number(true)
+// 
 TEST_F(function_numberTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case013.json"));
 }
 
-// $number(false)
+// 
 TEST_F(function_numberTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case014.json"));
 }
 
-// $number(Account.blah)
+// 
 TEST_F(function_numberTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case015.json"));
 }
 
-// $number(null)
+// 
 TEST_F(function_numberTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case016.json"));
 }
 
-// $number([])
+// 
 TEST_F(function_numberTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case017.json"));
 }
 
-// $number(\"[1]\")
+// 
 TEST_F(function_numberTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case018.json"));
 }
 
-// $number([1,2])
+// 
 TEST_F(function_numberTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case019.json"));
 }
 
-// $number([\"hello\"])
+// 
 TEST_F(function_numberTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case020.json"));
 }
 
-// $number([\"2\"])
+// 
 TEST_F(function_numberTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case021.json"));
 }
 
-// $number({})
+// 
 TEST_F(function_numberTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case022.json"));
 }
 
-// $number({\"hello\":\"world\"})
+// 
 TEST_F(function_numberTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case023.json"));
 }
 
-// $number($number)
+// 
 TEST_F(function_numberTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case024.json"));
 }
 
-// $number(function(){5})
+// 
 TEST_F(function_numberTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case025.json"));
 }
 
-// $number(1,2)
+// 
 TEST_F(function_numberTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case026.json"));
 }
 
-// $number('00')
+// 
 TEST_F(function_numberTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case027.json"));
 }
 
-// $number('0123')
+// 
 TEST_F(function_numberTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case028.json"));
 }
 
-// $number('-007')
+// 
 TEST_F(function_numberTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case029.json"));
 }
 
-// $number('000.00123000')
+// 
 TEST_F(function_numberTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case030.json"));
 }
 
-// $number('0x12')
+// 
 TEST_F(function_numberTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case031.json"));
 }
 
-// $number('0B101')
+// 
 TEST_F(function_numberTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case032.json"));
 }
 
-// $number('0O12')
+// 
 TEST_F(function_numberTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case033.json"));
 }
diff --git a/test/gen/function_padTest.cpp b/test/gen/function_padTest.cpp
index 8744a11..1599604 100644
--- a/test/gen/function_padTest.cpp
+++ b/test/gen/function_padTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class function_padTest : public JsonataTest {
 };
 
-// $pad(\"foo\", 5)
+// 
 TEST_F(function_padTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case000.json"));
 }
 
-// $pad(\"foo\", -5)
+// 
 TEST_F(function_padTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case001.json"));
 }
 
-// $pad(\"foo\", -5, \"#\")
+// 
 TEST_F(function_padTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case002.json"));
 }
 
-// $pad(\"foo\", 5, \"\")
+// 
 TEST_F(function_padTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case003.json"));
 }
 
-// $pad(\"foo\", 1)
+// 
 TEST_F(function_padTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case004.json"));
 }
 
-// $pad(\"foo\", 8, \"-+\")
+// 
 TEST_F(function_padTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case005.json"));
 }
 
-// $pad(nothing, 1)
+// 
 TEST_F(function_padTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case006.json"));
 }
 
-// $pad('a𝄞💩', 7)
+// 
 TEST_F(function_padTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case007.json"));
 }
 
-// $pad('𝄞💩', -7)
+// 
 TEST_F(function_padTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case008.json"));
 }
 
-// $pad('a𝄞💩', 7, '💩')
+// 
 TEST_F(function_padTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case009.json"));
 }
 
-// $pad('a𝄞💩', 6, '💩')
+// 
 TEST_F(function_padTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case010.json"));
 }
 
-// $pad('foo', 5.7, ' ')
+// 
 TEST_F(function_padTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case011.json"));
 }
 
-// $pad('foo', -5.7, ' ')
+// 
 TEST_F(function_padTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case012.json"));
 }
diff --git a/test/gen/function_parseIntegerTest.cpp b/test/gen/function_parseIntegerTest.cpp
index 414d623..02e4c02 100644
--- a/test/gen/function_parseIntegerTest.cpp
+++ b/test/gen/function_parseIntegerTest.cpp
@@ -6,308 +6,8 @@ using namespace jsonata;
 class function_parseIntegerTest : public JsonataTest {
 };
 
-// $parseInteger(undefined, '0')
-TEST_F(function_parseIntegerTest, parseInteger_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 0));
-}
-
-// $parseInteger('123', '000')
-TEST_F(function_parseIntegerTest, parseInteger_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 1));
-}
-
-// $parseInteger('0123', '0000')
-TEST_F(function_parseIntegerTest, parseInteger_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 2));
-}
-
-// $parseInteger('1234', '0')
-TEST_F(function_parseIntegerTest, parseInteger_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 3));
-}
-
-// $parseInteger('1234', '###0')
-TEST_F(function_parseIntegerTest, parseInteger_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 4));
-}
-
-// $parseInteger('12', '###0')
-TEST_F(function_parseIntegerTest, parseInteger_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 5));
-}
-
-// $parseInteger('123rd', '000;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 6));
-}
-
-// $parseInteger('1st', '0;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 7));
-}
-
-// $parseInteger('28th', '#0;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 8));
-}
-
-// $parseInteger('1234th', '###0;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 9));
-}
-
-// $parseInteger('12th', '###0;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 10));
-}
-
-// $parseInteger('١٢٣٤٠', '###١')
-TEST_F(function_parseIntegerTest, parseInteger_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 11));
-}
-
-// $parseInteger('１２３４０', '###０')
-TEST_F(function_parseIntegerTest, parseInteger_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 12));
-}
-
-// $parseInteger('12', '#,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 13));
-}
-
-// $parseInteger('1,200', '#,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 14));
-}
-
-// $parseInteger('12,345,678', '#,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 15));
-}
-
-// $parseInteger('1,234,567,890', '#,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 16));
-}
-
-// $parseInteger('1,234,567,890', '#,###,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 17));
-}
-
-// $parseInteger('1234:567,890', '#:###,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 18));
-}
-
-// $parseInteger('12345,67,890', '##,##,##0')
-TEST_F(function_parseIntegerTest, parseInteger_case_19) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 19));
-}
-
-// $parseInteger('', 'I')
-TEST_F(function_parseIntegerTest, parseInteger_case_20) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 20));
-}
-
-// $parseInteger('MCMLXXXIV', 'I')
-TEST_F(function_parseIntegerTest, parseInteger_case_21) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 21));
-}
-
-// $parseInteger('xcix', 'i')
-TEST_F(function_parseIntegerTest, parseInteger_case_22) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 22));
-}
-
-// $parseInteger('twelve', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_23) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 23));
-}
-
-// $parseInteger('twenty', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_24) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 24));
-}
-
-// $parseInteger('thirty-four', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_25) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 25));
-}
-
-// $parseInteger('NINETY-NINE', 'W')
-TEST_F(function_parseIntegerTest, parseInteger_case_26) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 26));
-}
-
-// $parseInteger('one hundred', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_27) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 27));
-}
-
-// $parseInteger('FIVE HUNDRED AND FIFTY-FIVE', 'W')
-TEST_F(function_parseIntegerTest, parseInteger_case_28) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 28));
-}
-
-// $parseInteger('Five Hundred and Fifty-Five', 'Ww')
-TEST_F(function_parseIntegerTest, parseInteger_case_29) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 29));
-}
-
-// $parseInteger('nine hundred and nineteen', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_30) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 30));
-}
-
-// $parseInteger('seven hundred and thirty', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_31) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 31));
-}
-
-// $parseInteger('one thousand', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_32) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 32));
-}
-
-// $parseInteger('three thousand, seven hundred and thirty', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_33) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 33));
-}
-
-// $parseInteger('three hundred and twenty-seven thousand, seven hundred and thirty', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_34) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 34));
-}
-
-// $parseInteger('four million, three hundred and twenty-seven thousand, seven hundred and thirty', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_35) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 35));
-}
-
-// $parseInteger('one trillion and one', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_36) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 36));
-}
-
-// $parseInteger('one trillion, two hundred and thirty-four billion, five hundred and sixty-seven million, eight hundred and ninety thousand, one hundred and twenty-three', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_37) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 37));
-}
-
-// $parseInteger('one thousand trillion', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_38) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 38));
-}
-
-// $parseInteger('ten billion trillion trillion trillion', 'w')
-TEST_F(function_parseIntegerTest, parseInteger_case_39) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 39));
-}
-
-// $parseInteger('twelfth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_40) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 40));
-}
-
-// $parseInteger('twentieth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_41) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 41));
-}
-
-// $parseInteger('thirty-fourth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_42) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 42));
-}
-
-// $parseInteger('NINETY-NINTH', 'W;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_43) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 43));
-}
-
-// $parseInteger('one hundredth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_44) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 44));
-}
-
-// $parseInteger('FIVE HUNDRED AND FIFTY-FIFTH', 'W;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_45) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 45));
-}
-
-// $parseInteger('nine hundred and nineteenth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_46) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 46));
-}
-
-// $parseInteger('seven hundred and thirtieth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_47) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 47));
-}
-
-// $parseInteger('Seven Hundred and Thirty-Third', 'Ww;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_48) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 48));
-}
-
-// $parseInteger('one thousandth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_49) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 49));
-}
-
-// $parseInteger('three thousand, seven hundred and thirty-first', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_50) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 50));
-}
-
-// $parseInteger('three hundred and twenty-seven thousand, seven hundred and thirteenth', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_51) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 51));
-}
-
-// $parseInteger('four million, three hundred and twenty-seven thousand, seven hundred and thirty-second', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_52) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 52));
-}
-
-// $parseInteger('one trillion and first', 'w;o')
-TEST_F(function_parseIntegerTest, parseInteger_case_53) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 53));
-}
-
-// $parseInteger('A', 'A')
-TEST_F(function_parseIntegerTest, parseInteger_case_54) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 54));
-}
-
-// $parseInteger('l', 'a')
-TEST_F(function_parseIntegerTest, parseInteger_case_55) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 55));
-}
-
-// $parseInteger('z', 'a')
-TEST_F(function_parseIntegerTest, parseInteger_case_56) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 56));
-}
-
-// $parseInteger('aa', 'a')
-TEST_F(function_parseIntegerTest, parseInteger_case_57) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 57));
-}
-
-// $parseInteger('KN', 'A')
-TEST_F(function_parseIntegerTest, parseInteger_case_58) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 58));
-}
-
-// $parseInteger('FZPH', 'A')
-TEST_F(function_parseIntegerTest, parseInteger_case_59) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 59));
-}
-
-// $parseInteger('50', '#')
-TEST_F(function_parseIntegerTest, parseInteger_case_60) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 60));
+// 
+TEST_F(function_parseIntegerTest, parseInteger) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json"));
 }
 
diff --git a/test/gen/function_powerTest.cpp b/test/gen/function_powerTest.cpp
index e73cae9..f3293bd 100644
--- a/test/gen/function_powerTest.cpp
+++ b/test/gen/function_powerTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_powerTest : public JsonataTest {
 };
 
-// $power(4, 2)
+// 
 TEST_F(function_powerTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case000.json"));
 }
 
-// $power(4, 0.5)
+// 
 TEST_F(function_powerTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case001.json"));
 }
 
-// $power(10, -2)
+// 
 TEST_F(function_powerTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case002.json"));
 }
 
-// $power(-2, 3)
+// 
 TEST_F(function_powerTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case003.json"));
 }
 
-// $power(nothing, 3)
+// 
 TEST_F(function_powerTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case004.json"));
 }
 
-// $power(-2, 1/3)
+// 
 TEST_F(function_powerTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case005.json"));
 }
 
-// $power(100, 1000)
+// 
 TEST_F(function_powerTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case006.json"));
 }
diff --git a/test/gen/function_replaceTest.cpp b/test/gen/function_replaceTest.cpp
index c4d80a3..7d724f2 100644
--- a/test/gen/function_replaceTest.cpp
+++ b/test/gen/function_replaceTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class function_replaceTest : public JsonataTest {
 };
 
-// $replace(\"Hello World\", \"World\", \"Everyone\")
+// 
 TEST_F(function_replaceTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case000.json"));
 }
 
-// $replace(\"the cat sat on the mat\", \"at\", \"it\")
+// 
 TEST_F(function_replaceTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case001.json"));
 }
 
-// $replace(\"the cat sat on the mat\", \"at\", \"it\", 0)
+// 
 TEST_F(function_replaceTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case002.json"));
 }
 
-// $replace(\"the cat sat on the mat\", \"at\", \"it\", 2)
+// 
 TEST_F(function_replaceTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case003.json"));
 }
 
-// $replace(nothing, \"at\", \"it\", 2)
+// 
 TEST_F(function_replaceTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case004.json"));
 }
 
-// $replace(\"hello\")
+// 
 TEST_F(function_replaceTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case005.json"));
 }
 
-// $replace(\"hello\", \"l\", \"1\", null)
+// 
 TEST_F(function_replaceTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case006.json"));
 }
 
-// $replace(\"hello\", \"l\", \"1\", -2)
+// 
 TEST_F(function_replaceTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case007.json"));
 }
 
-// $replace(\"hello\", 1)
+// 
 TEST_F(function_replaceTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case008.json"));
 }
 
-// $replace(\"hello\", \"\", \"bye\")
+// 
 TEST_F(function_replaceTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case009.json"));
 }
 
-// $replace(\"hello\", 2, 1)
+// 
 TEST_F(function_replaceTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case010.json"));
 }
 
-// $replace(123, 2, 1)
+// 
 TEST_F(function_replaceTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case011.json"));
 }
diff --git a/test/gen/function_reverseTest.cpp b/test/gen/function_reverseTest.cpp
index df52963..79a0d04 100644
--- a/test/gen/function_reverseTest.cpp
+++ b/test/gen/function_reverseTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_reverseTest : public JsonataTest {
 };
 
-// $reverse([1..5])
+// 
 TEST_F(function_reverseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case000.json"));
 }
 
-// [[$], [$reverse($)], [$]]
+// 
 TEST_F(function_reverseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case001.json"));
 }
 
-// $reverse(nothing)
+// 
 TEST_F(function_reverseTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case002.json"));
 }
 
-// $reverse([1])
+// 
 TEST_F(function_reverseTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case003.json"));
 }
diff --git a/test/gen/function_roundTest.cpp b/test/gen/function_roundTest.cpp
index b4e6a9b..d111de5 100644
--- a/test/gen/function_roundTest.cpp
+++ b/test/gen/function_roundTest.cpp
@@ -6,92 +6,92 @@ using namespace jsonata;
 class function_roundTest : public JsonataTest {
 };
 
-// $round(4)
+// 
 TEST_F(function_roundTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case000.json"));
 }
 
-// $round(2.3)
+// 
 TEST_F(function_roundTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case001.json"));
 }
 
-// $round(2.7)
+// 
 TEST_F(function_roundTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case002.json"));
 }
 
-// $round(2.5)
+// 
 TEST_F(function_roundTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case003.json"));
 }
 
-// $round(3.5)
+// 
 TEST_F(function_roundTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case004.json"));
 }
 
-// $round(-0.5)
+// 
 TEST_F(function_roundTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case005.json"));
 }
 
-// $round(-0.3)
+// 
 TEST_F(function_roundTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case006.json"));
 }
 
-// $round(0.5)
+// 
 TEST_F(function_roundTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case007.json"));
 }
 
-// $round(-7.5)
+// 
 TEST_F(function_roundTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case008.json"));
 }
 
-// $round(-8.5)
+// 
 TEST_F(function_roundTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case009.json"));
 }
 
-// $round(4.49, 1)
+// 
 TEST_F(function_roundTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case010.json"));
 }
 
-// $round(4.525, 2)
+// 
 TEST_F(function_roundTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case011.json"));
 }
 
-// $round(4.515, 2)
+// 
 TEST_F(function_roundTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case012.json"));
 }
 
-// $round(12345, -2)
+// 
 TEST_F(function_roundTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case013.json"));
 }
 
-// $round(12450, -2)
+// 
 TEST_F(function_roundTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case014.json"));
 }
 
-// $round(12350, -2)
+// 
 TEST_F(function_roundTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case015.json"));
 }
 
-// $round(6.022e-23, 24)
+// 
 TEST_F(function_roundTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case016.json"));
 }
 
-// $round(unknown)
+// 
 TEST_F(function_roundTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case017.json"));
 }
diff --git a/test/gen/function_shuffleTest.cpp b/test/gen/function_shuffleTest.cpp
index 6c2a749..d15e443 100644
--- a/test/gen/function_shuffleTest.cpp
+++ b/test/gen/function_shuffleTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_shuffleTest : public JsonataTest {
 };
 
-// $count($shuffle([1..10]))
+// 
 TEST_F(function_shuffleTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case000.json"));
 }
 
-// $sort($shuffle([1..10]))
+// 
 TEST_F(function_shuffleTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case001.json"));
 }
 
-// $shuffle(nothing)
+// 
 TEST_F(function_shuffleTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case002.json"));
 }
 
-// $shuffle([1])
+// 
 TEST_F(function_shuffleTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case003.json"));
 }
diff --git a/test/gen/function_siftTest.cpp b/test/gen/function_siftTest.cpp
index a16d43c..3324109 100644
--- a/test/gen/function_siftTest.cpp
+++ b/test/gen/function_siftTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_siftTest : public JsonataTest {
 };
 
-// $sift(λ($v){$v.**.Postcode})
+// 
 TEST_F(function_siftTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case000.json"));
 }
 
-// **[*].$sift(λ($v){$v.Postcode})
+// 
 TEST_F(function_siftTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case001.json"));
 }
 
-// $sift(λ($v, $k){$k ~> /^A/})
+// 
 TEST_F(function_siftTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case002.json"));
 }
 
-// $sift({'a': 1, 'b': 0}, $boolean)
+// 
 TEST_F(function_siftTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case003.json"));
 }
 
-// $sift({'a': 'hello', 'b': 'world', 'hello': 'again'}, λ($v,$k,$o){$lookup($o, $v)})
+// 
 TEST_F(function_siftTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case004.json"));
 }
diff --git a/test/gen/function_signaturesTest.cpp b/test/gen/function_signaturesTest.cpp
index 95147be..1ed1d00 100644
--- a/test/gen/function_signaturesTest.cpp
+++ b/test/gen/function_signaturesTest.cpp
@@ -6,177 +6,177 @@ using namespace jsonata;
 class function_signaturesTest : public JsonataTest {
 };
 
-// λ($arg)<b:b>{$not($arg)}(true)
+// 
 TEST_F(function_signaturesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case000.json"));
 }
 
-// λ($arg)<b:b>{$not($arg)}(foo)
+// 
 TEST_F(function_signaturesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case001.json"));
 }
 
-// λ($arg)<x:b>{$not($arg)}(null)
+// 
 TEST_F(function_signaturesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case002.json"));
 }
 
-// function($x,$y)<n-n:n>{$x+$y}(2, 6)
+// 
 TEST_F(function_signaturesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case003.json"));
 }
 
-// [1..5].function($x,$y)<n-n:n>{$x+$y}(6)
+// 
 TEST_F(function_signaturesTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case004.json"));
 }
 
-// [1..5].function($x,$y)<n-n:n>{$x+$y}(2, 6)
+// 
 TEST_F(function_signaturesTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case005.json"));
 }
 
-// Age.function($x,$y)<n-n:n>{$x+$y}(6)
+// 
 TEST_F(function_signaturesTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case006.json"));
 }
 
-// λ($str)<s->{$uppercase($str)}(\"hello\")
+// 
 TEST_F(function_signaturesTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case007.json"));
 }
 
-// Account.Order.Product.Description.Colour.λ($str)<s->{$uppercase($str)}()
+// 
 TEST_F(function_signaturesTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case008.json"));
 }
 
-// λ($str, $prefix)<s-s>{$prefix & $str}(\"World\", \"Hello \")
+// 
 TEST_F(function_signaturesTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case009.json"));
 }
 
-// FirstName.λ($str, $prefix)<s-s>{$prefix & $str}(\"Hello \")
+// 
 TEST_F(function_signaturesTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case010.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}(\"a\")
+// 
 TEST_F(function_signaturesTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case011.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([\"a\"])
+// 
 TEST_F(function_signaturesTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case012.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}(\"a\", \"-\")
+// 
 TEST_F(function_signaturesTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case013.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([\"a\"], \"-\")
+// 
 TEST_F(function_signaturesTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case014.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([\"a\", \"b\"], \"-\")
+// 
 TEST_F(function_signaturesTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case015.json"));
 }
 
-// λ($arr, $sep)<as?:s>{$join($arr, $sep)}([\"a\", \"b\"], \"-\")
+// 
 TEST_F(function_signaturesTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case016.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([], \"-\")
+// 
 TEST_F(function_signaturesTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case017.json"));
 }
 
-// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}(foo, \"-\")
+// 
 TEST_F(function_signaturesTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case018.json"));
 }
 
-// λ($obj)<o>{$obj}({\"hello\": \"world\"})
+// 
 TEST_F(function_signaturesTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case019.json"));
 }
 
-// λ($arr)<a<a<n>>>{$arr}([[1]])
+// 
 TEST_F(function_signaturesTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case020.json"));
 }
 
-// λ($num)<(ns)-:n>{$number($num)}(5)
+// 
 TEST_F(function_signaturesTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case021.json"));
 }
 
-// λ($num)<(ns)-:n>{$number($num)}(\"5\")
+// 
 TEST_F(function_signaturesTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case022.json"));
 }
 
-// [1..5].λ($num)<(ns)-:n>{$number($num)}()
+// 
 TEST_F(function_signaturesTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case023.json"));
 }
 
-// ($twice := function($f)<f:f>{function($x)<n:n>{$f($f($x))}};$add2 := function($x)<n:n>{$x+2};$add4 := $twice($add2);$add4(5))
+// 
 TEST_F(function_signaturesTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case024.json"));
 }
 
-// ($twice := function($f)<f<n:n>:f<n:n>>{function($x)<n:n>{$f($f($x))}};$add2 := function($x)<n:n>{$x+2};$add4 := $twice($add2);$add4(5))
+// 
 TEST_F(function_signaturesTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case025.json"));
 }
 
-// λ($arg)<n<n>>{$arg}(5)
+// 
 TEST_F(function_signaturesTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case026.json"));
 }
 
-// λ($arg1, $arg2)<nn:a>{[$arg1, $arg2]}(1,\"2\")
+// 
 TEST_F(function_signaturesTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case027.json"));
 }
 
-// λ($arg1, $arg2)<nn:a>{[$arg1, $arg2]}(1,3,\"2\")
+// 
 TEST_F(function_signaturesTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case028.json"));
 }
 
-// λ($arg1, $arg2)<nn+:a>{[$arg1, $arg2]}(1,3, 2,\"g\")
+// 
 TEST_F(function_signaturesTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case029.json"));
 }
 
-// λ($arr)<a<n>>{$arr}([\"3\"]) 
+// 
 TEST_F(function_signaturesTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case030.json"));
 }
 
-// λ($arr)<a<n>>{$arr}([1, 2, \"3\"]) 
+// 
 TEST_F(function_signaturesTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case031.json"));
 }
 
-// λ($arr)<a<n>>{$arr}(\"f\")
+// 
 TEST_F(function_signaturesTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case032.json"));
 }
 
-// ($fun := λ($arr)<a<n>>{$arr};$fun(\"f\"))
+// 
 TEST_F(function_signaturesTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case033.json"));
 }
 
-// λ($arr)<(sa<n>)>>{$arr}([[1]])
+// 
 TEST_F(function_signaturesTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case034.json"));
 }
diff --git a/test/gen/function_sortTest.cpp b/test/gen/function_sortTest.cpp
index dcfb1d5..248944c 100644
--- a/test/gen/function_sortTest.cpp
+++ b/test/gen/function_sortTest.cpp
@@ -6,57 +6,57 @@ using namespace jsonata;
 class function_sortTest : public JsonataTest {
 };
 
-// $sort(nothing)
+// 
 TEST_F(function_sortTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case000.json"));
 }
 
-// $sort(1)
+// 
 TEST_F(function_sortTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case001.json"));
 }
 
-// $sort([1,3,2])
+// 
 TEST_F(function_sortTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case002.json"));
 }
 
-// $sort([1,3,22,11])
+// 
 TEST_F(function_sortTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case003.json"));
 }
 
-// [[$], [$sort($)], [$]]
+// 
 TEST_F(function_sortTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case004.json"));
 }
 
-// $sort(Account.Order.Product.Price)
+// 
 TEST_F(function_sortTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case005.json"));
 }
 
-// $sort(Account.Order.Product.\"Product Name\")
+// 
 TEST_F(function_sortTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case006.json"));
 }
 
-// $sort(Account.Order.Product)
+// 
 TEST_F(function_sortTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case007.json"));
 }
 
-// $sort(Account.Order.Product, function($a, $b) { $a.(Price * Quantity) > $b.(Price * Quantity) }).(Price & \" x \" & Quantity)
+// 
 TEST_F(function_sortTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case008.json"));
 }
 
-// $sort(Account.Order.Product, function($a, $b) { $a.Price > $b.Price }).SKU
+// 
 TEST_F(function_sortTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case009.json"));
 }
 
-//                  (Account.Order.Product                   ~> $sort(λ($a,$b){$a.Quantity < $b.Quantity})                   ~> $sort(λ($a,$b){$a.Price > $b.Price})                 ).SKU             
+// 
 TEST_F(function_sortTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case010.json"));
 }
diff --git a/test/gen/function_splitTest.cpp b/test/gen/function_splitTest.cpp
index e5279f2..358a699 100644
--- a/test/gen/function_splitTest.cpp
+++ b/test/gen/function_splitTest.cpp
@@ -6,97 +6,97 @@ using namespace jsonata;
 class function_splitTest : public JsonataTest {
 };
 
-// $split(\"Hello World\", \" \")
+// 
 TEST_F(function_splitTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case000.json"));
 }
 
-// $split(\"Hello\", \" \")
+// 
 TEST_F(function_splitTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case001.json"));
 }
 
-// $split(\"Hello  World\", \" \")
+// 
 TEST_F(function_splitTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case002.json"));
 }
 
-// $split(\"Hello\", \"\")
+// 
 TEST_F(function_splitTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case003.json"));
 }
 
-// $sum($split(\"12345\", \"\").$number($))
+// 
 TEST_F(function_splitTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case004.json"));
 }
 
-// $split(\"a, b, c, d\", \", \")
+// 
 TEST_F(function_splitTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case005.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", 2)
+// 
 TEST_F(function_splitTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case006.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", 2.5)
+// 
 TEST_F(function_splitTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case007.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", 10)
+// 
 TEST_F(function_splitTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case008.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", 0)
+// 
 TEST_F(function_splitTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case009.json"));
 }
 
-// $split(nothing, \" \")
+// 
 TEST_F(function_splitTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case010.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", -3)
+// 
 TEST_F(function_splitTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case011.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", null)
+// 
 TEST_F(function_splitTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case012.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", -5)
+// 
 TEST_F(function_splitTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case013.json"));
 }
 
-// $split(\"a, b, c, d\", \", \", \"2\")
+// 
 TEST_F(function_splitTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case014.json"));
 }
 
-// $split(\"a, b, c, d\", true)
+// 
 TEST_F(function_splitTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case015.json"));
 }
 
-// $split(12345, 3)
+// 
 TEST_F(function_splitTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case016.json"));
 }
 
-// $split(12345)
+// 
 TEST_F(function_splitTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case017.json"));
 }
 
-// $split('12💩345💩6', '💩')
+// 
 TEST_F(function_splitTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case018.json"));
 }
diff --git a/test/gen/function_spreadTest.cpp b/test/gen/function_spreadTest.cpp
index 063ea98..2b627a1 100644
--- a/test/gen/function_spreadTest.cpp
+++ b/test/gen/function_spreadTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_spreadTest : public JsonataTest {
 };
 
-// $spread(\"Hello World\")
+// 
 TEST_F(function_spreadTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case000.json"));
 }
 
-// $spread((Account.Order.Product.Description))
+// 
 TEST_F(function_spreadTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case001.json"));
 }
 
-// $spread(blah)
+// 
 TEST_F(function_spreadTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case002.json"));
 }
 
-// $string($spread(function($x){$x*$x}))
+// 
 TEST_F(function_spreadTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case003.json"));
 }
diff --git a/test/gen/function_sqrtTest.cpp b/test/gen/function_sqrtTest.cpp
index d926385..69e66f6 100644
--- a/test/gen/function_sqrtTest.cpp
+++ b/test/gen/function_sqrtTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_sqrtTest : public JsonataTest {
 };
 
-// $sqrt(4)
+// 
 TEST_F(function_sqrtTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case000.json"));
 }
 
-// $sqrt(2)
+// 
 TEST_F(function_sqrtTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case001.json"));
 }
 
-// $sqrt(nothing)
+// 
 TEST_F(function_sqrtTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case002.json"));
 }
 
-// $sqrt(-2)
+// 
 TEST_F(function_sqrtTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case003.json"));
 }
diff --git a/test/gen/function_stringTest.cpp b/test/gen/function_stringTest.cpp
index 5289f0f..21a658b 100644
--- a/test/gen/function_stringTest.cpp
+++ b/test/gen/function_stringTest.cpp
@@ -6,152 +6,152 @@ using namespace jsonata;
 class function_stringTest : public JsonataTest {
 };
 
-// $string(5)
+// 
 TEST_F(function_stringTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case000.json"));
 }
 
-// $string(22/7)
+// 
 TEST_F(function_stringTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case001.json"));
 }
 
-// $string(1e100)
+// 
 TEST_F(function_stringTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case002.json"));
 }
 
-// $string(1e-100)
+// 
 TEST_F(function_stringTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case003.json"));
 }
 
-// $string(1e-6)
+// 
 TEST_F(function_stringTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case004.json"));
 }
 
-// $string(1e-7)
+// 
 TEST_F(function_stringTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case005.json"));
 }
 
-// $string(1e20)
+// 
 TEST_F(function_stringTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case006.json"));
 }
 
-// $string(1e21)
+// 
 TEST_F(function_stringTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case007.json"));
 }
 
-// Account.Order.$string($sum(Product.(Price* Quantity)))
+// 
 TEST_F(function_stringTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case008.json"));
 }
 
-// $string(true)
+// 
 TEST_F(function_stringTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case009.json"));
 }
 
-// $string(false)
+// 
 TEST_F(function_stringTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case010.json"));
 }
 
-// $string(null)
+// 
 TEST_F(function_stringTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case011.json"));
 }
 
-// $string(blah)
+// 
 TEST_F(function_stringTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case012.json"));
 }
 
-// $string($string)
+// 
 TEST_F(function_stringTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case013.json"));
 }
 
-// $string(function(){true})
+// 
 TEST_F(function_stringTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case014.json"));
 }
 
-// $string(function(){1})
+// 
 TEST_F(function_stringTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case015.json"));
 }
 
-// $string({\"string\": \"hello\"})
+// 
 TEST_F(function_stringTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case016.json"));
 }
 
-// $string([\"string\", 5])
+// 
 TEST_F(function_stringTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case017.json"));
 }
 
-// $string({  \"string\": \"hello\",  \"number\": 78.8 / 2,  \"null\":null,  \"boolean\": false,  \"function\": $sum,  \"lambda\": function(){true},  \"object\": {    \"str\": \"another\",    \"lambda2\": function($n){$n}  },  \"array\": []})
+// 
 TEST_F(function_stringTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case018.json"));
 }
 
-// $string(1/0)
+// 
 TEST_F(function_stringTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case019.json"));
 }
 
-// $string({\"inf\": 1/0})
+// 
 TEST_F(function_stringTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case020.json"));
 }
 
-// $string(2,3)
+// 
 TEST_F(function_stringTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case021.json"));
 }
 
-// $string()
+// 
 TEST_F(function_stringTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case022.json"));
 }
 
-// $string({\"string\": \"hello\"}, false)
+// 
 TEST_F(function_stringTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case023.json"));
 }
 
-// $string({\"string\": \"hello\"}, true)
+// 
 TEST_F(function_stringTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case024.json"));
 }
 
-// $string([\"string\", 5], false)
+// 
 TEST_F(function_stringTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case025.json"));
 }
 
-// $string([\"string\", 5], true)
+// 
 TEST_F(function_stringTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case026.json"));
 }
 
-// $string({  \"string\": \"hello\",  \"number\": 78.8 / 2,  \"null\":null,  \"boolean\": false,  \"function\": $sum,  \"lambda\": function(){true},  \"object\": {    \"str\": \"another\",    \"lambda2\": function($n){$n}  },  \"array\": []}, false)
+// 
 TEST_F(function_stringTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case027.json"));
 }
 
-// $string({  \"string\": \"hello\",  \"number\": 78.8 / 2,  \"null\":null,  \"boolean\": false,  \"function\": $sum,  \"lambda\": function(){true},  \"object\": {    \"str\": \"another\",    \"lambda2\": function($n){$n}  },  \"array\": []}, true)
+// 
 TEST_F(function_stringTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case028.json"));
 }
 
-// $string()
+// 
 TEST_F(function_stringTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case029.json"));
 }
diff --git a/test/gen/function_substringAfterTest.cpp b/test/gen/function_substringAfterTest.cpp
index 31d9c20..7944dc0 100644
--- a/test/gen/function_substringAfterTest.cpp
+++ b/test/gen/function_substringAfterTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_substringAfterTest : public JsonataTest {
 };
 
-// $substringAfter(\"Hello World\", \" \")
+// 
 TEST_F(function_substringAfterTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case000.json"));
 }
 
-// $substringAfter(\"Hello World\", \"l\")
+// 
 TEST_F(function_substringAfterTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case001.json"));
 }
 
-// $substringAfter(\"Hello World\", \"f\")
+// 
 TEST_F(function_substringAfterTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case002.json"));
 }
 
-// $substringAfter(\"Hello World\", \"ld\")
+// 
 TEST_F(function_substringAfterTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case003.json"));
 }
 
-// $substringAfter(blah, \"ld\")
+// 
 TEST_F(function_substringAfterTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case004.json"));
 }
diff --git a/test/gen/function_substringBeforeTest.cpp b/test/gen/function_substringBeforeTest.cpp
index 9074e5d..e4034be 100644
--- a/test/gen/function_substringBeforeTest.cpp
+++ b/test/gen/function_substringBeforeTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_substringBeforeTest : public JsonataTest {
 };
 
-// $substringBefore(\"Hello World\", \" \")
+// 
 TEST_F(function_substringBeforeTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case000.json"));
 }
 
-// $substringBefore(\"Hello World\", \"l\")
+// 
 TEST_F(function_substringBeforeTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case001.json"));
 }
 
-// $substringBefore(\"Hello World\", \"f\")
+// 
 TEST_F(function_substringBeforeTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case002.json"));
 }
 
-// $substringBefore(\"Hello World\", \"He\")
+// 
 TEST_F(function_substringBeforeTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case003.json"));
 }
 
-// $substringBefore(blah, \"He\")
+// 
 TEST_F(function_substringBeforeTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case004.json"));
 }
diff --git a/test/gen/function_substringTest.cpp b/test/gen/function_substringTest.cpp
index 1b090d8..7746f7f 100644
--- a/test/gen/function_substringTest.cpp
+++ b/test/gen/function_substringTest.cpp
@@ -6,97 +6,97 @@ using namespace jsonata;
 class function_substringTest : public JsonataTest {
 };
 
-// $substring(\"hello world\", 0, 5)
+// 
 TEST_F(function_substringTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case000.json"));
 }
 
-// $substring(\"hello world\", -5, 5)
+// 
 TEST_F(function_substringTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case001.json"));
 }
 
-// $substring(\"hello world\", 6)
+// 
 TEST_F(function_substringTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case002.json"));
 }
 
-// $substring(blah, 6)
+// 
 TEST_F(function_substringTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case003.json"));
 }
 
-// $substring('𝄞💩', 0, 2)
+// 
 TEST_F(function_substringTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case004.json"));
 }
 
-// $substring('𝄞💩', 0, 1)
+// 
 TEST_F(function_substringTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case005.json"));
 }
 
-// $substring('𝄞💩', 1, 1)
+// 
 TEST_F(function_substringTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case006.json"));
 }
 
-// $substring(\"hello world\", -5)
+// 
 TEST_F(function_substringTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case007.json"));
 }
 
-// $substring(\"hello world\", -5, 5)
+// 
 TEST_F(function_substringTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case008.json"));
 }
 
-// $substring(\"hello world\", -5, 4)
+// 
 TEST_F(function_substringTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case009.json"));
 }
 
-// $substring(\"hello world\", -5, 1)
+// 
 TEST_F(function_substringTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case010.json"));
 }
 
-// $substring(\"hello world\", -5, 0)
+// 
 TEST_F(function_substringTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case011.json"));
 }
 
-// $substring(\"hello world\", -5, -1)
+// 
 TEST_F(function_substringTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case012.json"));
 }
 
-// $substring(\"hello world\", 0, -6)
+// 
 TEST_F(function_substringTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case013.json"));
 }
 
-// $substring(\"hello world\", -100, 3)
+// 
 TEST_F(function_substringTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case014.json"));
 }
 
-// $substring(\"😂😁😀\", -2, 1)
+// 
 TEST_F(function_substringTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case015.json"));
 }
 
-// $substring(\"😂😁😀\", -3, 1)
+// 
 TEST_F(function_substringTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case016.json"));
 }
 
-// $substring(\"😂😁😀\", -4, 1)
+// 
 TEST_F(function_substringTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case017.json"));
 }
 
-// $substring(\"😂😁😀\", -5, 1)
+// 
 TEST_F(function_substringTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case018.json"));
 }
diff --git a/test/gen/function_sumTest.cpp b/test/gen/function_sumTest.cpp
index 16ff875..7ebcd38 100644
--- a/test/gen/function_sumTest.cpp
+++ b/test/gen/function_sumTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_sumTest : public JsonataTest {
 };
 
-// $sum(Account.Order.Product.(Price * Quantity))
+// 
 TEST_F(function_sumTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case000.json"));
 }
 
-// Account.Order.$sum(Product.(Price * Quantity))
+// 
 TEST_F(function_sumTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case001.json"));
 }
 
-// Account.Order.(OrderID & \": \" & $sum(Product.(Price*Quantity)))
+// 
 TEST_F(function_sumTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case002.json"));
 }
 
-// $sum()
+// 
 TEST_F(function_sumTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case003.json"));
 }
 
-// $sum(1)
+// 
 TEST_F(function_sumTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case004.json"));
 }
 
-// $sum(Account.Order)
+// 
 TEST_F(function_sumTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case005.json"));
 }
 
-// $sum(undefined)
+// 
 TEST_F(function_sumTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case006.json"));
 }
diff --git a/test/gen/function_tomillisTest.cpp b/test/gen/function_tomillisTest.cpp
index bade2d7..d7276ec 100644
--- a/test/gen/function_tomillisTest.cpp
+++ b/test/gen/function_tomillisTest.cpp
@@ -6,298 +6,73 @@ using namespace jsonata;
 class function_tomillisTest : public JsonataTest {
 };
 
-// $toMillis(\"1970-01-01T00:00:00.001Z\")
+// 
 TEST_F(function_tomillisTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case001.json"));
 }
 
-// $toMillis(\"2018-02-01T09:42:13.123+0000\")
+// 
 TEST_F(function_tomillisTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case002.json"));
 }
 
-// $toMillis(\"2017-10-30\")
+// 
 TEST_F(function_tomillisTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case003.json"));
 }
 
-// $toMillis(\"2017-10-30T15:28:34Z\")
+// 
 TEST_F(function_tomillisTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case004.json"));
 }
 
-// $toMillis(\"2018\")
+// 
 TEST_F(function_tomillisTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case005.json"));
 }
 
-// $toMillis(foo)
+// 
 TEST_F(function_tomillisTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case006.json"));
 }
 
-// $toMillis(\"foo\")
+// 
 TEST_F(function_tomillisTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case007.json"));
 }
 
-// $toMillis(\"01-02-2018\")
+// 
 TEST_F(function_tomillisTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case008.json"));
 }
 
-// $toMillis(\"2018-02-03 11:15:33\")
+// 
 TEST_F(function_tomillisTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case009.json"));
 }
 
-// $toMillis(\"201802\", \"[Y0001][M01]\")
+// 
 TEST_F(function_tomillisTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case010.json"));
 }
 
-// $toMillis(\"201802\", \"[Y,*-4][M01]\")
+// 
 TEST_F(function_tomillisTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case011.json"));
 }
 
-// $toMillis(\"20180205\", \"[Y0001][M01][D01]\")
+// 
 TEST_F(function_tomillisTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case012.json"));
 }
 
-// $toMillis('2024-01-01T12:38:49Z') = $toMillis('20240101123849', '[Y0000][M00][D00][H00][m00][s00]')
+// 
 TEST_F(function_tomillisTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case013.json"));
 }
 
-// $toMillis(undefined, 'pic')
-TEST_F(function_tomillisTest, parseDateTime_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 0));
-}
-
-// $toMillis('Hello', 'Hello')
-TEST_F(function_tomillisTest, parseDateTime_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 1));
-}
-
-// $toMillis('2018', '[Y1]')
-TEST_F(function_tomillisTest, parseDateTime_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 2));
-}
-
-// $toMillis('2018-03-27', '[Y1]-[M01]-[D01]')
-TEST_F(function_tomillisTest, parseDateTime_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 3));
-}
-
-// $toMillis('2018-03-27T14:03:00.123Z', '[Y0001]-[M01]-[D01]T[H01]:[m01]:[s01].[f001]Z')
-TEST_F(function_tomillisTest, parseDateTime_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 4));
-}
-
-// $toMillis('27th 3 1976', '[D1o] [M#1] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 5));
-}
-
-// $toMillis('21st 12 1881', '[D1o] [M01] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 6));
-}
-
-// $toMillis('2nd 12 2012', '[D1o] [M01] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 7));
-}
-
-// $toMillis('MCMLXXXIV', '[YI]')
-TEST_F(function_tomillisTest, parseDateTime_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 8));
-}
-
-// $toMillis('27 03 MMXVIII', '[D1] [M01] [YI]')
-TEST_F(function_tomillisTest, parseDateTime_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 9));
-}
-
-// $toMillis('27 iii MMXVIII', '[D1] [Mi] [YI]')
-TEST_F(function_tomillisTest, parseDateTime_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 10));
-}
-
-// $toMillis('w C mmxviii', '[Da] [MA] [Yi]')
-TEST_F(function_tomillisTest, parseDateTime_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 11));
-}
-
-// $toMillis('ae C mmxviii', '[Da] [MA] [Yi]')
-TEST_F(function_tomillisTest, parseDateTime_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 12));
-}
-
-// $toMillis('27th April 2008', '[D1o] [MNn] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 13));
-}
-
-// $toMillis('21 August 2017', '[D1] [MNn] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 14));
-}
-
-// $toMillis('2 Feb 2012', '[D1] [MNn,3-3] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 15));
-}
-
-// $toMillis('one thousand, nine hundred and eighty-four', '[Yw]')
-TEST_F(function_tomillisTest, parseDateTime_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 16));
-}
-
-// $toMillis('nineteen hundred and eighty-four', '[Yw]')
-TEST_F(function_tomillisTest, parseDateTime_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 17));
-}
-
-// $toMillis('twenty-seven April 2008', '[Dw] [MNn] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 18));
-}
-
-// $toMillis('twenty-seventh April 2008', '[Dw] [MNn] [Y0001]')
-TEST_F(function_tomillisTest, parseDateTime_case_19) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 19));
-}
-
-// $toMillis('twenty-first August two thousand and seventeen', '[Dw] [MNn] [Yw]')
-TEST_F(function_tomillisTest, parseDateTime_case_20) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 20));
-}
-
-// $toMillis('TWENTY-SECOND August two thousand and seventeen', '[DW] [MNn] [Yw]')
-TEST_F(function_tomillisTest, parseDateTime_case_21) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 21));
-}
-
-// $toMillis('Twentieth of August, two thousand and seventeen', '[DW] of [MNn], [Yw]')
-TEST_F(function_tomillisTest, parseDateTime_case_22) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 22));
-}
-
-// $toMillis('4/4/2018 12:06 am', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
-TEST_F(function_tomillisTest, parseDateTime_case_23) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 23));
-}
-
-// $toMillis('4/4/2018 06:30 am', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
-TEST_F(function_tomillisTest, parseDateTime_case_24) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 24));
-}
-
-// $toMillis('4/4/2018 12:06 pm', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
-TEST_F(function_tomillisTest, parseDateTime_case_25) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 25));
-}
-
-// $toMillis('4/4/2018 11:30 pm', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
-TEST_F(function_tomillisTest, parseDateTime_case_26) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 26));
-}
-
-// $toMillis('2018-094', '[Y0001]-[d001]')
-TEST_F(function_tomillisTest, parseDateTime_case_27) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 27));
-}
-
-// $toMillis('13:45', '[H]:[m]') ~> $fromMillis() ~> $substringBefore('T') = $substringBefore($now(), 'T')
-TEST_F(function_tomillisTest, parseDateTime_case_28) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 28));
-}
-
-// $toMillis('13:45', '[H]:[m]') ~> $fromMillis() ~> $substringAfter('T')
-TEST_F(function_tomillisTest, parseDateTime_case_29) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 29));
-}
-
-// $toMillis('Wednesday, 14th November 2018', '[FNn], [D1o] [MNn] [Y]') ~> $fromMillis()
-TEST_F(function_tomillisTest, parseDateTime_case_30) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 30));
-}
-
-// $toMillis('Mon, Twelfth November 2018', '[FNn,*-3], [DWwo] [MNn] [Y]') ~> $fromMillis()
-TEST_F(function_tomillisTest, parseDateTime_case_31) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 31));
-}
-
-// $toMillis('2018--180', '[Y]--[d]') ~> $fromMillis()
-TEST_F(function_tomillisTest, parseDateTime_case_32) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 32));
-}
-
-// $toMillis('three hundred and sixty-fifth day of 2018', '[dwo] day of [Y]') ~> $fromMillis()
-TEST_F(function_tomillisTest, parseDateTime_case_33) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 33));
-}
-
-// $toMillis('irrelevent string', '[Y]-[M]-[D]')
-TEST_F(function_tomillisTest, parseDateTime_case_34) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 34));
-}
-
-// $toMillis('2018-05-22', '[Y]-[M]-[q]')
-TEST_F(function_tomillisTest, parseDateTime_case_35) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 35));
-}
-
-// $toMillis('2018-05-22', '[YN]-[M]-[D]')
-TEST_F(function_tomillisTest, parseDateTime_case_36) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 36));
-}
-
-// $toMillis('2018-22', '[Y]-[D]')
-TEST_F(function_tomillisTest, parseDateTime_case_37) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 37));
-}
-
-// $toMillis('5-22 23:59', '[M]-[D] [m]:[s]')
-TEST_F(function_tomillisTest, parseDateTime_case_38) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 38));
-}
-
-// $toMillis('2018-3-2-5', '[X]-[x]-[w]-[F1]')
-TEST_F(function_tomillisTest, parseDateTime_case_39) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 39));
-}
-
-// $toMillis('2018-32-5', '[X]-[W]-[F1]')
-TEST_F(function_tomillisTest, parseDateTime_case_40) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 40));
-}
-
-// $toMillis('2020-09-09 08:00:00 +02:00', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [Z]') ~> $fromMillis() 
-TEST_F(function_tomillisTest, parseDateTime_case_41) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 41));
-}
-
-// $toMillis('2020-09-09 08:00:00 GMT-05:00', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [z]') ~> $fromMillis() 
-TEST_F(function_tomillisTest, parseDateTime_case_42) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 42));
-}
-
-// $toMillis('2020-09-09 12:00:00 +05:30', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [Z]') ~> $fromMillis() 
-TEST_F(function_tomillisTest, parseDateTime_case_43) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 43));
-}
-
-// $toMillis('2020-09-09 12:00:00 GMT-5', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [z01]') ~> $fromMillis() 
-TEST_F(function_tomillisTest, parseDateTime_case_44) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 44));
-}
-
-// $toMillis('2020-09-09 12:00:00 +0530', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [Z0001]') ~> $fromMillis() 
-TEST_F(function_tomillisTest, parseDateTime_case_45) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 45));
+// 
+TEST_F(function_tomillisTest, parseDateTime) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json"));
 }
 
diff --git a/test/gen/function_trimTest.cpp b/test/gen/function_trimTest.cpp
index 5f395c1..fe155a3 100644
--- a/test/gen/function_trimTest.cpp
+++ b/test/gen/function_trimTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_trimTest : public JsonataTest {
 };
 
-// $trim(\"Hello World\")
+// 
 TEST_F(function_trimTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-trim/case000.json"));
 }
 
-// $trim(\"   Hello     \t World  \t \")
+// 
 TEST_F(function_trimTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-trim/case001.json"));
 }
 
-// $trim()
+// 
 TEST_F(function_trimTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-trim/case002.json"));
 }
diff --git a/test/gen/function_typeOfTest.cpp b/test/gen/function_typeOfTest.cpp
index 7eb6e2e..948be23 100644
--- a/test/gen/function_typeOfTest.cpp
+++ b/test/gen/function_typeOfTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class function_typeOfTest : public JsonataTest {
 };
 
-// ($var:= undefined; $type($var))
+// 
 TEST_F(function_typeOfTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case001.json"));
 }
 
-// ($var:= null; $type($var))
+// 
 TEST_F(function_typeOfTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case002.json"));
 }
 
-// ($var:= 123; $type($var))
+// 
 TEST_F(function_typeOfTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case003.json"));
 }
 
-// ($var:= '123'; $type($var))
+// 
 TEST_F(function_typeOfTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case004.json"));
 }
 
-// ($var:= true; $type($var))
+// 
 TEST_F(function_typeOfTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case005.json"));
 }
 
-// ($var:= 'true'; $type($var))
+// 
 TEST_F(function_typeOfTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case006.json"));
 }
 
-// ($var:= []; $type($var))
+// 
 TEST_F(function_typeOfTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case007.json"));
 }
 
-// ($var:= ['a']; $type($var))
+// 
 TEST_F(function_typeOfTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case008.json"));
 }
 
-// ($var:= ['a','b']; $type($var))
+// 
 TEST_F(function_typeOfTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case009.json"));
 }
 
-// ($var:= function(){true}; $type($var))
+// 
 TEST_F(function_typeOfTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case010.json"));
 }
 
-// ($var:= (λ($v, $i, $a) {$v.price = $max($a.price)}); $type($var))
+// 
 TEST_F(function_typeOfTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case011.json"));
 }
 
-// ($var:= {}; $type($var))
+// 
 TEST_F(function_typeOfTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case012.json"));
 }
 
-// ($var:= {\"foo\":\"bar\"}; $type($var))
+// 
 TEST_F(function_typeOfTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case013.json"));
 }
diff --git a/test/gen/function_uppercaseTest.cpp b/test/gen/function_uppercaseTest.cpp
index 32887c9..51a8d2c 100644
--- a/test/gen/function_uppercaseTest.cpp
+++ b/test/gen/function_uppercaseTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_uppercaseTest : public JsonataTest {
 };
 
-// $uppercase(\"Hello World\")
+// 
 TEST_F(function_uppercaseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-uppercase/case000.json"));
 }
 
-// $uppercase(blah)
+// 
 TEST_F(function_uppercaseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-uppercase/case001.json"));
 }
diff --git a/test/gen/function_zipTest.cpp b/test/gen/function_zipTest.cpp
index 2ed15c4..519e76a 100644
--- a/test/gen/function_zipTest.cpp
+++ b/test/gen/function_zipTest.cpp
@@ -6,32 +6,32 @@ using namespace jsonata;
 class function_zipTest : public JsonataTest {
 };
 
-// $zip([1,2,3],[4,5,6])
+// 
 TEST_F(function_zipTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case000.json"));
 }
 
-// $zip([1,2,3],[4,5,6],[7,8,9])
+// 
 TEST_F(function_zipTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case001.json"));
 }
 
-// $zip([1,2,3],[4,5],[7,8,9])
+// 
 TEST_F(function_zipTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case002.json"));
 }
 
-// $zip([1,2,3])
+// 
 TEST_F(function_zipTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case003.json"));
 }
 
-// $zip(1,2,3)
+// 
 TEST_F(function_zipTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case004.json"));
 }
 
-// $zip([1,2,3], [4,5,6], nothing)
+// 
 TEST_F(function_zipTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case005.json"));
 }
diff --git a/test/gen/higher_order_functionsTest.cpp b/test/gen/higher_order_functionsTest.cpp
index bad559e..0457a2c 100644
--- a/test/gen/higher_order_functionsTest.cpp
+++ b/test/gen/higher_order_functionsTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class higher_order_functionsTest : public JsonataTest {
 };
 
-// ($twice:=function($f){function($x){$f($f($x))}}; $add3:=function($y){$y+3}; $add6:=$twice($add3); $add6(7))
+// 
 TEST_F(higher_order_functionsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/higher-order-functions/case000.json"));
 }
 
-// λ($f) { λ($x) { $x($x) }( λ($g) { $f( (λ($a) {$g($g)($a)}))})}(λ($f) { λ($n) { $n < 2 ? 1 : $n * $f($n - 1) } })(6)
+// 
 TEST_F(higher_order_functionsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/higher-order-functions/case001.json"));
 }
 
-// λ($f) { λ($x) { $x($x) }( λ($g) { $f( (λ($a) {$g($g)($a)}))})}(λ($f) { λ($n) { $n <= 1 ? $n : $f($n-1) + $f($n-2) } })(6) 
+// 
 TEST_F(higher_order_functionsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/higher-order-functions/case002.json"));
 }
diff --git a/test/gen/hof_filterTest.cpp b/test/gen/hof_filterTest.cpp
index 7b213f8..cad9e43 100644
--- a/test/gen/hof_filterTest.cpp
+++ b/test/gen/hof_filterTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class hof_filterTest : public JsonataTest {
 };
 
-// (library.books~>$filter(λ($v, $i, $a) {$v.price = $max($a.price)})).isbn
+// 
 TEST_F(hof_filterTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case000.json"));
 }
 
-// nothing~>$filter(λ($v, $i, $a) {$v.price = $max($a.price)})
+// 
 TEST_F(hof_filterTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case001.json"));
 }
 
-// $filter(data, function($d) { true })
+// 
 TEST_F(hof_filterTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case002.json"));
 }
 
-// $filter([0, 1, 2], $boolean)
+// 
 TEST_F(hof_filterTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case003.json"));
 }
diff --git a/test/gen/hof_mapTest.cpp b/test/gen/hof_mapTest.cpp
index 51c1741..28ae115 100644
--- a/test/gen/hof_mapTest.cpp
+++ b/test/gen/hof_mapTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class hof_mapTest : public JsonataTest {
 };
 
-// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $add := function($x){$x*$x};  $map($data.one, $add) )  
+// 
 TEST_F(hof_mapTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case000.json"));
 }
 
-// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $add := function($x){$x*$x};  $map($add) )  
+// 
 TEST_F(hof_mapTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case001.json"));
 }
 
-// ( $square := function($x){$x*$x}; $map([1], $square)[] )
+// 
 TEST_F(hof_mapTest, case0010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case0010.json"));
 }
 
-// ( $data := [1]; $square := function($x){$x*$x}; $data ~> $map($square)[] )
+// 
 TEST_F(hof_mapTest, case0011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case0011.json"));
 }
 
-// $map([1,2,3], $string)
+// 
 TEST_F(hof_mapTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case002.json"));
 }
 
-// Account.Order.Product ~> $map(λ($prod, $index) { $index+1 & \": \" & $prod.\"Product Name\" })
+// 
 TEST_F(hof_mapTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case003.json"));
 }
 
-// Account.Order.Product ~> $map(λ($prod, $index, $arr) { $index+1 & \"/\" & $count($arr) & \": \" & $prod.\"Product Name\" })
+// 
 TEST_F(hof_mapTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case004.json"));
 }
 
-// $map(Phone, function($v, $i) {$i[$v.type=\"office\"]})
+// 
 TEST_F(hof_mapTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case005.json"));
 }
 
-// $map(Phone, function($v, $i) {$v.type=\"office\" ? $i})
+// 
 TEST_F(hof_mapTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case006.json"));
 }
 
-// $map(Phone, function($v, $i) {$v.type=\"office\" ? $i: null})
+// 
 TEST_F(hof_mapTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case007.json"));
 }
 
-// $map(Phone, function($v, $i) {$v.type=\"office\" ? $i: null})
+// 
 TEST_F(hof_mapTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case008.json"));
 }
 
-// $map([0, 1, 2], $boolean)
+// 
 TEST_F(hof_mapTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case009.json"));
 }
diff --git a/test/gen/hof_reduceTest.cpp b/test/gen/hof_reduceTest.cpp
index 7007898..1e0d87b 100644
--- a/test/gen/hof_reduceTest.cpp
+++ b/test/gen/hof_reduceTest.cpp
@@ -6,47 +6,47 @@ using namespace jsonata;
 class hof_reduceTest : public JsonataTest {
 };
 
-// (  $seq := [1,2,3,4,5];  $reduce($seq, function($x, $y){$x+$y})) 
+// 
 TEST_F(hof_reduceTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case000.json"));
 }
 
-// (  $concat := function($s){function($a, $b){$string($a) & $s & $string($b)}};  $comma_join := $concat(' ... ');  $reduce([1,2,3,4,5], $comma_join))      
+// 
 TEST_F(hof_reduceTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case001.json"));
 }
 
-// (  $seq := [1,2,3,4,5];  $reduce($seq, function($x, $y){$x+$y}, 2))
+// 
 TEST_F(hof_reduceTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case002.json"));
 }
 
-// (  $seq := 1;  $reduce($seq, function($x, $y){$x+$y}))
+// 
 TEST_F(hof_reduceTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case003.json"));
 }
 
-// (  $seq := 1;  $reduce($seq, function($x, $y){$x+$y}))
+// 
 TEST_F(hof_reduceTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case004.json"));
 }
 
-// $reduce(Account.Order.Product.Quantity, $append)
+// 
 TEST_F(hof_reduceTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case005.json"));
 }
 
-// $reduce(Account.Order.Product.Quantity, $append)
+// 
 TEST_F(hof_reduceTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case006.json"));
 }
 
-// ($product := function($a, $b) { $a * $b };$power := function($x, $n) { $n = 0 ? 1 : $reduce([1..$n].($x), $product) };[0..5].$power(2, $))
+// 
 TEST_F(hof_reduceTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case007.json"));
 }
 
-// (  $seq := 1;  $reduce($seq, function($x){$x}))
+// 
 TEST_F(hof_reduceTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case008.json"));
 }
diff --git a/test/gen/hof_singleTest.cpp b/test/gen/hof_singleTest.cpp
index 3c916d3..d7802ba 100644
--- a/test/gen/hof_singleTest.cpp
+++ b/test/gen/hof_singleTest.cpp
@@ -6,57 +6,57 @@ using namespace jsonata;
 class hof_singleTest : public JsonataTest {
 };
 
-// (library.books~>$single(λ($v, $i, $a) {$v.price = $max($a.price)})).isbn
+// 
 TEST_F(hof_singleTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case000.json"));
 }
 
-// nothing~>$single(λ($v, $i, $a) {$v.price = $max($a.price)})
+// 
 TEST_F(hof_singleTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case001.json"));
 }
 
-// $single(data, function($d) { true })
+// 
 TEST_F(hof_singleTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case002.json"));
 }
 
-// $single([0, 1, 2], $boolean)
+// 
 TEST_F(hof_singleTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case003.json"));
 }
 
-// $single([0, 1, 2], function($v) {$v = 3})
+// 
 TEST_F(hof_singleTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case004.json"));
 }
 
-// $single([0, 1, 2])
+// 
 TEST_F(hof_singleTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case005.json"));
 }
 
-// $single([0])
+// 
 TEST_F(hof_singleTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case006.json"));
 }
 
-// $single([])
+// 
 TEST_F(hof_singleTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case007.json"));
 }
 
-// $single([true, false, true], function($v) {$v=false})
+// 
 TEST_F(hof_singleTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case008.json"));
 }
 
-// $single(['zero', 'one', 'two'], function($v, $i, $k) {$i=1})
+// 
 TEST_F(hof_singleTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case009.json"));
 }
 
-// Phone ~> $filter(function($p) {$p.type = 'home'}) ~> $single(function($p) {$p.number = '0203 544 1234'})
+// 
 TEST_F(hof_singleTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case010.json"));
 }
diff --git a/test/gen/hof_zip_mapTest.cpp b/test/gen/hof_zip_mapTest.cpp
index bc9eb75..a6e7ac2 100644
--- a/test/gen/hof_zip_mapTest.cpp
+++ b/test/gen/hof_zip_mapTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class hof_zip_mapTest : public JsonataTest {
 };
 
-// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $map($zip($data.one, $data.two), $sum)) 
+// 
 TEST_F(hof_zip_mapTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case000.json"));
 }
 
-// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $data.$zip(one, two) ~> $map($sum)) 
+// 
 TEST_F(hof_zip_mapTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case001.json"));
 }
 
-// (  $data := {    \"one\": [1],    \"two\": [5]  };  $data.$zip(one, two) ~> $map($sum)) 
+// 
 TEST_F(hof_zip_mapTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case002.json"));
 }
 
-// (  $data := {    \"one\": 1,    \"two\": 5  };  $data.$zip(one, two) ~> $map($sum)) 
+// 
 TEST_F(hof_zip_mapTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case003.json"));
 }
diff --git a/test/gen/inclusion_operatorTest.cpp b/test/gen/inclusion_operatorTest.cpp
index 13f9bbe..0a61049 100644
--- a/test/gen/inclusion_operatorTest.cpp
+++ b/test/gen/inclusion_operatorTest.cpp
@@ -6,47 +6,47 @@ using namespace jsonata;
 class inclusion_operatorTest : public JsonataTest {
 };
 
-// 1 in [1,2]
+// 
 TEST_F(inclusion_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case000.json"));
 }
 
-// 3 in [1,2]
+// 
 TEST_F(inclusion_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case001.json"));
 }
 
-// \"hello\" in [1,2]
+// 
 TEST_F(inclusion_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case002.json"));
 }
 
-// \"world\" in [\"hello\", \"world\"]
+// 
 TEST_F(inclusion_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case003.json"));
 }
 
-// in in [\"hello\", \"world\"]
+// 
 TEST_F(inclusion_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case004.json"));
 }
 
-// \"world\" in in
+// 
 TEST_F(inclusion_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case005.json"));
 }
 
-// \"hello\" in \"hello\"
+// 
 TEST_F(inclusion_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case006.json"));
 }
 
-// library.books[\"Aho\" in authors].title
+// 
 TEST_F(inclusion_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case007.json"));
 }
 
-// content.integration.$lowercase(name)
+// 
 TEST_F(inclusion_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case008.json"));
 }
diff --git a/test/gen/joinsTest.cpp b/test/gen/joinsTest.cpp
index 9200f71..50a673d 100644
--- a/test/gen/joinsTest.cpp
+++ b/test/gen/joinsTest.cpp
@@ -6,218 +6,23 @@ using namespace jsonata;
 class joinsTest : public JsonataTest {
 };
 
-// Employee@$e.(Contact)[ssn = $e.SSN].{ 'name': $e.(FirstName & ' ' & Surname), 'phone': Phone[type='mobile'].number }
-TEST_F(joinsTest, employee_map_reduce_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 0));
-}
-
-// Employee@$e.(Contact)[ssn = $e.SSN]{ $e.FirstName: Phone[type='mobile'].number }
-TEST_F(joinsTest, employee_map_reduce_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 1));
-}
-
-// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $join($c.Phone.number, ', ') }
-TEST_F(joinsTest, employee_map_reduce_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 2));
-}
-
-// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $c.Phone[type != 'home'].number ~> $join(', ') }
-TEST_F(joinsTest, employee_map_reduce_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 3));
-}
-
-// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $c.Phone[type != 'home'].number }
-TEST_F(joinsTest, employee_map_reduce_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 4));
-}
-
-// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $c.Phone[type != 'home'].number[] }
-TEST_F(joinsTest, employee_map_reduce_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 5));
-}
-
-// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.FirstName: $c.Phone.number }
-TEST_F(joinsTest, employee_map_reduce_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 6));
-}
-
-// Employee@$e^($e.Surname).Contact@$c[$e.SSN=$c.ssn].{ 'name': $e.Surname, 'phone': $c.Phone.number }
-TEST_F(joinsTest, employee_map_reduce_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 7));
-}
-
-// Employee@$e^($e.FirstName).Contact@$c[$e.SSN=$c.ssn].{ 'name': $e.Surname, 'phone': $c.Phone.number }
-TEST_F(joinsTest, employee_map_reduce_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 8));
-}
-
-// Employee@$e.Contact@$c[$e.SSN=$c.ssn]{ $e.Surname: $c.Phone.number^($) }
-TEST_F(joinsTest, employee_map_reduce_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 9));
-}
-
-// Employee@$e.Contact@$c[$e.SSN=$c.ssn]{ $e.Surname: $c.Phone.number^(>$) }
-TEST_F(joinsTest, employee_map_reduce_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 10));
-}
-
-// $@$i
-TEST_F(joinsTest, employee_map_reduce_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 11));
-}
-
-// Account.Order@o.Product
-TEST_F(joinsTest, errors_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 0));
-}
-
-// Account.Order@$o#i.Product
-TEST_F(joinsTest, errors_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 1));
-}
-
-// Account.Order[1]@$o.Product
-TEST_F(joinsTest, errors_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 2));
-}
-
-// Account.Order^(>OrderID)@$o.Product.{ 'name':`Product Name`, 'orderid':$o.OrderID }
-TEST_F(joinsTest, errors_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 3));
-}
-
-// $#$pos[$pos<3]
-TEST_F(joinsTest, index_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 0));
-}
-
-// $#$pos[$pos<3] = $[[0..2]]
-TEST_F(joinsTest, index_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 1));
-}
-
-// $.$#$pos[$pos<3]
-TEST_F(joinsTest, index_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 2));
-}
-
-// $.$#$pos[$pos<3] = $.$[[0..2]]
-TEST_F(joinsTest, index_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 3));
-}
-
-// $#$pos[$pos<3]^($)
-TEST_F(joinsTest, index_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 4));
-}
-
-// $#$pos[$pos<3]^(>$)
-TEST_F(joinsTest, index_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 5));
-}
-
-// $^($)#$pos[$pos<3] 
-TEST_F(joinsTest, index_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 6));
-}
-
-// $#$pos[$pos<3][1]
-TEST_F(joinsTest, index_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 7));
-}
-
-// $#$pos[$pos<3][1][]
-TEST_F(joinsTest, index_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 8));
-}
-
-// $#$pos[$pos<3]^($)[-1]
-TEST_F(joinsTest, index_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 9));
-}
-
-// $#$pos[][$pos<3]^($)[-1]
-TEST_F(joinsTest, index_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 10));
-}
-
-// $#$pos[$pos<3]^($)[-1][]
-TEST_F(joinsTest, index_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 11));
-}
-
-// $[[1..4]]#$pos[$pos>=2]
-TEST_F(joinsTest, index_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 12));
-}
-
-// Account.Order#$o.Product[ProductID=858383].{ 'Product': `Product Name`, 'Order Index': $o }
-TEST_F(joinsTest, index_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 13));
-}
-
-// Account.Order#$i.Missing
-TEST_F(joinsTest, index_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 14));
-}
-
-// Account.Order#$i.Product{ $string(ProductID): $i }
-TEST_F(joinsTest, index_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 15));
-}
-
-// 
-TEST_F(joinsTest, library_joins_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 0));
-}
-
-// 
-TEST_F(joinsTest, library_joins_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 1));
-}
-
-// library.books#$pos.$[$substring(title,0,3) = 'The'].$pos
-TEST_F(joinsTest, library_joins_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 2));
-}
-
-// 
-TEST_F(joinsTest, library_joins_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 3));
-}
-
-// 
-TEST_F(joinsTest, library_joins_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 4));
-}
-
-// 
-TEST_F(joinsTest, library_joins_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 5));
-}
-
-// 
-TEST_F(joinsTest, library_joins_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 6));
-}
-
 // 
-TEST_F(joinsTest, library_joins_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 7));
+TEST_F(joinsTest, employee_map_reduce) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json"));
 }
 
 // 
-TEST_F(joinsTest, library_joins_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 8));
+TEST_F(joinsTest, errors) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/errors.json"));
 }
 
 // 
-TEST_F(joinsTest, library_joins_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 9));
+TEST_F(joinsTest, index) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/index.json"));
 }
 
 // 
-TEST_F(joinsTest, library_joins_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 10));
+TEST_F(joinsTest, library_joins) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/library-joins.json"));
 }
 
diff --git a/test/gen/lambdasTest.cpp b/test/gen/lambdasTest.cpp
index 50a9a44..8c680eb 100644
--- a/test/gen/lambdasTest.cpp
+++ b/test/gen/lambdasTest.cpp
@@ -6,72 +6,72 @@ using namespace jsonata;
 class lambdasTest : public JsonataTest {
 };
 
-// function($x){$x*$x}(5)
+// 
 TEST_F(lambdasTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case000.json"));
 }
 
-// function($x){$x>5 ? \"foo\"}(6)
+// 
 TEST_F(lambdasTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case001.json"));
 }
 
-// function($x){$x>5 ? \"foo\"}(3)
+// 
 TEST_F(lambdasTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case002.json"));
 }
 
-// ($factorial:= function($x){$x <= 1 ? 1 : $x * $factorial($x-1)}; $factorial(4))
+// 
 TEST_F(lambdasTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case003.json"));
 }
 
-// ($fibonacci := function($x){$x <= 1 ? $x : $fibonacci($x-1) + $fibonacci($x-2)}; [1,2,3,4,5,6,7,8,9].$fibonacci($))
+// 
 TEST_F(lambdasTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case004.json"));
 }
 
-// ($nth_price := function($n) { (Account.Order.Product.Price)[$n] }; $nth_price(1) )
+// 
 TEST_F(lambdasTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case005.json"));
 }
 
-//             (              $even := function($n) { $n = 0 ? true : $odd($n-1) };              $odd := function($n) { $n = 0 ? false : $even($n-1) };              $even(82)            )
+// 
 TEST_F(lambdasTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case006.json"));
 }
 
-//             (              $even := function($n) { $n = 0 ? true : $odd($n-1) };               $odd := function($n) { $n = 0 ? false : $even($n-1) };               $even(65) )
+// 
 TEST_F(lambdasTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case007.json"));
 }
 
-//         (          $even := function($n) { $n = 0 ? true : $odd($n-1) };           $odd := function($n) { $n = 0 ? false : $even($n-1) };           $odd(65)         )
+// 
 TEST_F(lambdasTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case008.json"));
 }
 
-// (  $gcd := λ($a, $b){$b = 0 ? $a : $gcd($b, $a%$b) };  [$gcd(8,12), $gcd(9,12)])
+// 
 TEST_F(lambdasTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case009.json"));
 }
 
-// (  $range := function($start, $end, $step) { (    $step:=($step?$step:1);    $start+$step > $end ? $start : $append($start, $range($start+$step, $end, $step))   )};  $range(0,15))        
+// 
 TEST_F(lambdasTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case010.json"));
 }
 
-// (  $range := function($start, $end, $step) { (      $step:=($step?$step:1);        $start+$step > $end ? $start : $append($start, $range($start+$step, $end, $step))   )};  $range(0,15,2))        
+// 
 TEST_F(lambdasTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case011.json"));
 }
 
-// ( $median := λ($x){$sort($x)[$count($x)/2]};  $median([5,4,3,2,1,6,7,8,1]) )
+// 
 TEST_F(lambdasTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case012.json"));
 }
 
-// ( $f := function(){1}; $f.environment )
+// 
 TEST_F(lambdasTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case013.json"));
 }
diff --git a/test/gen/literalsTest.cpp b/test/gen/literalsTest.cpp
index fd3cf33..21ba44d 100644
--- a/test/gen/literalsTest.cpp
+++ b/test/gen/literalsTest.cpp
@@ -6,122 +6,107 @@ using namespace jsonata;
 class literalsTest : public JsonataTest {
 };
 
-// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
-TEST_F(literalsTest, array_inputs_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 0));
+// 
+TEST_F(literalsTest, array_inputs) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/array-inputs.json"));
 }
 
-// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
-TEST_F(literalsTest, array_inputs_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 1));
-}
-
-// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
-TEST_F(literalsTest, array_inputs_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 2));
-}
-
-// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
-TEST_F(literalsTest, array_inputs_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 3));
-}
-
-// \"hello\"
+// 
 TEST_F(literalsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case000.json"));
 }
 
-// 'hello'
+// 
 TEST_F(literalsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case001.json"));
 }
 
-// \"Wayne's World\"
+// 
 TEST_F(literalsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case002.json"));
 }
 
-// 42
+// 
 TEST_F(literalsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case003.json"));
 }
 
-// -42
+// 
 TEST_F(literalsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case004.json"));
 }
 
-// 3.14159
+// 
 TEST_F(literalsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case005.json"));
 }
 
-// 6.022e23
+// 
 TEST_F(literalsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case006.json"));
 }
 
-// 1.602E-19
+// 
 TEST_F(literalsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case007.json"));
 }
 
-// 10e1000
+// 
 TEST_F(literalsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case008.json"));
 }
 
-// \"hello\\tworld\"
+// 
 TEST_F(literalsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case009.json"));
 }
 
-// \"hello\\nworld\"
+// 
 TEST_F(literalsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case010.json"));
 }
 
-// \"hello \\\"world\\\"\"
+// 
 TEST_F(literalsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case011.json"));
 }
 
-// \"C:\\\\Test\\\\test.txt\"
+// 
 TEST_F(literalsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case012.json"));
 }
 
-// \"\\u03BB-calculus rocks\"
+// 
 TEST_F(literalsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case013.json"));
 }
 
-// \"𝄞\"
+// 
 TEST_F(literalsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case014.json"));
 }
 
-// \"\\y\"
+// 
 TEST_F(literalsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case015.json"));
 }
 
-// \"\\u\"
+// 
 TEST_F(literalsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case016.json"));
 }
 
-// \"\\u123t\"
+// 
 TEST_F(literalsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case017.json"));
 }
 
-// { 'foo': { 'sequence': 123, 'bar': 'baz' } } 
+// 
 TEST_F(literalsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case018.json"));
 }
 
-// { 'foo': { 'sequence': true, 'bar': 'baz' } } 
+// 
 TEST_F(literalsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case019.json"));
 }
diff --git a/test/gen/matchersTest.cpp b/test/gen/matchersTest.cpp
index 5d947c5..b11340a 100644
--- a/test/gen/matchersTest.cpp
+++ b/test/gen/matchersTest.cpp
@@ -11,7 +11,7 @@ TEST_F(matchersTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/matchers/case000.json"));
 }
 
-// $split('some text', $uppercase)
+// 
 TEST_F(matchersTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/matchers/case001.json"));
 }
diff --git a/test/gen/missing_pathsTest.cpp b/test/gen/missing_pathsTest.cpp
index 562fe25..c3802c9 100644
--- a/test/gen/missing_pathsTest.cpp
+++ b/test/gen/missing_pathsTest.cpp
@@ -6,32 +6,32 @@ using namespace jsonata;
 class missing_pathsTest : public JsonataTest {
 };
 
-// fdf
+// 
 TEST_F(missing_pathsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case000.json"));
 }
 
-// fdf.ett
+// 
 TEST_F(missing_pathsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case001.json"));
 }
 
-// fdf.ett[10]
+// 
 TEST_F(missing_pathsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case002.json"));
 }
 
-// fdf.ett[vc > 10]
+// 
 TEST_F(missing_pathsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case003.json"));
 }
 
-// fdf.ett + 27
+// 
 TEST_F(missing_pathsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case004.json"));
 }
 
-// $fdsd
+// 
 TEST_F(missing_pathsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case005.json"));
 }
diff --git a/test/gen/multiple_array_selectorsTest.cpp b/test/gen/multiple_array_selectorsTest.cpp
index 2b8d916..ca7e94b 100644
--- a/test/gen/multiple_array_selectorsTest.cpp
+++ b/test/gen/multiple_array_selectorsTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class multiple_array_selectorsTest : public JsonataTest {
 };
 
-// [1..10][[1..3,8,-1]]
+// 
 TEST_F(multiple_array_selectorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/multiple-array-selectors/case000.json"));
 }
 
-// [1..10][[1..3,8,5]]
+// 
 TEST_F(multiple_array_selectorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/multiple-array-selectors/case001.json"));
 }
 
-// [1..10][[1..3,8,false]]
+// 
 TEST_F(multiple_array_selectorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/multiple-array-selectors/case002.json"));
 }
diff --git a/test/gen/nullTest.cpp b/test/gen/nullTest.cpp
index e067966..b7dd607 100644
--- a/test/gen/nullTest.cpp
+++ b/test/gen/nullTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class nullTest : public JsonataTest {
 };
 
-// null
+// 
 TEST_F(nullTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case000.json"));
 }
 
-// [null]
+// 
 TEST_F(nullTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case001.json"));
 }
 
-// [null, null]
+// 
 TEST_F(nullTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case002.json"));
 }
 
-// $not(null)
+// 
 TEST_F(nullTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case003.json"));
 }
 
-// null = null
+// 
 TEST_F(nullTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case004.json"));
 }
 
-// null != null
+// 
 TEST_F(nullTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case005.json"));
 }
 
-// {\"true\": true, \"false\":false, \"null\": null}
+// 
 TEST_F(nullTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case006.json"));
 }
diff --git a/test/gen/numeric_operatorsTest.cpp b/test/gen/numeric_operatorsTest.cpp
index a388e28..28e5689 100644
--- a/test/gen/numeric_operatorsTest.cpp
+++ b/test/gen/numeric_operatorsTest.cpp
@@ -6,97 +6,97 @@ using namespace jsonata;
 class numeric_operatorsTest : public JsonataTest {
 };
 
-// foo.bar + bar
+// 
 TEST_F(numeric_operatorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case000.json"));
 }
 
-// bar + foo.bar
+// 
 TEST_F(numeric_operatorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case001.json"));
 }
 
-// foo.bar - bar
+// 
 TEST_F(numeric_operatorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case002.json"));
 }
 
-// bar - foo.bar
+// 
 TEST_F(numeric_operatorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case003.json"));
 }
 
-// foo.bar * bar
+// 
 TEST_F(numeric_operatorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case004.json"));
 }
 
-// bar * foo.bar
+// 
 TEST_F(numeric_operatorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case005.json"));
 }
 
-// foo.bar / bar
+// 
 TEST_F(numeric_operatorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case006.json"));
 }
 
-// bar / foo.bar
+// 
 TEST_F(numeric_operatorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case007.json"));
 }
 
-// foo.bar % bar
+// 
 TEST_F(numeric_operatorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case008.json"));
 }
 
-// bar % foo.bar
+// 
 TEST_F(numeric_operatorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case009.json"));
 }
 
-// bar + foo.bar * bar
+// 
 TEST_F(numeric_operatorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case010.json"));
 }
 
-// foo.bar * bar + bar
+// 
 TEST_F(numeric_operatorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case011.json"));
 }
 
-// 24 * notexist
+// 
 TEST_F(numeric_operatorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case012.json"));
 }
 
-// notexist + 1
+// 
 TEST_F(numeric_operatorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case013.json"));
 }
 
-// 1/(10e300 * 10e100) 
+// 
 TEST_F(numeric_operatorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case014.json"));
 }
 
-// \"5\" + \"5\"
+// 
 TEST_F(numeric_operatorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case015.json"));
 }
 
-// - notexist
+// 
 TEST_F(numeric_operatorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case016.json"));
 }
 
-// false + 1
+// 
 TEST_F(numeric_operatorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case017.json"));
 }
 
-// false + $x
+// 
 TEST_F(numeric_operatorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case018.json"));
 }
diff --git a/test/gen/object_constructorTest.cpp b/test/gen/object_constructorTest.cpp
index 23659fd..3a92032 100644
--- a/test/gen/object_constructorTest.cpp
+++ b/test/gen/object_constructorTest.cpp
@@ -6,127 +6,127 @@ using namespace jsonata;
 class object_constructorTest : public JsonataTest {
 };
 
-// {}
+// 
 TEST_F(object_constructorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case000.json"));
 }
 
-// {\"key\": \"value\"}
+// 
 TEST_F(object_constructorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case001.json"));
 }
 
-// {\"one\": 1, \"two\": 2}
+// 
 TEST_F(object_constructorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case002.json"));
 }
 
-// {\"one\": 1, \"two\": 2}.two
+// 
 TEST_F(object_constructorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case003.json"));
 }
 
-// {\"one\": 1, \"two\": {\"three\": 3, \"four\": \"4\"}}
+// 
 TEST_F(object_constructorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case004.json"));
 }
 
-// {\"one\": 1, \"two\": [3, \"four\"]}
+// 
 TEST_F(object_constructorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case005.json"));
 }
 
-// {\"test\": ()}
+// 
 TEST_F(object_constructorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case006.json"));
 }
 
-// blah.{}
+// 
 TEST_F(object_constructorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case007.json"));
 }
 
-// Account.Order{OrderID: Product.\"Product Name\"}
+// 
 TEST_F(object_constructorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case008.json"));
 }
 
-// Account.Order.{OrderID: Product.\"Product Name\"}
+// 
 TEST_F(object_constructorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case009.json"));
 }
 
-// Account.Order.Product{$string(ProductID): Price}
+// 
 TEST_F(object_constructorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case010.json"));
 }
 
-// Account.Order.Product{$string(ProductID): (Price)[0]}
+// 
 TEST_F(object_constructorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case011.json"));
 }
 
-// Account.Order.Product.{$string(ProductID): Price}
+// 
 TEST_F(object_constructorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case012.json"));
 }
 
-// Account.Order.Product{ProductID: \"Product Name\"}
+// 
 TEST_F(object_constructorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case013.json"));
 }
 
-// Account.Order.Product.{ProductID: \"Product Name\"}
+// 
 TEST_F(object_constructorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case014.json"));
 }
 
-// Account.Order{OrderID: $sum(Product.(Price*Quantity))}
+// 
 TEST_F(object_constructorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case015.json"));
 }
 
-// Account.Order.{OrderID: $sum(Product.(Price*Quantity))}
+// 
 TEST_F(object_constructorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case016.json"));
 }
 
-// Account.Order.Product{$.\"Product Name\": Price, $.\"Product Name\": Price}
+// 
 TEST_F(object_constructorTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case017.json"));
 }
 
-// Account.Order.Product{`Product Name`: Price, SKU: Price}
+// 
 TEST_F(object_constructorTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case018.json"));
 }
 
-// Account.Order{  OrderID: {    \"TotalPrice\":$sum(Product.(Price * Quantity)),    \"Items\": Product.\"Product Name\"  }}
+// 
 TEST_F(object_constructorTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case019.json"));
 }
 
-// {  \"Order\": Account.Order.{      \"ID\": OrderID,      \"Product\": Product.{          \"Name\": $.\"Product Name\",          \"SKU\": ProductID,          \"Details\": {            \"Weight\": Description.Weight,            \"Dimensions\": Description.(Width & \" x \" & Height & \" x \" & Depth)          }        },      \"Total Price\": $sum(Product.(Price * Quantity))    }}
+// 
 TEST_F(object_constructorTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case020.json"));
 }
 
-// {  \"Order\": Account.Order.{      \"ID\": OrderID,      \"Product\": Product.{          \"Name\": `Product Name`,          \"SKU\": ProductID,          \"Details\": {            \"Weight\": Description.Weight,            \"Dimensions\": Description.(Width & \" x \" & Height & \" x \" & Depth)          }        },      \"Total Price\": $sum(Product.(Price * Quantity))    }}
+// 
 TEST_F(object_constructorTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case021.json"));
 }
 
-// Phone{type: $join(number, \", \"), \"phone\":number}
+// 
 TEST_F(object_constructorTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case022.json"));
 }
 
-// $.{ type: $average(value), kind: $sum(value) } 
+// 
 TEST_F(object_constructorTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case023.json"));
 }
 
-// { type: $average(value), kind: $sum(value) } 
+// 
 TEST_F(object_constructorTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case024.json"));
 }
@@ -136,7 +136,7 @@ TEST_F(object_constructorTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case025.json"));
 }
 
-// $${id:{'label':label,'value':value}}
+// 
 TEST_F(object_constructorTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case026.json"));
 }
diff --git a/test/gen/parent_operatorTest.cpp b/test/gen/parent_operatorTest.cpp
index b657eff..0248614 100644
--- a/test/gen/parent_operatorTest.cpp
+++ b/test/gen/parent_operatorTest.cpp
@@ -6,223 +6,13 @@ using namespace jsonata;
 class parent_operatorTest : public JsonataTest {
 };
 
-// {'hello': 'world'}.% 
-TEST_F(parent_operatorTest, errors_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 0));
-}
-
-// %
-TEST_F(parent_operatorTest, errors_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 1));
-}
-
-// %()
-TEST_F(parent_operatorTest, errors_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 2));
-}
-
-// %(1)
-TEST_F(parent_operatorTest, errors_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 3));
-}
-
-// %%
-TEST_F(parent_operatorTest, errors_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 4));
-}
-
-// (%)
-TEST_F(parent_operatorTest, errors_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 5));
-}
-
-// (%%)
-TEST_F(parent_operatorTest, errors_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 6));
-}
-
-// library.loans.%%
-TEST_F(parent_operatorTest, errors_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 7));
-}
-
-// $.%
-TEST_F(parent_operatorTest, errors_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 8));
-}
-
-// $$.%
-TEST_F(parent_operatorTest, errors_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 9));
-}
-
-// library.loans.%.%.%
-TEST_F(parent_operatorTest, errors_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 10));
-}
-
-// library.%%%
-TEST_F(parent_operatorTest, errors_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 11));
-}
-
-// library.(%%%)
-TEST_F(parent_operatorTest, errors_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 12));
-}
-
-// library.(%% %)
-TEST_F(parent_operatorTest, errors_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 13));
-}
-
-// library.(% %%)
-TEST_F(parent_operatorTest, errors_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 14));
-}
-
-// library.(% % %)
-TEST_F(parent_operatorTest, errors_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 15));
-}
-
 // 
-TEST_F(parent_operatorTest, parent_case_0) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 0));
+TEST_F(parent_operatorTest, errors) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parent-operator/errors.json"));
 }
 
 // 
-TEST_F(parent_operatorTest, parent_case_1) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 1));
-}
-
-// Account.Order.Product.[`Product Name`, %.OrderID]
-TEST_F(parent_operatorTest, parent_case_2) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 2));
-}
-
-// Account.Order.Product.{ `Product Name`: [Quantity, %.OrderID] }
-TEST_F(parent_operatorTest, parent_case_3) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 3));
-}
-
-// Account.Order.Product.{ `Product Name`: [Quantity, (%.OrderID)] }
-TEST_F(parent_operatorTest, parent_case_4) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 4));
-}
-
-// Account.Order.Product[%.OrderID='order104'].SKU
-TEST_F(parent_operatorTest, parent_case_5) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 5));
-}
-
-// Account.Order.Product[%.%.`Account Name`='Firefly'].SKU
-TEST_F(parent_operatorTest, parent_case_6) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 6));
-}
-
-// Account.Order.Product.Price[%.%.OrderID='order103']
-TEST_F(parent_operatorTest, parent_case_7) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 7));
-}
-
-// Account.Order.Product.Price.%[%.OrderID='order103'].SKU
-TEST_F(parent_operatorTest, parent_case_8) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 8));
-}
-
-// Account.Order.Product[%.OrderID='order104'][%.%.`Account Name`='Firefly'].SKU
-TEST_F(parent_operatorTest, parent_case_9) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 9));
-}
-
-// (Account.Order.Product)[%.OrderID='order104'].SKU
-TEST_F(parent_operatorTest, parent_case_10) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 10));
-}
-
-// Account.Order.Product.{ %.OrderID: Price * Quantity }
-TEST_F(parent_operatorTest, parent_case_11) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 11));
-}
-
-// Account.Order.().%
-TEST_F(parent_operatorTest, parent_case_12) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 12));
-}
-
-// 
-TEST_F(parent_operatorTest, parent_case_13) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 13));
-}
-
-// 
-TEST_F(parent_operatorTest, parent_case_14) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 14));
-}
-
-// 
-TEST_F(parent_operatorTest, parent_case_15) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 15));
-}
-
-// 
-TEST_F(parent_operatorTest, parent_case_16) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 16));
-}
-
-// 
-TEST_F(parent_operatorTest, parent_case_17) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 17));
-}
-
-// Account.Order.Product.SKU^(%.Price)
-TEST_F(parent_operatorTest, parent_case_18) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 18));
-}
-
-// Account.Order.Product.SKU^(%.Price, >%.%.OrderID)
-TEST_F(parent_operatorTest, parent_case_19) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 19));
-}
-
-// Account.Order.Product.Description.{ 'Colour': Colour, 'Total': %.Price * %.Quantity }
-TEST_F(parent_operatorTest, parent_case_20) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 20));
-}
-
-// Account.Order.Product.Description.{ 'Item': Colour & ' ' & %.`Product Name`, 'Discounted': (%.%.OrderID = 'order103') ? %.Price / 2 : %.Price }
-TEST_F(parent_operatorTest, parent_case_21) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 21));
-}
-
-// Account.Order.Product.( $parent := %; %.OrderID )
-TEST_F(parent_operatorTest, parent_case_22) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 22));
-}
-
-// Account.Order.Product.( $parent := %; $parent.OrderID )
-TEST_F(parent_operatorTest, parent_case_23) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 23));
-}
-
-// library.loans@$L.books@$B[$L.isbn=$B.isbn].{ 'book': $B.title, 'parent': $keys(%) }
-TEST_F(parent_operatorTest, parent_case_24) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 24));
-}
-
-// library.loans@$L.books@$B[$L.isbn=$B.isbn].customers[id=$L.customer].{ 'book': $B.title, 'customer': name, 'parent': $keys(%) }
-TEST_F(parent_operatorTest, parent_case_25) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 25));
-}
-
-// library.loans@$L.books@$B[$L.isbn=$B.isbn].customers[id=$L.customer].{ 'book': $B.title, 'customer': name, 'parent': $keys(%.%) }
-TEST_F(parent_operatorTest, parent_case_26) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 26));
-}
-
-// library.loans@$L.books@$B[$L.isbn=$B.isbn].customers@$C[$C.id=$L.customer].{ 'book': $B.title, 'customer': $C.name, 'grandparent': $keys(%.%) }
-TEST_F(parent_operatorTest, parent_case_27) {
-    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 27));
+TEST_F(parent_operatorTest, parent) {
+    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parent-operator/parent.json"));
 }
 
diff --git a/test/gen/parenthesesTest.cpp b/test/gen/parenthesesTest.cpp
index 68b7408..23dc991 100644
--- a/test/gen/parenthesesTest.cpp
+++ b/test/gen/parenthesesTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class parenthesesTest : public JsonataTest {
 };
 
-// foo.(blah).baz.fud
+// 
 TEST_F(parenthesesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case000.json"));
 }
 
-// foo.(blah.baz).fud
+// 
 TEST_F(parenthesesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case001.json"));
 }
 
-// (foo.blah.baz).fud
+// 
 TEST_F(parenthesesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case002.json"));
 }
 
-// foo.blah.(baz.fud)
+// 
 TEST_F(parenthesesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case003.json"));
 }
 
-// (foo.blah.baz.fud)
+// 
 TEST_F(parenthesesTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case004.json"));
 }
 
-// (foo).(blah).baz.(fud)
+// 
 TEST_F(parenthesesTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case005.json"));
 }
 
-// (foo.(blah).baz.fud)
+// 
 TEST_F(parenthesesTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case006.json"));
 }
 
-// (4 + 2) / 2
+// 
 TEST_F(parenthesesTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case007.json"));
 }
diff --git a/test/gen/partial_applicationTest.cpp b/test/gen/partial_applicationTest.cpp
index b22f6c3..6fbcac6 100644
--- a/test/gen/partial_applicationTest.cpp
+++ b/test/gen/partial_applicationTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class partial_applicationTest : public JsonataTest {
 };
 
-// (  $add := function($x, $y){$x+$y};  $add2 := $add(?, 2);  $add2(3))
+// 
 TEST_F(partial_applicationTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case000.json"));
 }
 
-// (  $add := function($x, $y){$x+$y};  $add2 := $add(2, ?);  $add2(4))
+// 
 TEST_F(partial_applicationTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case001.json"));
 }
 
-// (  $firstn := $substring(?, 0, ?);  $first5 := $firstn(?, 5);  $first5(\"Hello World\"))
+// 
 TEST_F(partial_applicationTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case002.json"));
 }
 
-// substring(?, 0, ?)
+// 
 TEST_F(partial_applicationTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case003.json"));
 }
 
-// unknown(?)
+// 
 TEST_F(partial_applicationTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case004.json"));
 }
diff --git a/test/gen/performanceTest.cpp b/test/gen/performanceTest.cpp
index dea919a..c5aa4c0 100644
--- a/test/gen/performanceTest.cpp
+++ b/test/gen/performanceTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class performanceTest : public JsonataTest {
 };
 
-// {\"items\": items.{\"foo\": \"bar\",\"count\": $count($$.items[text!=\"\" and text!=\"foo\"].row)}}
+// 
 TEST_F(performanceTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/performance/case000.json"));
 }
 
-// {\"items\": items#$i.{\"foo\": \"bar\",\"label\": $$.items[$i].label & \" \" & $$.items[text!=\"\" and text!=\"test\"][$i].text}}
+// 
 TEST_F(performanceTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/performance/case001.json"));
 }
diff --git a/test/gen/predicatesTest.cpp b/test/gen/predicatesTest.cpp
index e7044b3..c0cf074 100644
--- a/test/gen/predicatesTest.cpp
+++ b/test/gen/predicatesTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class predicatesTest : public JsonataTest {
 };
 
-// nothing[x=6][y=3].number
+// 
 TEST_F(predicatesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case000.json"));
 }
 
-// clues[x=6][y=3].number
+// 
 TEST_F(predicatesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case001.json"));
 }
 
-// $[x=6][y=3].number
+// 
 TEST_F(predicatesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case002.json"));
 }
 
-// Account.Order.Product[$lowercase(Description.Colour) = \"purple\"][0].Price
+// 
 TEST_F(predicatesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case003.json"));
 }
diff --git a/test/gen/quoted_selectorsTest.cpp b/test/gen/quoted_selectorsTest.cpp
index 63e29ea..fcf774d 100644
--- a/test/gen/quoted_selectorsTest.cpp
+++ b/test/gen/quoted_selectorsTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class quoted_selectorsTest : public JsonataTest {
 };
 
-// foo.\"blah\"
+// 
 TEST_F(quoted_selectorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case000.json"));
 }
 
-// foo.\"blah\".baz.'fud'
+// 
 TEST_F(quoted_selectorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case001.json"));
 }
 
-// \"foo\".\"blah\".\"baz\".\"fud\"
+// 
 TEST_F(quoted_selectorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case002.json"));
 }
 
-// foo.\"blah.baz\"
+// 
 TEST_F(quoted_selectorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case003.json"));
 }
 
-// foo.`blah`
+// 
 TEST_F(quoted_selectorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case004.json"));
 }
 
-// foo.`blah`.baz.'fud'
+// 
 TEST_F(quoted_selectorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case005.json"));
 }
 
-// `foo`.`blah`.`baz`.`fud`
+// 
 TEST_F(quoted_selectorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case006.json"));
 }
 
-// foo.`blah.baz`
+// 
 TEST_F(quoted_selectorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case007.json"));
 }
diff --git a/test/gen/range_operatorTest.cpp b/test/gen/range_operatorTest.cpp
index 139eee4..106e494 100644
--- a/test/gen/range_operatorTest.cpp
+++ b/test/gen/range_operatorTest.cpp
@@ -6,127 +6,127 @@ using namespace jsonata;
 class range_operatorTest : public JsonataTest {
 };
 
-// [0..9]
+// 
 TEST_F(range_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case000.json"));
 }
 
-// [0..9][$ % 2 = 0]
+// 
 TEST_F(range_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case001.json"));
 }
 
-// [0, 4..9, 20, 22]
+// 
 TEST_F(range_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case002.json"));
 }
 
-// [5..2]
+// 
 TEST_F(range_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case003.json"));
 }
 
-// [5..2, 2..5]
+// 
 TEST_F(range_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case004.json"));
 }
 
-// [-2..2]
+// 
 TEST_F(range_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case005.json"));
 }
 
-// [-2..2].($*$)
+// 
 TEST_F(range_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case006.json"));
 }
 
-// [-2..blah]
+// 
 TEST_F(range_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case007.json"));
 }
 
-// [blah..5, 3, -2..blah]
+// 
 TEST_F(range_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case008.json"));
 }
 
-// [1.1 .. 5]
+// 
 TEST_F(range_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case009.json"));
 }
 
-// [1 .. 5.5]
+// 
 TEST_F(range_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case010.json"));
 }
 
-// [10..1.5]
+// 
 TEST_F(range_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case011.json"));
 }
 
-// [true..false]
+// 
 TEST_F(range_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case012.json"));
 }
 
-// ['dogs'..'cats']
+// 
 TEST_F(range_operatorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case013.json"));
 }
 
-// [1..'']
+// 
 TEST_F(range_operatorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case014.json"));
 }
 
-// [1..[]]
+// 
 TEST_F(range_operatorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case015.json"));
 }
 
-// [1..{}]
+// 
 TEST_F(range_operatorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case016.json"));
 }
 
-// [1..false]
+// 
 TEST_F(range_operatorTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case017.json"));
 }
 
-// [2..true]
+// 
 TEST_F(range_operatorTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case018.json"));
 }
 
-// [$x..true]
+// 
 TEST_F(range_operatorTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case019.json"));
 }
 
-// [false..$x]
+// 
 TEST_F(range_operatorTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case020.json"));
 }
 
-// [1..10000000] ~> $count()
+// 
 TEST_F(range_operatorTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case021.json"));
 }
 
-// [0..10000000] ~> $count()
+// 
 TEST_F(range_operatorTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case022.json"));
 }
 
-// [1..10000001] ~> $count()
+// 
 TEST_F(range_operatorTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case023.json"));
 }
 
-// [100..10000099] ~> $count()
+// 
 TEST_F(range_operatorTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case024.json"));
 }
diff --git a/test/gen/regexTest.cpp b/test/gen/regexTest.cpp
index 2892bfb..051bff8 100644
--- a/test/gen/regexTest.cpp
+++ b/test/gen/regexTest.cpp
@@ -6,197 +6,197 @@ using namespace jsonata;
 class regexTest : public JsonataTest {
 };
 
-// $split(\"ababbxabbcc\",/b+/)
+// 
 TEST_F(regexTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case000.json"));
 }
 
-// $split(\"ababbxabbcc\",/b+/, 2)
+// 
 TEST_F(regexTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case001.json"));
 }
 
-// $split(\"ababbxabbcc\",/d+/)
+// 
 TEST_F(regexTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case002.json"));
 }
 
-// $contains(\"ababbxabbcc\",/ab+/)
+// 
 TEST_F(regexTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case003.json"));
 }
 
-// $contains(\"ababbxabbcc\",/ax+/)
+// 
 TEST_F(regexTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case004.json"));
 }
 
-// Account.Order.Product[$contains($.\"Product Name\", /hat/)].ProductID
+// 
 TEST_F(regexTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case005.json"));
 }
 
-// Account.Order.Product[$contains($.\"Product Name\", /hat/i)].ProductID
+// 
 TEST_F(regexTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case006.json"));
 }
 
-// $replace(\"ababbxabbcc\",/b+/, \"yy\")
+// 
 TEST_F(regexTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case007.json"));
 }
 
-// $replace(\"ababbxabbcc\",/b+/, \"yy\", 2)
+// 
 TEST_F(regexTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case008.json"));
 }
 
-// $replace(\"ababbxabbcc\",/b+/, \"yy\", 0)
+// 
 TEST_F(regexTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case009.json"));
 }
 
-// $replace(\"ababbxabbcc\",/d+/, \"yy\")
+// 
 TEST_F(regexTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case010.json"));
 }
 
-// $replace(\"John Smith\", /(\\w+)\\s(\\w+)/, \"$2, $1\")
+// 
 TEST_F(regexTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case011.json"));
 }
 
-// $replace(\"265USD\", /([0-9]+)USD/, \"$$$1\")
+// 
 TEST_F(regexTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case012.json"));
 }
 
-// $replace(\"265USD\", /([0-9]+)USD/, \"$w\")
+// 
 TEST_F(regexTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case013.json"));
 }
 
-// $replace(\"265USD\", /([0-9]+)USD/, \"$0 -> $$$1\")
+// 
 TEST_F(regexTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case014.json"));
 }
 
-// $replace(\"265USD\", /([0-9]+)USD/, \"$0$1$2\")
+// 
 TEST_F(regexTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case015.json"));
 }
 
-// $replace(\"abcd\", /(ab)|(a)/, \"[1=$1][2=$2]\")
+// 
 TEST_F(regexTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case016.json"));
 }
 
-// $replace(\"abracadabra\", /bra/, \"*\")
+// 
 TEST_F(regexTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case017.json"));
 }
 
-// $replace(\"abracadabra\", /a.*a/, \"*\")
+// 
 TEST_F(regexTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case018.json"));
 }
 
-// $replace(\"abracadabra\", /a.*?a/, \"*\")
+// 
 TEST_F(regexTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case019.json"));
 }
 
-// $replace(\"abracadabra\", /a/, \"\")
+// 
 TEST_F(regexTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case020.json"));
 }
 
-// $replace(\"abracadabra\", /a(.)/, \"a$1$1\")
+// 
 TEST_F(regexTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case021.json"));
 }
 
-// $replace(\"abracadabra\", /.*?/, \"$1\")
+// 
 TEST_F(regexTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case022.json"));
 }
 
-// $replace(\"AAAA\", /A+/, \"b\")
+// 
 TEST_F(regexTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case023.json"));
 }
 
-// $replace(\"AAAA\", /A+?/, \"b\")
+// 
 TEST_F(regexTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case024.json"));
 }
 
-// $replace(\"darted\", /^(.*?)d(.*)$/, \"$1c$2\")
+// 
 TEST_F(regexTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case025.json"));
 }
 
-// $replace(\"abcdefghijklmno\", /(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)/, \"$8$5$12$12$18$123\")
+// 
 TEST_F(regexTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case026.json"));
 }
 
-// $replace(\"abcdefghijklmno\", /xyz/, \"$8$5$12$12$18$123\")
+// 
 TEST_F(regexTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case027.json"));
 }
 
-// $replace(\"abcdefghijklmno\", /ijk/, \"$8$5$12$12$18$123\")
+// 
 TEST_F(regexTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case028.json"));
 }
 
-// $replace(\"abcdefghijklmno\", /(ijk)/, \"$8$5$12$12$18$123\")
+// 
 TEST_F(regexTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case029.json"));
 }
 
-// $replace(\"abcdefghijklmno\", /ijk/, \"$x\")
+// 
 TEST_F(regexTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case030.json"));
 }
 
-// $replace(\"abcdefghijklmno\", /(ijk)/, \"$x$\")
+// 
 TEST_F(regexTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case031.json"));
 }
 
-// Account.Order.Product.$replace($.\"Product Name\", /hat/i, function($match) { \"foo\" })
+// 
 TEST_F(regexTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case032.json"));
 }
 
-// Account.Order.Product.$replace($.\"Product Name\", /(h)(at)/i, function($match) { $uppercase($match.match) })
+// 
 TEST_F(regexTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case033.json"));
 }
 
-// $replace(\"temperature = 68F today\", /(-?\\d+(?:\\.\\d*)?)F\\b/, function($m) { ($number($m.groups[0]) - 32) * 5/9 & \"C\" })
+// 
 TEST_F(regexTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case034.json"));
 }
 
-// Account.Order.Product.$replace($.\"Product Name\", /hat/i, function($match) { true })
+// 
 TEST_F(regexTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case035.json"));
 }
 
-// Account.Order.Product.$replace($.\"Product Name\", /hat/i, function($match) { 42 })
+// 
 TEST_F(regexTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case036.json"));
 }
 
-// $map($, $match(?, /^(\\w*\\s\\w*)/)).match
+// 
 TEST_F(regexTest, case037) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case037.json"));
 }
 
-// $map($, function($i){ $match($i, /^(\\w*\\s\\w*)/) }).match
+// 
 TEST_F(regexTest, case038) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case038.json"));
 }
diff --git a/test/gen/simple_array_selectorsTest.cpp b/test/gen/simple_array_selectorsTest.cpp
index 4969536..0dd6c6b 100644
--- a/test/gen/simple_array_selectorsTest.cpp
+++ b/test/gen/simple_array_selectorsTest.cpp
@@ -6,117 +6,117 @@ using namespace jsonata;
 class simple_array_selectorsTest : public JsonataTest {
 };
 
-// nest0.nest1[0]
+// 
 TEST_F(simple_array_selectorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case000.json"));
 }
 
-// foo.blah[0].baz.fud
+// 
 TEST_F(simple_array_selectorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case001.json"));
 }
 
-// foo.blah[1].baz.fud
+// 
 TEST_F(simple_array_selectorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case002.json"));
 }
 
-// foo.blah[-1].bazz
+// 
 TEST_F(simple_array_selectorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case003.json"));
 }
 
-// (foo.blah)[1].baz.fud
+// 
 TEST_F(simple_array_selectorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case004.json"));
 }
 
-// foo.blah.baz.fud[0]
+// 
 TEST_F(simple_array_selectorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case005.json"));
 }
 
-// foo.blah.baz.fud[-1]
+// 
 TEST_F(simple_array_selectorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case006.json"));
 }
 
-// (foo.blah.baz.fud)[0]
+// 
 TEST_F(simple_array_selectorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case007.json"));
 }
 
-// (foo.blah.baz.fud)[1]
+// 
 TEST_F(simple_array_selectorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case008.json"));
 }
 
-// (foo.blah.baz.fud)[5 * 0.2]
+// 
 TEST_F(simple_array_selectorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case009.json"));
 }
 
-// (foo.blah.baz.fud)[-1]
+// 
 TEST_F(simple_array_selectorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case010.json"));
 }
 
-// (foo.blah.baz.fud)[-2]
+// 
 TEST_F(simple_array_selectorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case011.json"));
 }
 
-// (foo.blah.baz.fud)[2-4]
+// 
 TEST_F(simple_array_selectorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case012.json"));
 }
 
-// (foo.blah.baz.fud)[-(4-2)]
+// 
 TEST_F(simple_array_selectorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case013.json"));
 }
 
-// (foo.blah.baz.fud)[$$.foo.bar / 30]
+// 
 TEST_F(simple_array_selectorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case014.json"));
 }
 
-// foo.blah[0].baz
+// 
 TEST_F(simple_array_selectorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case015.json"));
 }
 
-// foo.blah.baz[0]
+// 
 TEST_F(simple_array_selectorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case016.json"));
 }
 
-// (foo.blah.baz)[0]
+// 
 TEST_F(simple_array_selectorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case017.json"));
 }
 
-// $[0]
+// 
 TEST_F(simple_array_selectorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case018.json"));
 }
 
-// $[1]
+// 
 TEST_F(simple_array_selectorsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case019.json"));
 }
 
-// $[-1]
+// 
 TEST_F(simple_array_selectorsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case020.json"));
 }
 
-// $[1][0]
+// 
 TEST_F(simple_array_selectorsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case021.json"));
 }
 
-// $[1.1][0.9]
+// 
 TEST_F(simple_array_selectorsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case022.json"));
 }
diff --git a/test/gen/sortingTest.cpp b/test/gen/sortingTest.cpp
index 9c607c6..d80bc3f 100644
--- a/test/gen/sortingTest.cpp
+++ b/test/gen/sortingTest.cpp
@@ -6,107 +6,107 @@ using namespace jsonata;
 class sortingTest : public JsonataTest {
 };
 
-// Account.Order.Product.Price^($)
+// 
 TEST_F(sortingTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case000.json"));
 }
 
-// Account.Order.Product.Price^(<$)
+// 
 TEST_F(sortingTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case001.json"));
 }
 
-// Account.Order.Product.Price^(>$)
+// 
 TEST_F(sortingTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case002.json"));
 }
 
-// Account.Order.Product^(Price).Description.Colour
+// 
 TEST_F(sortingTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case003.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case004.json"));
 }
 
-// Account.Order.Product^(Price * Quantity).Description.Colour
+// 
 TEST_F(sortingTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case005.json"));
 }
 
-// Account.Order.Product^(Quantity, Description.Colour).Description.Colour
+// 
 TEST_F(sortingTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case006.json"));
 }
 
-// Account.Order.Product^(Quantity, >Description.Colour).Description.Colour
+// 
 TEST_F(sortingTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case007.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case008.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case009.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case010.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case011.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case012.json"));
 }
 
-// Account.Order.Product^(Price).SKU
+// 
 TEST_F(sortingTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case013.json"));
 }
 
-// $^(age).name
+// 
 TEST_F(sortingTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case014.json"));
 }
 
-// ($^(age)).name
+// 
 TEST_F(sortingTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case015.json"));
 }
 
-// $^(age)[0].name
+// 
 TEST_F(sortingTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case016.json"));
 }
 
-// ($^(age))[0].name
+// 
 TEST_F(sortingTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case017.json"));
 }
 
-// ($^(age)[0]).name
+// 
 TEST_F(sortingTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case018.json"));
 }
 
-// $[0]^(age)
+// 
 TEST_F(sortingTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case019.json"));
 }
 
-// Account.Order#$o.Product^(ProductID).{ 'Product': `Product Name`, 'Order Index': $o }
+// 
 TEST_F(sortingTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case020.json"));
 }
diff --git a/test/gen/string_concatTest.cpp b/test/gen/string_concatTest.cpp
index af903ff..ce6bec0 100644
--- a/test/gen/string_concatTest.cpp
+++ b/test/gen/string_concatTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class string_concatTest : public JsonataTest {
 };
 
-// \"foo\" & \"bar\"
+// 
 TEST_F(string_concatTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case000.json"));
 }
 
-// \"foo\"&\"bar\"
+// 
 TEST_F(string_concatTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case001.json"));
 }
 
-// foo.blah[0].baz.fud &foo.blah[1].baz.fud
+// 
 TEST_F(string_concatTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case002.json"));
 }
 
-// foo.(blah[0].baz.fud & blah[1].baz.fud)
+// 
 TEST_F(string_concatTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case003.json"));
 }
 
-// foo.(blah[0].baz.fud & none)
+// 
 TEST_F(string_concatTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case004.json"));
 }
 
-// foo.(none.here & blah[1].baz.fud)
+// 
 TEST_F(string_concatTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case005.json"));
 }
 
-// [1,2]&[3,4]
+// 
 TEST_F(string_concatTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case006.json"));
 }
 
-// [1,2]&3
+// 
 TEST_F(string_concatTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case007.json"));
 }
 
-// 1&2
+// 
 TEST_F(string_concatTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case008.json"));
 }
 
-// 1&[2]
+// 
 TEST_F(string_concatTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case009.json"));
 }
 
-// \"hello\"&5
+// 
 TEST_F(string_concatTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case010.json"));
 }
 
-// \"Prices: \" & Account.Order.Product.Price
+// 
 TEST_F(string_concatTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case011.json"));
 }
diff --git a/test/gen/tail_recursionTest.cpp b/test/gen/tail_recursionTest.cpp
index b4c669c..67bb5da 100644
--- a/test/gen/tail_recursionTest.cpp
+++ b/test/gen/tail_recursionTest.cpp
@@ -6,52 +6,52 @@ using namespace jsonata;
 class tail_recursionTest : public JsonataTest {
 };
 
-//             (              $f := function($n){()};              $f(1)            ) 
+// 
 TEST_F(tail_recursionTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case000.json"));
 }
 
-// (  $factorial := function($n){$n = 0 ? 1 : $n * $factorial($n - 1)};  $factorial(99))             
+// 
 TEST_F(tail_recursionTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case001.json"));
 }
 
-// (  $factorial := function($n){$n = 0 ? 1 : $n * $factorial($n - 1)};  $factorial(100))             
+// 
 TEST_F(tail_recursionTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case002.json"));
 }
 
-// (  $factorial := function($n){(    $iter := function($n, $acc) {      $n = 0 ? $acc : $iter($n - 1, $n * $acc)    };    $iter($n, 1)  )};  $factorial(5)) 
+// 
 TEST_F(tail_recursionTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case003.json"));
 }
 
-// (  $factorial := function($n){(    $iter := function($n, $acc) {      $n = 0 ? $acc : $iter($n - 1, $n * $acc)    };    $iter($n, 1)  )};  $factorial(150)) 
+// 
 TEST_F(tail_recursionTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case004.json"));
 }
 
-// (  $inf := function($n){$n+$inf($n-1)};  $inf(5))
+// 
 TEST_F(tail_recursionTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case005.json"));
 }
 
-// (  $inf := function(){$inf()};  $inf())
+// 
 TEST_F(tail_recursionTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case006.json"));
 }
 
-//         (          $even := function($n) { $n = 0 ? true : $odd($n-1) };           $odd := function($n) { $n = 0 ? false : $even($n-1) };           $odd(6555)         )
+// 
 TEST_F(tail_recursionTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case007.json"));
 }
 
-// ($f := function($s, $x)<an:s> { $x > 0 ? $f([$s, $s], $x-1) : $s};  $f('a', 2)  )
+// 
 TEST_F(tail_recursionTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case008.json"));
 }
 
-// ($f := function($s, $x)<sn:s> { $x > 0 ? $f([$s, $s], $x-1) : $s};  $f('a', 2)  )
+// 
 TEST_F(tail_recursionTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case009.json"));
 }
diff --git a/test/gen/token_conversionTest.cpp b/test/gen/token_conversionTest.cpp
index 89c9187..c6f874d 100644
--- a/test/gen/token_conversionTest.cpp
+++ b/test/gen/token_conversionTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class token_conversionTest : public JsonataTest {
 };
 
-// $.'7a'
+// 
 TEST_F(token_conversionTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case000.json"));
 }
 
-// $.'7'
+// 
 TEST_F(token_conversionTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case001.json"));
 }
 
-// $.7a
+// 
 TEST_F(token_conversionTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case002.json"));
 }
 
-// $.7
+// 
 TEST_F(token_conversionTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case003.json"));
 }
diff --git a/test/gen/transformTest.cpp b/test/gen/transformTest.cpp
index c753ec4..982ab28 100644
--- a/test/gen/transformTest.cpp
+++ b/test/gen/transformTest.cpp
@@ -6,522 +6,522 @@ using namespace jsonata;
 class transformTest : public JsonataTest {
 };
 
-// {'Order': Account.Order.{  'ID': OrderID,  'Product': Product.{    'SKU': ProductID,    'Details': {      'Weight': Description.Weight,      'Dimensions': Description.(Width & ' x ' & Height & ' x ' & Depth)    }  },  'Total Price': $sum(Product.(Price * Quantity))}}
+// 
 TEST_F(transformTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case000.json"));
 }
 
-//          (           $tempReadings := $count(state.tempReadings) = 5 ?               [state.tempReadings[[1..4]], event.t] :               [state.tempReadings, event.t];                    {             \"tempReadings\": $tempReadings,             \"sumTemperatures\": $sum($tempReadings),             \"avgTemperature\": $average($tempReadings) ~> $round(2),             \"maxTemperature\": $max($tempReadings),             \"minTemperature\": $min($tempReadings)           }         )
+// 
 TEST_F(transformTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case001.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case002.json"));
 }
 
-// foo
+// 
 TEST_F(transformTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case003.json"));
 }
 
-// baz
+// 
 TEST_F(transformTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case004.json"));
 }
 
-// Foo
+// 
 TEST_F(transformTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case005.json"));
 }
 
-// food
+// 
 TEST_F(transformTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case006.json"));
 }
 
-// maz.rar
+// 
 TEST_F(transformTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case007.json"));
 }
 
-// jee.par.waa
+// 
 TEST_F(transformTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case008.json"));
 }
 
-// foo
+// 
 TEST_F(transformTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case009.json"));
 }
 
-// foo.bar
+// 
 TEST_F(transformTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case010.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case011.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case012.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case013.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case014.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case015.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case016.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case017.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case018.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case019.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case020.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case021.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case022.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case023.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case024.json"));
 }
 
-// bar
+// 
 TEST_F(transformTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case025.json"));
 }
 
-// $
+// 
 TEST_F(transformTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case026.json"));
 }
 
-// $lowercase(Salutation)
+// 
 TEST_F(transformTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case027.json"));
 }
 
-// $lowercase(敷)
+// 
 TEST_F(transformTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case028.json"));
 }
 
-// $lowercase(Español)
+// 
 TEST_F(transformTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case029.json"));
 }
 
-// $lowercase($.\"NI.Number\")
+// 
 TEST_F(transformTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case030.json"));
 }
 
-// $lowercase(\"COMPENSATION IS : \" & Employment.\"Executive.Compensation\")
+// 
 TEST_F(transformTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case031.json"));
 }
 
-// \"Hello\"
+// 
 TEST_F(transformTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case032.json"));
 }
 
-// $uppercase(Salutation)
+// 
 TEST_F(transformTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case033.json"));
 }
 
-// $uppercase(\"Hello World\")
+// 
 TEST_F(transformTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case034.json"));
 }
 
-// $uppercase(\"鯵噂ソ竹\")
+// 
 TEST_F(transformTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case035.json"));
 }
 
-// Employment.Name & \" is happy\"
+// 
 TEST_F(transformTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case036.json"));
 }
 
-// Employment.Name & \" is pleased to employ \" & Salutation & \" \" & Surname
+// 
 TEST_F(transformTest, case037) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case037.json"));
 }
 
-// $uppercase(\"Hello \" & Salutation & \" \" & Surname)
+// 
 TEST_F(transformTest, case038) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case038.json"));
 }
 
-// $uppercase(Salutation & \" \" & Surname & \" - has \" & Cars & \" registered cars\")
+// 
 TEST_F(transformTest, case039) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case039.json"));
 }
 
-// $uppercase(Employment.ContractType)
+// 
 TEST_F(transformTest, case040) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case040.json"));
 }
 
-// $substringBefore(\"Hola\", \"l\")
+// 
 TEST_F(transformTest, case041) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case041.json"));
 }
 
-// $substringBefore(\"Hola\", 'l')
+// 
 TEST_F(transformTest, case042) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case042.json"));
 }
 
-// $substringBefore(\"Hola\", \"Q\")
+// 
 TEST_F(transformTest, case043) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case043.json"));
 }
 
-// $substringBefore(\"Hola\", \"\")
+// 
 TEST_F(transformTest, case044) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case044.json"));
 }
 
-// $substringBefore(\"鯵噂ソ竹\", \"ソ\")
+// 
 TEST_F(transformTest, case045) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case045.json"));
 }
 
-// $substringAfter(\"Coca\" & \"Cola\", \"ca\")
+// 
 TEST_F(transformTest, case046) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case046.json"));
 }
 
-// $substringAfter(Salutation & \" \" & MiddleName &\" \" & Surname, MiddleName)
+// 
 TEST_F(transformTest, case047) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case047.json"));
 }
 
-// $substringAfter(Salutation & \" \" & Employment.Role, Salutation)
+// 
 TEST_F(transformTest, case048) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case048.json"));
 }
 
-// $substringAfter(\"Hola\", 'l')
+// 
 TEST_F(transformTest, case049) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case049.json"));
 }
 
-// $substringAfter(\"Hola\", \"Q\")
+// 
 TEST_F(transformTest, case050) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case050.json"));
 }
 
-// $lowercase(Employment.Role) & \" (\" & Employment.Role & \")\"
+// 
 TEST_F(transformTest, case051) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case051.json"));
 }
 
-// Employment.Years & \" years of employment\"
+// 
 TEST_F(transformTest, case052) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case052.json"));
 }
 
-// $uppercase(Salutation & \" \" & Surname & \" - has \" & Employment.Years & \" years of employment\")
+// 
 TEST_F(transformTest, case053) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case053.json"));
 }
 
-// $substring(Employment.Role, 7,4)
+// 
 TEST_F(transformTest, case054) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case054.json"));
 }
 
-// $substring(Employment.Role, -4,4)
+// 
 TEST_F(transformTest, case055) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case055.json"));
 }
 
-// $substring(\"Hello World\",Cars,5)
+// 
 TEST_F(transformTest, case056) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case056.json"));
 }
 
-// $lowercase(\"Missing close brackets\"
+// 
 TEST_F(transformTest, case057) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case057.json"));
 }
 
-// $unknown(Salutation)
+// 
 TEST_F(transformTest, case058) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case058.json"));
 }
 
-// $decrypt(Salutation)
+// 
 TEST_F(transformTest, case059) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case059.json"));
 }
 
-// Employment.authentication(Salutation)
+// 
 TEST_F(transformTest, case060) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case060.json"));
 }
 
-// $uppercase(Invalid)
+// 
 TEST_F(transformTest, case061) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case061.json"));
 }
 
-// $uppercase(Employment.Invalid)
+// 
 TEST_F(transformTest, case062) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case062.json"));
 }
 
-// $lowercase(\"Coca\", \"Cola\")
+// 
 TEST_F(transformTest, case063) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case063.json"));
 }
 
-// $lowercase(Salary)
+// 
 TEST_F(transformTest, case064) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case064.json"));
 }
 
-// $lowercase(20)
+// 
 TEST_F(transformTest, case065) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case065.json"));
 }
 
-// $lowercase(20.55)
+// 
 TEST_F(transformTest, case066) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case066.json"));
 }
 
-// $lowercase(Employment)
+// 
 TEST_F(transformTest, case067) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case067.json"));
 }
 
-// $lowercase(Qualifications)
+// 
 TEST_F(transformTest, case068) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case068.json"));
 }
 
-// $uppercase(\"Coca\", \"Cola\")
+// 
 TEST_F(transformTest, case069) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case069.json"));
 }
 
-// $uppercase(Salary)
+// 
 TEST_F(transformTest, case070) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case070.json"));
 }
 
-// $uppercase(28)
+// 
 TEST_F(transformTest, case071) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case071.json"));
 }
 
-// $uppercase(20.55)
+// 
 TEST_F(transformTest, case072) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case072.json"));
 }
 
-// $uppercase(Cars)
+// 
 TEST_F(transformTest, case073) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case073.json"));
 }
 
-// $uppercase(Employment)
+// 
 TEST_F(transformTest, case074) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case074.json"));
 }
 
-// $uppercase(Qualifications)
+// 
 TEST_F(transformTest, case075) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case075.json"));
 }
 
-// $substringBefore(\"Coca\" & \"ca\")
+// 
 TEST_F(transformTest, case076) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case076.json"));
 }
 
-// $substringBefore(Salary,\"xx\")
+// 
 TEST_F(transformTest, case077) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case077.json"));
 }
 
-// $substringBefore(22,\"xx\")
+// 
 TEST_F(transformTest, case078) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case078.json"));
 }
 
-// $substringBefore(22.55,\"xx\")
+// 
 TEST_F(transformTest, case079) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case079.json"));
 }
 
-// $substringBefore(\"22\",2)
+// 
 TEST_F(transformTest, case080) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case080.json"));
 }
 
-// $substringBefore(\"22.55\",5)
+// 
 TEST_F(transformTest, case081) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case081.json"));
 }
 
-// $substringBefore(Employment,\"xx\")
+// 
 TEST_F(transformTest, case082) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case082.json"));
 }
 
-// $substringBefore(Qualifications,\"xx\")
+// 
 TEST_F(transformTest, case083) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case083.json"));
 }
 
-// $substringAfter(\"Coca\" & \"ca\")
+// 
 TEST_F(transformTest, case084) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case084.json"));
 }
 
-// $substringAfter(Salary,\"xx\")
+// 
 TEST_F(transformTest, case085) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case085.json"));
 }
 
-// $substringAfter(22,\"xx\")
+// 
 TEST_F(transformTest, case086) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case086.json"));
 }
 
-// $substringAfter(22.55,\"xx\")
+// 
 TEST_F(transformTest, case087) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case087.json"));
 }
 
-// $substringAfter(\"22\",2)
+// 
 TEST_F(transformTest, case088) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case088.json"));
 }
 
-// $substringAfter(\"22.55\",5)
+// 
 TEST_F(transformTest, case089) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case089.json"));
 }
 
-// $substringAfter(Employment,\"xx\")
+// 
 TEST_F(transformTest, case090) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case090.json"));
 }
 
-// $substringAfter(Qualifications,\"xx\")
+// 
 TEST_F(transformTest, case091) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case091.json"));
 }
 
-// $substring(\"Coca\" & \"ca\", 2, 4, 5)
+// 
 TEST_F(transformTest, case092) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case092.json"));
 }
 
-// $substring(\"Coca\", \"Mr\", 4)
+// 
 TEST_F(transformTest, case093) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case093.json"));
 }
 
-// $substring(\"Coca\", 3, \"Whoops\")
+// 
 TEST_F(transformTest, case094) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case094.json"));
 }
 
-// $substring(Salary,2,4)
+// 
 TEST_F(transformTest, case095) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case095.json"));
 }
 
-// $substring(\"Hello\",\"World\",5)
+// 
 TEST_F(transformTest, case096) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case096.json"));
 }
 
-// $substring(\"Hello\",5,\"World\")
+// 
 TEST_F(transformTest, case097) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case097.json"));
 }
 
-// $substring(\"Hello World\",5.5,5)
+// 
 TEST_F(transformTest, case098) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case098.json"));
 }
 
-// $substring(Employment,\"xx\")
+// 
 TEST_F(transformTest, case099) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case099.json"));
 }
 
-// $substring(Qualifications,6,5)
+// 
 TEST_F(transformTest, case100) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case100.json"));
 }
 
-// detail.contents
+// 
 TEST_F(transformTest, case101) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case101.json"));
 }
 
-// detail.meta
+// 
 TEST_F(transformTest, case102) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case102.json"));
 }
 
-// detail.meta
+// 
 TEST_F(transformTest, case103) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case103.json"));
 }
diff --git a/test/gen/transformsTest.cpp b/test/gen/transformsTest.cpp
index fcbef0a..7197399 100644
--- a/test/gen/transformsTest.cpp
+++ b/test/gen/transformsTest.cpp
@@ -6,77 +6,77 @@ using namespace jsonata;
 class transformsTest : public JsonataTest {
 };
 
-// $ ~> |Account.Order.Product|{\"Total\":Price*Quantity},[\"Description\", \"SKU\"]|
+// 
 TEST_F(transformsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case000.json"));
 }
 
-// Account.Order ~> |Product|{\"Total\":Price*Quantity},[\"Description\", \"SKU\"]|
+// 
 TEST_F(transformsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case001.json"));
 }
 
-// $ ~> |Account.Order.Product|{\"Total\":Price*Quantity, \"Price\": Price * 1.2}|
+// 
 TEST_F(transformsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case002.json"));
 }
 
-// $ ~> |Account.Order.Product|{},\"Description\"|
+// 
 TEST_F(transformsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case003.json"));
 }
 
-// $ ~> |Account.Order.Product|nomatch,\"Description\"|
+// 
 TEST_F(transformsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case004.json"));
 }
 
-// $ ~> |(Account.Order.Product)[0]|{\"Description\":\"blah\"}|
+// 
 TEST_F(transformsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case005.json"));
 }
 
-// $ ~> |foo.bar|{\"Description\":\"blah\"}|
+// 
 TEST_F(transformsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case006.json"));
 }
 
-// Account ~> |Order|{\"Product\":\"blah\"},nomatch|
+// 
 TEST_F(transformsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case007.json"));
 }
 
-// foo ~> |foo.bar|{\"Description\":\"blah\"}|
+// 
 TEST_F(transformsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case008.json"));
 }
 
-// Account ~> |Order|5|
+// 
 TEST_F(transformsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case009.json"));
 }
 
-// Account ~> |Order|{},5|
+// 
 TEST_F(transformsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case010.json"));
 }
 
-// Account ~> |Order|{\"Product\":\"blah\"},nomatch|
+// 
 TEST_F(transformsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case011.json"));
 }
 
-// {} ~> |$|['one', 'two', 'three']|
+// 
 TEST_F(transformsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case012.json"));
 }
 
-// $ ~> | ** ['hi'] | {'hello': hi}, ['hi'] |
+// 
 TEST_F(transformsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case013.json"));
 }
 
-// $ ~> | ** [hi] | {'hello': hi}, ['hi'] |
+// 
 TEST_F(transformsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case014.json"));
 }
diff --git a/test/gen/variablesTest.cpp b/test/gen/variablesTest.cpp
index 3ceff4f..a0f07f4 100644
--- a/test/gen/variablesTest.cpp
+++ b/test/gen/variablesTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class variablesTest : public JsonataTest {
 };
 
-// $price.foo.bar
+// 
 TEST_F(variablesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case000.json"));
 }
 
-// $price.foo.bar
+// 
 TEST_F(variablesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case001.json"));
 }
 
-// $var[1]
+// 
 TEST_F(variablesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case002.json"));
 }
 
-// $.foo.bar
+// 
 TEST_F(variablesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case003.json"));
 }
 
-// $a := 5
+// 
 TEST_F(variablesTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case004.json"));
 }
 
-// $a := $b := 5
+// 
 TEST_F(variablesTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case005.json"));
 }
 
-// ($a := $b := 5; $a)
+// 
 TEST_F(variablesTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case006.json"));
 }
 
-// ($a := $b := 5; $b)
+// 
 TEST_F(variablesTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case007.json"));
 }
 
-// ( $a := 5; $a := $a + 2; $a )
+// 
 TEST_F(variablesTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case008.json"));
 }
 
-// [1,2,3].$v
+// 
 TEST_F(variablesTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case009.json"));
 }
 
-// ( $foo := \"defined\"; ( $foo := nothing ); $foo )
+// 
 TEST_F(variablesTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case010.json"));
 }
 
-// ( $foo := \"defined\"; ( $foo := nothing; $foo ) )
+// 
 TEST_F(variablesTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case011.json"));
 }
 
-// ($a := [1,2]; $a[1]:=3; $a)
+// 
 TEST_F(variablesTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case012.json"));
 }
diff --git a/test/gen/wildcardsTest.cpp b/test/gen/wildcardsTest.cpp
index 5dfeb9c..5e485ca 100644
--- a/test/gen/wildcardsTest.cpp
+++ b/test/gen/wildcardsTest.cpp
@@ -6,52 +6,52 @@ using namespace jsonata;
 class wildcardsTest : public JsonataTest {
 };
 
-// foo.*
+// 
 TEST_F(wildcardsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case000.json"));
 }
 
-// foo.*.baz
+// 
 TEST_F(wildcardsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case001.json"));
 }
 
-// foo.*.bazz
+// 
 TEST_F(wildcardsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case002.json"));
 }
 
-// foo.*.baz.*
+// 
 TEST_F(wildcardsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case003.json"));
 }
 
-// foo.*.baz.*
+// 
 TEST_F(wildcardsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case004.json"));
 }
 
-// foo.*.baz.*
+// 
 TEST_F(wildcardsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case005.json"));
 }
 
-// *[type=\"home\"]
+// 
 TEST_F(wildcardsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case006.json"));
 }
 
-// Account[$$.Account.\"Account Name\" = \"Firefly\"].*[OrderID=\"order104\"].Product.Price
+// 
 TEST_F(wildcardsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case007.json"));
 }
 
-// Account[$$.Account.`Account Name` = \"Firefly\"].*[OrderID=\"order104\"].Product.Price
+// 
 TEST_F(wildcardsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case008.json"));
 }
 
-// *
+// 
 TEST_F(wildcardsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case009.json"));
 }

From 6ee6620808330a8c647afcacf0bad1eb7422a2fb Mon Sep 17 00:00:00 2001
From: wim delvaux <wim.delvaux@adaptiveplanet.com>
Date: Wed, 13 May 2026 12:21:05 +0200
Subject: [PATCH 4/7] compiles with nlohmann qjson and qvariant

---
 CMakeLists.txt                               |  75 +--
 include/jsonata/Jsonata.h                    |   8 +-
 include/jsonata/backend.h                    | 675 +++++++++++--------
 include/jsonata/common_backend.h             |  53 +-
 include/jsonata/nlohmann_backend.h           | 129 ++--
 include/jsonata/qtjson_backend.h             | 487 ++-----------
 include/jsonata/qtvariant_backend.h          | 423 +++++++++++-
 src/jsonata/Jsonata.cpp                      |  98 ++-
 test/Generate.cpp                            |   1 +
 test/JsonataTest.cpp                         |  22 +-
 test/gen/array_constructorTest.cpp           |  68 +-
 test/gen/blocksTest.cpp                      |  14 +-
 test/gen/boolean_expresssionsTest.cpp        |  62 +-
 test/gen/closuresTest.cpp                    |   4 +-
 test/gen/coalescing_operatorTest.cpp         |  26 +-
 test/gen/comparison_operatorsTest.cpp        | 154 ++++-
 test/gen/conditionalsTest.cpp                |  18 +-
 test/gen/contextTest.cpp                     |   8 +-
 test/gen/default_operatorTest.cpp            |  28 +-
 test/gen/descendent_operatorTest.cpp         |  34 +-
 test/gen/encodingTest.cpp                    |   8 +-
 test/gen/errorsTest.cpp                      |  54 +-
 test/gen/fieldsTest.cpp                      |  16 +-
 test/gen/flatteningTest.cpp                  | 167 +++--
 test/gen/function_absTest.cpp                |   8 +-
 test/gen/function_appendTest.cpp             |  12 +-
 test/gen/function_applicationsTest.cpp       |  44 +-
 test/gen/function_assertTest.cpp             |  16 +-
 test/gen/function_averageTest.cpp            |  26 +-
 test/gen/function_booleanTest.cpp            |  48 +-
 test/gen/function_ceilTest.cpp               |   8 +-
 test/gen/function_containsTest.cpp           |  14 +-
 test/gen/function_countTest.cpp              |  28 +-
 test/gen/function_decodeUrlComponentTest.cpp |   6 +-
 test/gen/function_decodeUrlTest.cpp          |   6 +-
 test/gen/function_distinctTest.cpp           |  41 +-
 test/gen/function_eachTest.cpp               |   6 +-
 test/gen/function_encodeUrlComponentTest.cpp |   4 +-
 test/gen/function_encodeUrlTest.cpp          |   4 +-
 test/gen/function_errorTest.cpp              |  22 +-
 test/gen/function_evalTest.cpp               |  37 +-
 test/gen/function_existsTest.cpp             |  50 +-
 test/gen/function_floorTest.cpp              |   8 +-
 test/gen/function_formatBaseTest.cpp         |  16 +-
 test/gen/function_formatIntegerTest.cpp      | 326 ++++++++-
 test/gen/function_formatNumberTest.cpp       |  74 +-
 test/gen/function_fromMillisTest.cpp         | 458 ++++++++++++-
 test/gen/function_joinTest.cpp               |  24 +-
 test/gen/function_keysTest.cpp               |  14 +-
 test/gen/function_lengthTest.cpp             |  34 +-
 test/gen/function_lookupTest.cpp             |   8 +-
 test/gen/function_lowercaseTest.cpp          |   4 +-
 test/gen/function_maxTest.cpp                |  54 +-
 test/gen/function_mergeTest.cpp              |  10 +-
 test/gen/function_numberTest.cpp             |  68 +-
 test/gen/function_padTest.cpp                |  26 +-
 test/gen/function_parseIntegerTest.cpp       | 306 ++++++++-
 test/gen/function_powerTest.cpp              |  14 +-
 test/gen/function_replaceTest.cpp            |  24 +-
 test/gen/function_reverseTest.cpp            |   8 +-
 test/gen/function_roundTest.cpp              |  36 +-
 test/gen/function_shuffleTest.cpp            |   8 +-
 test/gen/function_siftTest.cpp               |  10 +-
 test/gen/function_signaturesTest.cpp         |  70 +-
 test/gen/function_sortTest.cpp               |  22 +-
 test/gen/function_splitTest.cpp              |  38 +-
 test/gen/function_spreadTest.cpp             |   8 +-
 test/gen/function_sqrtTest.cpp               |   8 +-
 test/gen/function_stringTest.cpp             |  60 +-
 test/gen/function_substringAfterTest.cpp     |  10 +-
 test/gen/function_substringBeforeTest.cpp    |  10 +-
 test/gen/function_substringTest.cpp          |  38 +-
 test/gen/function_sumTest.cpp                |  14 +-
 test/gen/function_tomillisTest.cpp           | 257 ++++++-
 test/gen/function_trimTest.cpp               |   6 +-
 test/gen/function_typeOfTest.cpp             |  26 +-
 test/gen/function_uppercaseTest.cpp          |   4 +-
 test/gen/function_zipTest.cpp                |  12 +-
 test/gen/higher_order_functionsTest.cpp      |   6 +-
 test/gen/hof_filterTest.cpp                  |   8 +-
 test/gen/hof_mapTest.cpp                     |  24 +-
 test/gen/hof_reduceTest.cpp                  |  18 +-
 test/gen/hof_singleTest.cpp                  |  22 +-
 test/gen/hof_zip_mapTest.cpp                 |   8 +-
 test/gen/inclusion_operatorTest.cpp          |  18 +-
 test/gen/joinsTest.cpp                       | 211 +++++-
 test/gen/lambdasTest.cpp                     |  28 +-
 test/gen/literalsTest.cpp                    |  61 +-
 test/gen/matchersTest.cpp                    |   2 +-
 test/gen/missing_pathsTest.cpp               |  12 +-
 test/gen/multiple_array_selectorsTest.cpp    |   6 +-
 test/gen/nullTest.cpp                        |  14 +-
 test/gen/numeric_operatorsTest.cpp           |  38 +-
 test/gen/object_constructorTest.cpp          |  52 +-
 test/gen/parent_operatorTest.cpp             | 218 +++++-
 test/gen/parenthesesTest.cpp                 |  16 +-
 test/gen/partial_applicationTest.cpp         |  10 +-
 test/gen/performanceTest.cpp                 |   4 +-
 test/gen/predicatesTest.cpp                  |   8 +-
 test/gen/quoted_selectorsTest.cpp            |  16 +-
 test/gen/range_operatorTest.cpp              |  50 +-
 test/gen/regexTest.cpp                       |  78 +--
 test/gen/simple_array_selectorsTest.cpp      |  46 +-
 test/gen/sortingTest.cpp                     |  42 +-
 test/gen/string_concatTest.cpp               |  24 +-
 test/gen/tail_recursionTest.cpp              |  20 +-
 test/gen/token_conversionTest.cpp            |   8 +-
 test/gen/transformTest.cpp                   | 208 +++---
 test/gen/transformsTest.cpp                  |  30 +-
 test/gen/variablesTest.cpp                   |  26 +-
 test/gen/wildcardsTest.cpp                   |  20 +-
 111 files changed, 4283 insertions(+), 2194 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0d62dd8..1347fd7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,45 +10,32 @@ set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-option(JSONATA_NLOHMANN_BACKEND "Build qjsonata with nlohmann json backend" OFF)
-option(JSONATA_QTJSON_BACKEND "Build qjsonata with Qt json backend" OFF)
-option(JSONATA_QTVARIANT_BACKEND "Build qjsonata with Qt QVariant backend" OFF)
-
 include(GNUInstallDirs)
 include(FetchContent)
 
 set( JSONATA_ENABLED_BACKENDS )
 
-if( JSONATA_NLOHMANN_BACKEND )
-    # Find nlohmann_json or fetch if not found
-    find_package(nlohmann_json CONFIG QUIET)
-    if(NOT nlohmann_json_FOUND)
-        FetchContent_Declare(
-            nlohmann_json
-            GIT_REPOSITORY https://github.com/nlohmann/json.git
-            GIT_TAG        v3.12.0
-        )
-        FetchContent_MakeAvailable(nlohmann_json)
-        # Mark that we used FetchContent
-        set(JSONATA_USED_FETCHCONTENT_JSON TRUE)
-    endif()
-    list( APPEND JSONATA_ENABLED_BACKENDS nlohmann::unordered_json nlohmann::json )
+# Find nlohmann_json or fetch if not found
+find_package(nlohmann_json CONFIG QUIET)
+if(NOT nlohmann_json_FOUND)
+    FetchContent_Declare(
+        nlohmann_json
+        GIT_REPOSITORY https://github.com/nlohmann/json.git
+        GIT_TAG        v3.12.0
+    )
+    FetchContent_MakeAvailable(nlohmann_json)
+    # Mark that we used FetchContent
+    set(JSONATA_USED_FETCHCONTENT_JSON TRUE)
+    list( APPEND JSONATA_ENABLED_BACKENDS nlohmann::ordered_json nlohmann::json )
     set( JSONATA_NLOHMANN_ENABLED true )
 endif()
 
-if( JSONATA_QTJSON_BACKEND OR JSONATA_QTVARIANT_BACKEND )
-    find_package(Qt6 REQUIRED COMPONENTS Core)
-    if(NOT Qt6_FOUND)
-        error( "Cannot find Qt >=6.10" )
-    endif()
-    if( JSONATA_QTJSON_BACKEND  )
-        list( APPEND JSONATA_ENABLED_BACKENDS QJsonValue )
-        set( JSONATA_QTJSON_ENABLED true )
-    endif()
-    if( JSONATA_QTVARIANT_BACKEND )
-        list( APPEND JSONATA_ENABLED_BACKENDS QVariant )
-        set( JSONATA_QTVARIANT_ENABLED true )
-    endif()
+find_package(Qt6 QUIET COMPONENTS Core)
+if(Qt6_FOUND)
+    list( APPEND JSONATA_ENABLED_BACKENDS QJsonValue QVariant )
+    set( JSONATA_QT_ENABLED true )
+else()
+    warning( "Cannot find Qt >=6.10." )
 endif()
 
 # Collect source files
@@ -95,7 +82,7 @@ target_include_directories(qjsonata PUBLIC
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-if( JSONATA_NLOHMANN_BACKEND )
+if( JSONATA_NLOHMANN_ENABLED )
     # nlohmann_json is used from public headers, so propagate it PUBLIC.
     # Ensure the exported target only records the imported name in the install
     # interface to avoid referencing non-exported build targets.
@@ -115,17 +102,10 @@ if( JSONATA_NLOHMANN_BACKEND )
             $<INSTALL_INTERFACE:nlohmann_json::nlohmann_json>
         )
     endif()
-    target_compile_definitions(qjsonata PUBLIC JSONATA_NLOHMANN_ENABLED )
 endif()
 
-if( JSONATA_QTJSON_BACKEND OR JSONATA_QTVARIANT_BACKEND )
+if( JSONATA_QT_ENABLED )
     target_link_libraries(qjsonata PUBLIC Qt6::Core)
-    if( JSONATA_QTJSON_BACKEND )
-        target_compile_definitions(qjsonata PUBLIC JSONATA_QTJSON_ENABLED )
-    endif()
-    if( JSONATA_QTVARIANT_BACKEND )
-        target_compile_definitions(qjsonata PUBLIC JSONATA_QTVARIANT_ENABLED )
-    endif()
 endif()
 
 # Optionally build tests
@@ -173,8 +153,11 @@ if(JSONATA_BUILD_TESTS)
     add_executable(qgenerate test/Generate.cpp
         include/jsonata/backend.h)
     target_link_libraries(qgenerate qjsonata)
+    list(GET JSONATA_ENABLED_BACKENDS 0 FIRST_BACKEND)
+    target_compile_definitions(qgenerate PRIVATE
+        JSONATA_TEST_BACKEND=${FIRST_BACKEND}
+    )
 
-    # Create main test executables
     foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
         # 1. Strip the extension to create a clean executable name
         string(REPLACE "::" "_" CLEAN_BE ${BE})
@@ -197,10 +180,6 @@ if(JSONATA_BUILD_TESTS)
             gtest
             Threads::Threads
         )
-        # will select the last backend to test but we only need one to generate
-        target_compile_definitions(qgenerate PRIVATE
-            JSONATA_TEST_BACKEND=${BE}
-        )
     endforeach()
 
 
@@ -284,7 +263,7 @@ endif()
 
 # Installation rules
 if(JSONATA_USED_FETCHCONTENT_JSON)
-    if( JSONATA_NLOHMANN_BACKEND)
+    if( JSONATA_NLOHMANN_ENABLED )
         install(TARGETS qjsonata nlohmann_json
             EXPORT qjsonataTargets
             LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -292,7 +271,7 @@ if(JSONATA_USED_FETCHCONTENT_JSON)
             RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
             INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
         )
-endif()
+    endif()
 else()
     install(TARGETS qjsonata
         EXPORT qjsonataTargets
@@ -308,7 +287,7 @@ install(DIRECTORY third_party/utfcpp/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
 # Export targets for the install-tree
 install(EXPORT qjsonataTargets
-    FILE qjsonataTargets.cmake
+    FILE jsonataTargets.cmake
     NAMESPACE qjsonata::
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/qjsonata
 )
diff --git a/include/jsonata/Jsonata.h b/include/jsonata/Jsonata.h
index fca7841..794dee4 100644
--- a/include/jsonata/Jsonata.h
+++ b/include/jsonata/Jsonata.h
@@ -128,7 +128,7 @@ namespace jsonata
             Jsonata(const Jsonata &other); // Copy constructor for per-thread instances
 
             template <typename T>
-                requires isCompatible<T>
+                requires jsonata::isReadCompatible<T>
             static backend<T> parse( const std::string & s ) {
                 return wrap(T::parse( s ));
             }
@@ -446,7 +446,7 @@ namespace jsonata
             // Conversion helpers between engine types and JSON
             // Ordered variants preserve insertion order using jsonata::ordered_json
             template<typename T>
-                requires isCompatible<T>
+                requires jsonata::isReadCompatible<T>
             static std::any toAny(const T &jv)
             {
                 auto j = jsonata::backend(jv);
@@ -489,7 +489,7 @@ namespace jsonata
             }
 
             template<typename T>
-                requires isCompatible<T>
+                requires jsonata::isReadCompatible<T>
             static jsonata::backend<T> fromAny(const std::any &value)
             {
                 if (!value.has_value())
@@ -564,7 +564,7 @@ namespace jsonata
             }
 
             template<typename from, typename to >
-                requires isCompatible<from> && isCompatible<to>
+                requires jsonata::isReadCompatible<from> && jsonata::isReadCompatible<to>
             static to convert( const from & oj ) {
                 // Recursive lambda to convert ordered_json to json
                 std::function<to(const from & )> convert = [&](const from & j) -> to {
diff --git a/include/jsonata/backend.h b/include/jsonata/backend.h
index ee428a7..11a37dc 100644
--- a/include/jsonata/backend.h
+++ b/include/jsonata/backend.h
@@ -1,334 +1,474 @@
 #pragma once
 
-#include "jsonata/common_backend.h"
+#include <optional>
 #include <string>
 #include <type_traits>
-#include <optional>
-// test for existence of methods
-struct Anything
+
+#include "jsonata/common_backend.h"
+#include "jsonata/nlohmann_backend.h"
+#include "jsonata/qtjson_backend.h"
+#include "jsonata/qtvariant_backend.h"
+
+namespace jsonata
 {
-        // Implicit conversion to absolutely anything
-        template<typename T>
-        operator T() const;
-        // This allows the mock to stay 'active' when passed by reference
-        template<typename T>
-        operator T &() const;
-
-        // Also handle const references just in case
-        template<typename T>
-        operator const T &() const;
-};
-
-template<typename T>
-concept isBasicallyReadCompatible = requires(const T &ConstObj) {
-    json_bridge<T>::forAll(ConstObj, [](const std::string &, auto &) {});
-    json_bridge<T>::array();
-    json_bridge<T>::object();
-    json_bridge<T>::at(ConstObj, 1);
-    json_bridge<T>::dump(ConstObj);
-    json_bridge<T>::parse(std::string());
-    { json_bridge<T>::size(ConstObj) } -> std::same_as<size_t>;
-    { json_bridge<T>::isEmpty(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isObject(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isArray(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::contains(ConstObj, std::string()) } -> std::same_as<bool>;
-    { json_bridge<T>::isNull(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isBool(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isString(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isNumber(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isInteger(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isUnsignedInteger(ConstObj) } -> std::same_as<bool>;
-    { json_bridge<T>::isFloat(ConstObj) } -> std::same_as<bool>;
-    requires requires(Anything &property) {
-        { json_bridge<T>::getPropertyValueOfType(ConstObj, std::string(), property) } -> std::same_as<bool>;
+    // test for existence of methods
+    struct Anything
+    {
+            // Implicit conversion to absolutely anything
+            template<typename T>
+            operator T() const;
+            // This allows the mock to stay 'active' when passed by reference
+            template<typename T>
+            operator T &() const;
+
+            // Also handle const references just in case
+            template<typename T>
+            operator const T &() const;
     };
-    { json_bridge<T>::template get<Anything>(ConstObj) } -> std::same_as<Anything>;
-};
-
-template<typename T>
-concept isBasicallyWriteCompatible = isBasicallyReadCompatible<T> && requires(T &Obj ) {
-    json_bridge<T>::mutateForAll(Obj, [](const std::string &, auto &) {});
-    json_bridge<T>::appendValue(Obj, std::string(), Anything{} );
-    json_bridge<T>::set(Obj, std::string(), Anything{});
-    json_bridge<T>::pushBack(Obj, Anything{} );
-    { json_bridge<T>::create(std::string()) } -> std::same_as<T>;
-    { json_bridge<T>::create(1) } -> std::same_as<T>;
-    { json_bridge<T>::create(nullptr) } -> std::same_as<T>;
-    { json_bridge<T>::create() } -> std::same_as<T>;
-};
-
-// test for proper signalture of methods
-template<typename T>
-concept isReadCompatible = isBasicallyReadCompatible<T> && requires(const T &ConstObj) {
-    requires requires(std::string s, T &innerVal) {
-        json_bridge<T>::forAll(ConstObj, [](const std::string & key, auto & value) {
-            // This is the CRITICAL part:
-            // We force a compile-time check on the nested value
-            static_assert(isBasicallyWriteCompatible<std::remove_reference_t<decltype(value)>>);
-        });
+
+    template<typename T>
+    concept isBasicallyReadCompatible = requires(const T &ConstObj) {
+        json_bridge<T>::forAll(ConstObj, [](const std::string &, auto &) {});
+        json_bridge<T>::array();
+        json_bridge<T>::object();
+        json_bridge<T>::at(ConstObj, 1);
+        json_bridge<T>::dump(ConstObj);
+        json_bridge<T>::parse(std::string());
+        {
+            json_bridge<T>::size(ConstObj)
+        } -> std::same_as<size_t>;
+        {
+            json_bridge<T>::isEmpty(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::EQ(ConstObj, ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isObject(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isArray(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::contains(ConstObj, std::string())
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isNull(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isBool(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isString(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isNumber(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isInteger(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isUnsignedInteger(ConstObj)
+        } -> std::same_as<bool>;
+        {
+            json_bridge<T>::isFloat(ConstObj)
+        } -> std::same_as<bool>;
+        requires requires(Anything &property) {
+            {
+                json_bridge<T>::getPropertyValueOfType(ConstObj, std::string(), property)
+            } -> std::same_as<bool>;
+        };
+        {
+            json_bridge<T>::template get<Anything>(ConstObj)
+        } -> std::same_as<Anything>;
     };
-    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::parse(std::string()))>>;
-    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::at(ConstObj, std::string()))>>;
-    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::at(ConstObj, 1))>>;
-    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::array())>>;
-    isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::object())>>;
-
-    // To check recursive compatibility without crashing the compiler:
-    requires requires {
-        typename json_bridge<T>::is_json_bridge_type; // A simple tag
+
+    template<typename T>
+    concept isBasicallyWriteCompatible = isBasicallyReadCompatible<T> && requires(T &Obj) {
+        json_bridge<T>::mutateForAll(Obj, [](const std::string &, auto &) {});
+        json_bridge<T>::appendValue(Obj, std::string(), Anything{});
+        json_bridge<T>::set(Obj, std::string(), Anything{});
+        json_bridge<T>::pushBack(Obj, Anything{});
+        {
+            json_bridge<T>::create(std::string())
+        } -> std::same_as<T>;
+        {
+            json_bridge<T>::create(1)
+        } -> std::same_as<T>;
+        {
+            json_bridge<T>::create(nullptr)
+        } -> std::same_as<T>;
+        {
+            json_bridge<T>::create()
+        } -> std::same_as<T>;
     };
-};
-
-// test for proper signalture of methods
-template<typename T>
-concept isCompatible = isReadCompatible<T> &&
-                       isBasicallyWriteCompatible<T> && requires(T & Obj ) {
-    requires requires(std::string s, T &innerVal) {
-        json_bridge<T>::mutateForAll(Obj, [](const std::string & key, auto & value) {
-            // This is the CRITICAL part:
-            // We force a compile-time check on the nested value
-            static_assert(isBasicallyWriteCompatible<std::remove_reference_t<decltype(value)>>);
-        });
+
+    // test for proper signalture of methods
+    template<typename T>
+    concept isReadCompatible = isBasicallyReadCompatible<T> && requires(const T &ConstObj) {
+        requires requires(std::string s, T &innerVal) {
+            json_bridge<T>::forAll(ConstObj, [](const std::string & key, auto & value) {
+                // This is the CRITICAL part:
+                // We force a compile-time check on the nested value
+                static_assert(isBasicallyWriteCompatible<std::remove_reference_t<decltype(value)>>);
+            });
+        };
+        isBasicallyWriteCompatible<
+            std::remove_cvref_t<decltype(json_bridge<T>::parse(std::string()))>>;
+        isBasicallyWriteCompatible<
+            std::remove_cvref_t<decltype(json_bridge<T>::at(ConstObj, std::string()))>>;
+        isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::at(ConstObj, 1))>>;
+        isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::array())>>;
+        isBasicallyWriteCompatible<std::remove_cvref_t<decltype(json_bridge<T>::object())>>;
+
+        // To check recursive compatibility without crashing the compiler:
+        requires requires {
+            typename json_bridge<T>::is_json_bridge_type; // A simple tag
+        };
     };
-};
 
-namespace jsonata
-{
+    // test for proper signalture of methods
+    template<typename T>
+    concept isWriteCompatible =
+        isReadCompatible<T> && !std::is_const_v<T> && isBasicallyWriteCompatible<T>
+        && requires(T &Obj) {
+               requires requires(std::string s, T &innerVal) {
+                   json_bridge<T>::mutateForAll(Obj, [](const std::string & key, auto & value) {
+                       // This is the CRITICAL part:
+                       // We force a compile-time check on the nested value
+                       static_assert(
+                           isBasicallyWriteCompatible<std::remove_reference_t<decltype(value)>>);
+                   });
+               };
+           };
+
     template<typename T>
     struct backend;
-}
-
-// test to see of type T is of the form backend<X>
-template<typename T>
-struct extractBackendType {
-        using type = void;
-        static constexpr bool isBackend = false;
-};
-
-// Specialization for your backend
-template<typename X>
-struct extractBackendType<jsonata::backend<X>> {
-        using type = std::remove_cvref_t<X>;
-        static constexpr bool isBackend = true;
-};
-
-// test to see if T is of form backend<X> with isReadCompatible<X> (i.e X is const)
-template<typename T>
-concept isReadCompatibleBackend = [] {
-    using Extract = extractBackendType<std::remove_cvref_t<T>>;
-    if constexpr (Extract::isBackend) {
-        // Check if the inner type X is compatible
-        return isReadCompatible<typename Extract::type>;
-    }
-    return false;
-}();
-
-// test to see if T is of form backend<X> with isCompatible<X>
-template<typename T>
-concept isCompatibleBackend = [] {
-    using Extract = extractBackendType<std::remove_cvref_t<T>>;
-    if constexpr (Extract::isBackend) {
-        // Check if the inner type X is compatible
-        return isCompatible<typename Extract::type>;
-    }
-    return false;
-}();
 
-namespace jsonata
-{
+    // test to see of type T is of the form backend<X>
     template<typename T>
-    struct backend
+    struct extractBackendType
+    {
+            using type = void;
+            static constexpr bool isBackend = false;
+    };
+
+    // Specialization for your backend
+    template<typename X>
+    struct extractBackendType<jsonata::backend<X>>
     {
+            using type = std::remove_cvref_t<X>;
+            static constexpr bool isBackend = true;
+    };
 
+    // test to see if T is of form backend<X> with isReadCompatible<X> (i.e X is const)
+    template<typename T>
+    concept isReadCompatibleBackend = [] {
+        using Extract = extractBackendType<std::remove_cvref_t<T>>;
+        if constexpr (Extract::isBackend) {
+            // Check if the inner type X is compatible
+            return isReadCompatible<typename Extract::type>;
+        }
+        return false;
+    }();
+
+    // test to see if T is of form backend<X> with isWriteCompatible<X>
+    template<typename T>
+    concept isWriteCompatibleBackend = [] {
+        using Extract = extractBackendType<std::remove_cvref_t<T>>;
+        if constexpr (Extract::isBackend) {
+            // Check if the inner type X is compatible
+            return isWriteCompatible<typename Extract::type>;
+        }
+        return false;
+    }();
+
+    template<typename T>
+    struct backend
+    {
             // Use the base type for bridge lookups
             using BaseT = std::remove_cvref_t<T>;
 
-            // Use a conditional concept check
-            static constexpr bool mutatable_T = isCompatible<BaseT> && !std::is_const_v<T>;
-            static constexpr bool compatible_T = isReadCompatible<BaseT>;
-
-            backend() : val(nullptr) {}
-            backend(std::nullptr_t) : val(nullptr) {}
+            backend() {}
+            backend(std::nullptr_t) {}
 
-            backend(const backend&) = default;
-            backend(backend&&) noexcept = default;
+            backend(const backend &) = default;
+            backend(backend &&) noexcept = default;
 
             template<typename U>
             // Ensure U is compatible with T to avoid greedy matching
-                requires std::is_convertible_v<std::remove_reference_t<U>*, T*>
-            explicit backend(U&& v) noexcept : val(&v) {}
+                requires std::is_convertible_v<std::remove_reference_t<U> *, T *>
+            explicit backend(U &&v) noexcept
+                : val(std::forward<U>(v))
+            {}
 
             template<typename U>
             // Ensure U is compatible with T to avoid greedy matching
-                requires isCompatibleBackend<U>
-            explicit backend(U& v) noexcept : val(v.val) {}
+                requires isWriteCompatibleBackend<U>
+            explicit backend(U &v) noexcept
+                : val(v.val)
+            {}
 
             template<typename U>
-                requires (!std::is_convertible_v<std::remove_reference_t<U>*, T*>)
-            backend(U&& value) {
-                std::optional<T> owned; // To handle temporaries like 'create' results
+                requires(!std::is_convertible_v<std::remove_reference_t<U> *, T *>)
+            backend(U &&value)
+            {
                 // Use the bridge to turn the literal into a real JSON object
-                owned.emplace(json_bridge<BaseT>::create(std::forward<U>(value)));
-                val = &(*owned);
+                val.emplace(json_bridge<BaseT>::create(std::forward<U>(value)));
             }
 
-            operator T&() { return *val; }
-            operator const T&() const { return *val; }
+            operator T &() { return *val; }
+            operator const T &() const { return *val; }
 
             // to unwrap explicitely
             template<typename Self>
-            auto&& operator*(this Self&& self) {
+            auto &&operator*(this Self &&self)
+            {
                 return *self.val;
             }
 
-            static auto create( auto && value ) {
+            static auto create(auto &&value)
+            {
                 return wrap(json_bridge<BaseT>::create(std::forward<decltype(value)>(value)));
             }
 
-            static auto create() {
-                return wrap(json_bridge<BaseT>::create());
-            }
+            static auto create() { return wrap(json_bridge<BaseT>::create()); }
 
-            backend<T> & operator=( backend<T> && other ) {
-                val = other.val;
-                other.val = nullptr;
+            backend<T> &operator=(backend<T> &&other)
+            {
+                val = std::move(other.val);
                 return *this;
             }
 
-            backend<T> & operator=( const backend<T> & other ) {
+            backend<T> &operator=(const backend<T> &other)
+            {
                 val = other.val;
                 return *this;
             }
 
-            bool isEmpty() const requires compatible_T
+            bool isEmpty() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isEmpty(*val);
+                return val && json_bridge<BaseT>::isEmpty(*val);
             }
 
-            bool isObject() const requires compatible_T
+            bool isObject() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isObject(*val);
+                return val && json_bridge<BaseT>::isObject(*val);
             }
 
-            size_t size() const requires compatible_T
+            size_t size() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::size(*val);
+                return (val) ? json_bridge<BaseT>::size(*val) : 0;
             }
 
-            bool isArray() const requires compatible_T
+            bool isArray() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isArray(*val);
+                return val && json_bridge<BaseT>::isArray(*val);
             }
 
-            bool contains(const std::string &k) const requires compatible_T
+            bool contains(const std::string &k) const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::contains(*val, k);
+                return val && json_bridge<BaseT>::contains(*val, k);
             }
 
-            bool isString() const requires compatible_T
+            bool isString() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isString(*val);
+                return val && json_bridge<BaseT>::isString(*val);
             }
 
-            bool isNull() const requires compatible_T
+            bool isNull() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isNull(*val);
+                return !val || json_bridge<BaseT>::isNull(*val);
             }
 
-            bool isBool() const requires compatible_T
+            bool isBool() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isBool(*val);
+                return val && json_bridge<BaseT>::isBool(*val);
             }
 
-            bool isNumber() const requires compatible_T
+            bool isNumber() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isNumber(*val);
+                return val && json_bridge<BaseT>::isNumber(*val);
             }
 
-            bool isInteger() const requires compatible_T
+            bool isInteger() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isInteger(*val);
+                return val && json_bridge<BaseT>::isInteger(*val);
             }
 
-            bool isFloat() const requires compatible_T
+            bool isFloat() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isFloat(*val);
+                return val && json_bridge<BaseT>::isFloat(*val);
             }
 
-            bool isUnsignedInteger() const requires compatible_T
+            bool isUnsignedInteger() const
+                requires isReadCompatible<BaseT>
             {
-                return json_bridge<BaseT>::isUnsignedInteger(*val);
+                return val && json_bridge<BaseT>::isUnsignedInteger(*val);
             }
 
-            // Transparently forward the size call to your static bridge
-            auto at(auto key) requires compatible_T {
+            auto at(auto key)
+                requires isReadCompatible<BaseT>
+            {
+                if (!val) {
+                    throw "Backend has no value";
+                }
                 return wrap(json_bridge<BaseT>::at(*val, key));
             }
 
-            auto operator[](const std::string &k) const requires compatible_T
+            auto operator[](const std::string &k) const
+                requires isReadCompatible<BaseT>
             {
+                if (!val) {
+                    throw "Backend has no value";
+                }
                 return wrap(json_bridge<BaseT>::at(*val, k));
             }
 
-            auto operator[](int k) const requires compatible_T
+            auto operator[](int k) const
+                requires isReadCompatible<BaseT>
             {
+                if (!val) {
+                    throw "Backend has no value";
+                }
                 return wrap(json_bridge<BaseT>::at(*val, k));
             }
 
             template<typename outType>
-            outType get() const requires compatible_T
+            outType get() const
+                requires isReadCompatible<BaseT>
             {
+                if (!val) {
+                    throw "Backend has no value";
+                }
                 return json_bridge<BaseT>::template get<outType>(*val);
             }
 
-            static auto parse(const std::string &s) requires compatible_T
+            static auto parse(const std::string &s)
+                requires isReadCompatible<BaseT>
             {
                 return wrap(json_bridge<BaseT>::parse(s));
             }
 
             // apply action to all items in any type of collection allow mutation of value
-            void mutateForAll(auto action) requires mutatable_T
+            void mutateForAll(auto action)
+                requires isWriteCompatible<BaseT>
             {
-                json_bridge<BaseT>::mutateForAll(*val, action);
+                if (!val) {
+                    return;
+                }
+                json_bridge<BaseT>::mutateForAll(*val, [action](const std::string &k, T &val) {
+                    auto b = wrap(val);
+                    auto rv = action(k, b);
+                    if (rv) {
+                        val = *b;
+                    }
+                    return rv;
+                });
             }
 
             // apply action to all items in any type of collection
-            void forAll(auto action) const requires compatible_T
+            void forAll(auto action) const
+                requires isReadCompatible<BaseT>
             {
-                json_bridge<BaseT>::forAll(*val, action);
+                if (!val) {
+                    return;
+                }
+                json_bridge<BaseT>::forAll(*val, [action](const std::string &k, const T &val) {
+                    action(k, wrap(val));
+                });
             }
 
-            void set(const auto &key, auto value) requires mutatable_T
+            void set(const auto &key, auto value)
+                requires isWriteCompatible<BaseT>
             {
+                if (!val) {
+                    *this = std::move(object());
+                }
                 json_bridge<BaseT>::set(*val, key, value);
             }
 
-            std::string dump() const requires compatible_T
+            std::string dump() const
+                requires isReadCompatible<BaseT>
             {
+                if (!val) {
+                    return "";
+                }
                 return json_bridge<BaseT>::dump(*val);
             }
 
-            bool getPropertyValueOfType(const std::string &propertyName,
-                                        auto &propertyValue) const requires compatible_T
+            template<typename PropT>
+            bool getPropertyValueOfType(const std::string &propertyName, PropT &&propertyValue) const
+                requires isReadCompatible<BaseT>
             {
-                using PType = std::decay_t<decltype(propertyValue)>;
-                return json_bridge<BaseT>::template getPropertyValueOfType<PType>(*val, propertyName, propertyValue);
-            }
-
-            void push_back( auto value ) requires mutatable_T {
-                return json_bridge<BaseT>::pushBack( *val, value);
+                if (!val) {
+                    return false;
+                }
+                // 1. Detect if we are dealing with a TaggedProperty
+                if constexpr (isTaggedProperty_v<std::decay_t<PropT>>) {
+                    // 2. Extract the backend<T> object of the property and the Tag
+                    using Tag = typename std::decay_t<PropT>::tagType;
+
+                    // make sure if value in TaggedProperty std::optional, that it is initialized
+                    auto *dataPtr = ensureHasValue(propertyValue.value);
+
+                    if (!dataPtr->val) {
+                        // allocate val
+                        dataPtr->val = std::move(json_bridge<BaseT>::create());
+                    }
+
+                    // Repackage pointing to the T inside the backend's val pointer
+                    auto repackaged = TaggedProperty<BaseT, Tag>{*(dataPtr->val)};
+
+                    return json_bridge<BaseT>::getPropertyValueOfType(*val,
+                                                                      propertyName,
+                                                                      repackaged);
+                } else {
+                    auto *dataPtr = ensureHasValue(propertyValue);
+                    // Standard case for simple types
+                    return json_bridge<BaseT>::getPropertyValueOfType(*val, propertyName, *dataPtr);
+                }
+            }
+
+            void push_back(auto value)
+                requires isWriteCompatible<BaseT>
+            {
+                if (!val) {
+                    return;
+                }
+                return json_bridge<BaseT>::pushBack(*val, value);
             }
 
-            void appendValue( const std::string & K, auto value ) requires mutatable_T {
-                return json_bridge<BaseT>::appendValue( *val, K, value);
+            void appendValue(const std::string &K, auto value)
+                requires isWriteCompatible<BaseT>
+            {
+                if (!val) {
+                    return;
+                }
+                json_bridge<BaseT>::appendValue(*val, K, value);
             }
 
-            static auto array() requires compatible_T {
-                return wrap(json_bridge<BaseT>::array() );
+            static auto array()
+                requires isReadCompatible<BaseT>
+            {
+                return wrap(json_bridge<BaseT>::array());
             }
 
-            static auto object() requires compatible_T {
-                return wrap(json_bridge<BaseT>::object() );
+            static auto object()
+                requires isReadCompatible<BaseT>
+            {
+                return wrap(json_bridge<BaseT>::object());
             }
 
             static auto array(std::initializer_list<backend<T>> args);
@@ -336,26 +476,47 @@ namespace jsonata
             static auto object(std::initializer_list<std::pair<std::string, backend<T>>> args);
 
             // This allows: if (myJson != nullptr)
-            bool operator!=(std::nullptr_t) const
+            bool operator!=(std::nullptr_t) const { return !isNull(); }
+
+            bool operator==(std::nullptr_t) const { return isNull(); }
+
+            bool operator!=(const backend<T> &O) const
             {
-                return !isNull();
+                return ! json_bridge<BaseT>::EQ(*val, *(O.val));
             }
 
-            bool operator==(std::nullptr_t) const
+            bool operator==(const backend<T> &O) const
             {
-                return isNull();
+                return json_bridge<BaseT>::EQ(*val, *(O.val));
             }
-        private :
 
-            T * val;
+        private:
+            std::optional<BaseT> val;
+
+            template<typename AT>
+            static auto *ensureHasValue(AT &obj)
+            {
+                // If it's an optional, make sure it has a value
+                if constexpr (isOptional_v<AT>) {
+                    if (!obj.has_value()) {
+                        obj.emplace(); // Construct the data  inside the optional
+                    }
+                    return &(*obj);
+                } else {
+                    return &obj; // It's already a raw backend
+                }
+            }
 
             // Helper to wrap the result of doAt
-            static auto wrap(auto&& result) {
+            static auto wrap(auto &&result)
+            {
                 // We use remove_cvref_t to get the base type for the template
                 using RawType = std::remove_cvref_t<decltype(result)>;
                 // C++23 way to ensure we preserve the 'const' and 'reference' nature
                 // of the result exactly as it came out of the bridge
-                return backend<std::remove_reference_t<RawType>>(std::forward<decltype(result)>(result));            }
+                return backend<std::remove_reference_t<RawType>>(
+                    std::forward<decltype(result)>(result));
+            }
     };
 
     // Deduction guide to make it easy to use
@@ -363,7 +524,7 @@ namespace jsonata
     backend(T &) -> backend<T>;
 
     template<typename T>
-    backend(T*) -> backend<T>;
+    backend(T *) -> backend<T>;
 
     template<typename T>
     concept isPairLike = requires(T t) {
@@ -374,9 +535,8 @@ namespace jsonata
     };
 
     template<typename Container>
-    concept isMappedContainer = requires {
-        typename std::remove_cvref_t<Container>::value_type;
-    } && isPairLike<typename std::remove_cvref_t<Container>::value_type>;
+    concept isMappedContainer = requires { typename std::remove_cvref_t<Container>::value_type; }
+                                && isPairLike<typename std::remove_cvref_t<Container>::value_type>;
 
     template<typename List>
     concept isListContainer = !isMappedContainer<List>;
@@ -387,15 +547,15 @@ namespace jsonata
         using fromCollection = std::decay_t<decltype(from)>;
         using actionType = std::decay_t<decltype(action)>;
 
-        if constexpr ( isReadCompatible<fromCollection> ) {
-            jsonata::backend(from).forAll( action );
-        } else if constexpr ( isReadCompatibleBackend<fromCollection> ) {
-            from.forAll( action );
-        } else if constexpr ( isMappedContainer<fromCollection> ) {
+        if constexpr (isReadCompatible<fromCollection>) {
+            jsonata::backend(from).forAll(action);
+        } else if constexpr (isReadCompatibleBackend<fromCollection>) {
+            from.forAll(action);
+        } else if constexpr (isMappedContainer<fromCollection>) {
             for (const auto &[k, v] : from) {
                 action(k, v);
             }
-        } else if constexpr ( isListContainer<fromCollection>) {
+        } else if constexpr (isListContainer<fromCollection>) {
             int idx = 0;
             for (const auto &el : from) {
                 action(std::to_string(idx++), el);
@@ -408,31 +568,24 @@ namespace jsonata
 
     static void copy(const auto &from, auto &out)
     {
-
         forAll(from, [&out](auto k, auto v) {
             using outType = std::decay_t<decltype(out)>;
             using VType = std::decay_t<decltype(v)>;
             using KType = std::decay_t<decltype(k)>;
 
-            if constexpr (isCompatible<outType>) {
+            if constexpr (isWriteCompatible<outType>) {
                 backend(out).appendValue(k, v);
-            } else if constexpr (isCompatibleBackend<outType>) {
+            } else if constexpr (isWriteCompatibleBackend<outType>) {
                 out.appendValue(k, v);
-            } else if constexpr (isMappedContainer<outType> ) {
+            } else if constexpr (isMappedContainer<outType>) {
                 out[k] = v;
-            } else if constexpr (isListContainer<outType> ) {
+            } else if constexpr (isListContainer<outType>) {
                 out.push_back(v);
             } else {
                 // This triggers ONLY if none of the above branches are taken
-                static_assert(sizeof(outType) == 0,
-                              "Unsupported outCollection type: Must be initializer, Qt "
-                              "JSON, "
-                              "nlohmann JSON, a "
-                              "Map, or must "
-                              "support "
-                              "push"
-                              "_bac"
-                              "k.");
+                static_assert(
+                    sizeof(outType) == 0,
+                    "Unsupported outCollection type: Must be initializer, Qt " "JSON, " "nlohmann " "JSON, a " "Map, or must " "support " "push" "_bac" "k.");
             }
         });
     }
@@ -446,22 +599,19 @@ namespace jsonata
             using VType = std::decay_t<decltype(cv)>;
             using KType = std::decay_t<decltype(k)>;
 
-            if constexpr (isCompatible<outType>) {
+            if constexpr (isWriteCompatible<outType>) {
                 backend(out).appendValue(k, cv);
-            } else if constexpr (isCompatibleBackend<outType>) {
+            } else if constexpr (isWriteCompatibleBackend<outType>) {
                 out.appendValue(k, cv);
-            } else if constexpr ( isMappedContainer<outType> ) {
+            } else if constexpr (isMappedContainer<outType>) {
                 out[k] = convert(v);
-            } else if constexpr (isListContainer<outType> ) {
+            } else if constexpr (isListContainer<outType>) {
                 out.push_back(convert(v));
             } else {
                 // This triggers ONLY if none of the above branches are taken
-                static_assert(sizeof(outType) == 0,
-                              "Unsupported outCollection type: Must be Qt JSON, nlohmann "
-                              "JSON, "
-                              "a Map, or must "
-                              "support "
-                              "push_back.");
+                static_assert(
+                    sizeof(outType) == 0,
+                    "Unsupported outCollection type: Must be Qt JSON, nlohmann " "JSON, " "a Map, " "or must " "support " "push_back.");
             }
         });
     }
@@ -482,36 +632,3 @@ namespace jsonata
         return o;
     }
 } // namespace jsonata
-
-#include "nlohmann_backend.h"
-#include "qtjson_backend.h"
-#include "qtvariant_backend.h"
-
-
-// ordered_json ordered_json::array(std::initializer_list<ordered_json> args)
-// {
-//     ordered_json a = ordered_json::array();
-//     copy(args, a, [](const ordered_json &j) -> QJsonValue { return j; });
-//     return a;
-// }
-
-// ordered_json ordered_json::object(std::initializer_list<std::pair<std::string, ordered_json>> args)
-// {
-//     ordered_json o = ordered_json::object();
-//     copy(args, o, [](const ordered_json &j) { return j; });
-//     return o;
-// }
-
-// json json::array(std::initializer_list<json> args)
-// {
-//     json a = json::array();
-//     copy(args, a, [](const json &j) -> QJsonValue { return j; });
-//     return a;
-// }
-
-// json json::object(std::initializer_list<std::pair<std::string, json>> args)
-// {
-//     json o = json::object();
-//     copy(args, o, [](const json &j) { return j; });
-//     return o;
-// }
diff --git a/include/jsonata/common_backend.h b/include/jsonata/common_backend.h
index ccafeca..726c65d 100644
--- a/include/jsonata/common_backend.h
+++ b/include/jsonata/common_backend.h
@@ -16,9 +16,54 @@ template<typename T>
 concept isStdVector = is_vector<T>::value;
 
 // This is the "Contract" class which we will specify based on actual json classes (see qjson_backend e.a.)
-template<typename T>
-struct json_bridge {
-        // We leave this empty.
-        // Specializations will provide the actual logic.
+namespace jsonata
+{
+    template<typename T, typename Enable = void>
+    struct json_bridge_impl;
+
+    template<typename T, typename Enable>
+    struct json_bridge_impl {};
+
+    template<typename T>
+    using json_bridge =
+        json_bridge_impl<std::remove_cvref_t<T>,void>;
+}
+
+// for special conversion in getPropertyValueOfType
+template<typename T, typename Tag>
+struct TaggedProperty {
+        using valueType = T;
+        using tagType = Tag;
+        T& value;
 };
 
+// Convenience helpers
+struct AsArray {};
+
+template<typename T> auto Array(T& v) { return TaggedProperty<T, AsArray>{v}; }
+// use as x.getPropertyValueOfType( "name", Array(destination) );
+
+template<typename T> struct isTaggedProperty : std::false_type {};
+
+template<typename T, typename Tag>
+struct isTaggedProperty<TaggedProperty<T, Tag>> : std::true_type {};
+
+template<typename T>
+inline constexpr bool isTaggedProperty_v = isTaggedProperty<T>::value;
+
+#include <optional>
+#include <type_traits>
+
+// 1. The base case: any type that is NOT a std::optional
+template<typename T>
+struct isOptional : std::false_type {};
+
+// 2. The specialization: if the type is std::optional<U>, it matches this
+template<typename U>
+struct isOptional<std::optional<U>> : std::true_type {};
+
+// 3. The helper variable (the "_v" version)
+template<typename T>
+inline constexpr bool isOptional_v = isOptional<std::decay_t<T>>::value;
+
+
diff --git a/include/jsonata/nlohmann_backend.h b/include/jsonata/nlohmann_backend.h
index d229d32..dd5c780 100644
--- a/include/jsonata/nlohmann_backend.h
+++ b/include/jsonata/nlohmann_backend.h
@@ -1,86 +1,95 @@
 #pragma once
 
-#ifdef JSONATA_NLOHMANN_ENABLED
-
-#include "JException.h"
 #include "Utils.h"
-#include "common_backend.h"
 #include <concepts>
 
+#include "common_backend.h"
+
 #include <nlohmann/json.hpp>
-template<typename T>
-struct is_nlohmann : std::false_type
-{};
 
-template<typename... Args>
-struct is_nlohmann<nlohmann::basic_json<Args...>> : std::true_type
-{};
+#include <nlohmann/json.hpp>
+#include <type_traits>
+#include <concepts>
+
+template <typename T>
+concept isNlohmann = requires(T j) {
+        typename T::value_type;
+        { j.is_object() } -> std::same_as<bool>;
+        { j.is_array() } -> std::same_as<bool>;
+        // This is the "fingerprint" of a nlohmann-like container
+        T::array();
+    };
 
+namespace jsonata
+{
 // Single bridge specialization
 template<typename T>
-    requires is_nlohmann<T>::value
-struct json_bridge<T>
+    requires isNlohmann<T>
+struct json_bridge_impl<T,void>
 {
+        using BaseT = std::remove_cvref_t<T>;
         using is_json_bridge_type = void; // Tag to satisfy the concept
 
-        static T create(auto&& value) {
-            using V = std::remove_cvref_t<decltype(value)>;
+        static BaseT create(auto&& value) {
+            using V = std::decay_t<decltype(value)>;
 
             if constexpr (std::is_same_v<V, std::nullptr_t>) {
-                return T(QJsonValue::Null);
+                return BaseT();
             } else if constexpr (std::is_constructible_v<T, V>) {
-                return T(value);
+                return BaseT(value);
             } else {
                 static_assert(false, "Unsupported type for nlohmann creation");
             }
         }
 
-        static T create() { return T(); }
+        static BaseT create() { return BaseT(); }
 
-        static size_t size(const T &value) { return value.size(); }
+        static size_t size(const BaseT &value) { return value.size(); }
 
-        static bool isEmpty(const T &value) { return value.empty(); }
+        static bool isEmpty(const BaseT &value) { return value.empty(); }
 
-        static bool isObject(const T &value) { return value.is_object(); }
+        static bool isObject(const BaseT &value) { return value.is_object(); }
 
-        static bool isArray(const T &value) { return value.is_array(); }
+        static bool isArray(const BaseT &value) { return value.is_array(); }
 
-        static bool isNumber(const T &value) { return value.is_number(); }
+        static bool isNumber(const BaseT &value) { return value.is_number(); }
 
-        static bool isNull(const T &value) { return value.is_null(); }
+        static bool isInteger(const BaseT &value) { return value.is_number_integer(); }
 
-        static bool isBool(const T &value) { return value.is_bool(); }
+        static bool isFloat(const BaseT &value) { return value.is_number_float(); }
 
-        static bool isInteger(const T &value) { return value.is_number_integer(); }
+        static bool isUnsignedInteger(const BaseT &value) { return value.is_number_unsigned(); }
 
-        static bool isFloat(const T &value) { return value.is_number_float(); }
+        static bool isBool(const BaseT &value) { return value.is_boolean(); }
 
-        static bool isUnsignedInteger(const T &value) { return V.is_number_unsigned(); }
+        static bool isString(const BaseT &value) { return value.is_string(); }
 
-        static bool contains(const T &value, const std::string &k) { return value.contains(k); }
+        static bool isNull(const BaseT &value) { return value.is_null(); }
 
-        static bool isString(const T &value) { return value.is_string(); }
+        static bool EQ(const BaseT &v1,const BaseT & v2) { return v1 == v2; }
 
-        static nlohmann::basic_json &at(const T &value, const std::string &k) { return value[k]; }
+        static bool contains(const BaseT &value, const std::string &k) { return value.contains(k); }
 
-        static nlohmann::basic_json &at(const T &value, int k) { return value[k]; }
+        static decltype(auto) at(const BaseT &value, const std::string &k) { return value[k]; }
+
+        static decltype(auto) at(const BaseT &value, int k) { return value[k]; }
 
         template<typename outType>
-        static outType get(const T &value)
+        static outType get(const BaseT &value)
         {
             return value.template get<outType>();
         }
 
-        static outType parse(const std::string &s) { return nlohmann::parse(s); }
+        static BaseT parse(const std::string &s) { return T::parse(s); }
 
-        static Value array() { return nlohmann::array(); }
+        static BaseT array() { return BaseT::array(); }
 
-        static Value object() { return nlohmann::object(); }
+        static BaseT object() { return BaseT::object(); }
 
-        static void pushBack(T &val, auto value) { val.push_back(value); }
+        static void pushBack(BaseT &val, auto value) { val.push_back(value); }
 
         template<typename action>
-        static void mutateForAll(T &from, action a)
+        static void mutateForAll(BaseT &from, action a)
         {
             if (from.is_array()) {
                 int idx = 0;
@@ -96,7 +105,7 @@ struct json_bridge<T>
         }
 
         template<typename action>
-        static void doForAll(const T &from, action a)
+        static void forAll(const BaseT &from, action a)
         {
             using fromType = std::decay_t<decltype(from)>;
             if constexpr (std::is_same_v<
@@ -128,7 +137,7 @@ struct json_bridge<T>
         }
 
         template<typename keyType, typename valueType>
-        static void appendValue(T &to, const keyType &k, const valueType &v)
+        static void appendValue(BaseT &to, const keyType &k, const valueType &v)
         {
             if (to.is_array()) {
                 to.push_back(v);
@@ -138,18 +147,18 @@ struct json_bridge<T>
         }
 
         template<typename keyType, typename valueType>
-        static void set(T &to, const keyType &k, const valueType &v)
+        static void set(BaseT &to, const keyType &k, const valueType &v)
         {
-            to[] = v;
+            to[k] = v;
         }
 
-        static std::string dump(const T &v) { return v.dump(); }
+        static std::string dump(const BaseT &v) { return v.dump(); }
 
-        template<typename propertyType>
-        static bool getPropertyValueOfType(const T &root,
+        static bool getPropertyValueOfType(const BaseT &root,
                                     const std::string &propertyName,
-                                    propertyType &propertyValue)
+                                    auto &propertyValue)
         {
+            using propertyType = std::decay_t<decltype(propertyValue)>;
             auto convertor = [&](auto E, auto &Prop) {
                 using EType = std::decay_t<decltype(E)>; // This is the type of E
 
@@ -164,12 +173,7 @@ struct json_bridge<T>
                         Prop = E.template get<bool>();
                         return true;
                     }
-                } else if constexpr (isStdVector<propertyType>) {
-                    if (E.is_array()) {
-                        Prop = E;
-                        return true;
-                    }
-                } else if constexpr (IsNlohmann<propertyType>) {
+                } else if constexpr (isNlohmann<propertyType>) {
                     Prop = E;
                     return true;
                 } else {
@@ -183,9 +187,22 @@ struct json_bridge<T>
             auto overrideIt = root.find(propertyName);
             return (overrideIt != root.end()) ? convertor((*overrideIt), propertyValue) : false;
         }
-};
 
-#else
-template<typename T>
-concept IsNlohmann = false;
-#endif
+        static bool getPropertyValueOfType(const BaseT &root,
+                                           const std::string &propertyName,
+                                           TaggedProperty<T,AsArray> propertyValue)
+        {
+            auto convertor = [&](auto E, TaggedProperty<T,AsArray> Prop) {
+                using EType = std::decay_t<decltype(E)>; // This is the type of E
+                if (E.is_array()) {
+                    Prop.value = E;
+                    return true;
+                }
+                return false;
+            };
+
+            auto overrideIt = root.find(propertyName);
+            return (overrideIt != root.end()) ? convertor((*overrideIt), propertyValue) : false;;
+        }
+};
+}
\ No newline at end of file
diff --git a/include/jsonata/qtjson_backend.h b/include/jsonata/qtjson_backend.h
index 9d16e17..c9ad99a 100644
--- a/include/jsonata/qtjson_backend.h
+++ b/include/jsonata/qtjson_backend.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#ifdef JSONATA_QTJSON_ENABLED
-
 #include "JException.h"
 #include "Utils.h"
 #include <concepts>
@@ -20,20 +18,16 @@ template<typename T>
 concept IsQtJson = std::is_base_of_v<QJsonValue, T> || std::is_base_of_v<QJsonArray, T>
                    || std::is_base_of_v<QJsonObject, T> || std::is_base_of_v<QJsonValueRef, T>;
 
+namespace jsonata
+{
 template<>
-struct json_bridge<QJsonValue>
+struct json_bridge_impl<QJsonValue,void>
 {
         using is_json_bridge_type = void; // Tag to satisfy the concept
 
-        // Factory method to unify constructors
-
-        //         ordered_json(const QJsonValueRef &r)
-        //             : QJsonValue(r)
-        //         {}
-
         static QJsonValue create(auto &&value)
         {
-            using V = std::remove_cvref_t<decltype(value)>;
+            using V = std::decay_t<decltype(value)>;
 
             if constexpr (std::is_same_v<V, std::nullptr_t>) {
                 return QJsonValue(QJsonValue::Null);
@@ -62,7 +56,7 @@ struct json_bridge<QJsonValue>
 
         static size_t size(const QJsonValue &value)
         {
-            return value.isArray() ? 0 : value.toArray().count();
+            return value.isArray() ? value.toArray().count() : 0;
         }
 
         static bool isEmpty(const QJsonValue &value) {
@@ -75,17 +69,12 @@ struct json_bridge<QJsonValue>
 
         static bool isArray(const QJsonValue &value) { return value.isArray(); }
 
-        static bool isNumber(const QJsonValue &value) { return value.isDouble(); }
-
+        static bool isNumber(const QJsonValue &value) { return value.isDouble() ; }
         static bool isInteger(const QJsonValue &value)
         {
             return value.isDouble() && value.toVariant().typeId() == QMetaType::LongLong;
         }
 
-        static bool isNull(const QJsonValue &value) { return value.isNull(); }
-
-        static bool isBool(const QJsonValue &value) { return value.isBool(); }
-
         static bool isFloat(const QJsonValue &value)
         {
             return value.isDouble() && value.toVariant().typeId() == QMetaType::Double;
@@ -100,13 +89,19 @@ struct json_bridge<QJsonValue>
             return V.typeId() == QMetaType::LongLong && V.toLongLong() >= 0;
         }
 
+        static bool isBool(const QJsonValue &value) { return value.isBool(); }
+
+        static bool isString(const QJsonValue &value) { return value.isString(); }
+
+        static bool isNull(const QJsonValue &value) { return value.isNull(); }
+
+        static bool EQ(const QJsonValue &v1,const QJsonValue & v2) { return v1 == v2; }
+
         static bool contains(const QJsonValue &value, const std::string &k)
         {
             return value.isObject() && value.toObject().contains(QString::fromStdString(k));
         }
 
-        static bool isString(const QJsonValue &value) { return value.isString(); }
-
         static QJsonValue at(const QJsonValue &value, const std::string &k)
         {
             if (!value.isObject()) {
@@ -150,17 +145,6 @@ struct json_bridge<QJsonValue>
         static void mutateForAll(QJsonValue &from, action a)
         {
             using fromType = std::decay_t<decltype(from)>;
-            /*            if constexpr (std::is_same_v<fromType,
-                                         std::initializer_list<std::pair<std::string, QJsonValue>>>) {
-                for (const auto &[k, v] : from) {
-                    action(k, v);
-                }
-            } else if constexpr (std::is_same_v<fromType, std::initializer_list<QJsonValue>>) {
-                int idx = 0;
-                for (const auto &el : from) {
-                    action(std::to_string(idx++), el);
-                }
-            } else */
             if (from.isArray()) {
                 int idx = 0;
                 bool changed = false;
@@ -327,406 +311,63 @@ struct json_bridge<QJsonValue>
             return r;
         }
 
-        template<typename propertyType>
+        // for simple types
         static bool getPropertyValueOfType(const QJsonValue &root,
                                            const std::string &propertyName,
-                                           propertyType &propertyValue)
+                                           auto &propertyValue)
         {
-            auto convertor = [&](auto E, auto &Prop) {
-                using EType = std::decay_t<decltype(E)>; // This is the type of E
-                if constexpr (std::is_base_of_v<std::string, propertyType>) {
-                    // property must be string
-                    if (E.isString()) {
-                        Prop = E.toString().toStdString();
-                        return true;
-                    }
-                } else if constexpr (std::is_same_v<propertyType, bool>) {
-                    if (E.isBool()) {
-                        Prop = E.toBool();
-                        return true;
-                    }
-                } else if constexpr (isStdVector<propertyType>) {
-                    if (E.isArray()) {
-                        Prop = E.toArray();
-                        return true;
-                    }
-                } else if constexpr (IsQtJson<propertyType>) {
-                    Prop = E;
+            using propertyType = std::decay_t<decltype(propertyValue)>;
+
+            QJsonObject obj = root.toObject();
+            QJsonValue E = obj.value(QString::fromStdString(propertyName));
+
+            if( E.isUndefined() ) {
+                // propertyname does not exist
+                return false;
+            }
+
+            if constexpr (std::is_base_of_v<std::string, propertyType>) {
+                // property must be string
+                if (E.isString()) {
+                    propertyValue = E.toString().toStdString();
+                    return true;
+                }
+            } else if constexpr (std::is_same_v<propertyType, bool>) {
+                if (E.isBool()) {
+                    propertyValue = E.toBool();
                     return true;
-                } else {
-                    // This triggers ONLY if none of the above branches are taken
-                    static_assert(sizeof(propertyType) == 0, "cannot get unknown propertytype");
                 }
+            } else if constexpr (IsQtJson<propertyType>) {
+                propertyValue = E;
+                return true;
+            } else {
+                // This triggers ONLY if none of the above branches are taken
+                static_assert(sizeof(propertyType) == 0, "cannot get unknown propertytype");
+            }
 
-                return false;
-            };
+            return false;
+        }
 
+        static bool getPropertyValueOfType(const QJsonValue &root,
+                                           const std::string &propertyName,
+                                           TaggedProperty<QJsonValue,AsArray> propertyValue)
+        {
             QJsonObject obj = root.toObject();
-            QJsonValue val = obj.value(QString::fromStdString(propertyName));
-            return (!val.isUndefined()) ? convertor(val, propertyValue) : false;
+            QJsonValue E = obj.value(QString::fromStdString(propertyName));
+
+            if( E.isUndefined() ) {
+                // propertyname does not exist
+                return false;
+            }
+
+            if (E.isArray()) {
+                // value MUST be an array
+                propertyValue.value = E.toArray();
+                return true;
+            }
+            return false;
         }
+
 };
-#else
-template<typename T>
-concept IsQtJson = false;
-#endif
-
-// template<typename T>
-// concept hasFind = requires(T t, std::string s) {
-//     {
-//         t.find(s)
-//     } -> std::same_as<bool>;
-// };
-
-// template<typename k, typename v>
-// using ordered_map = std::map<k, v>;
-
-// class ordered_json : public QJsonValue
-// {
-//     public:
-//         ordered_json(std::nullptr_t)
-//             : QJsonValue(QJsonValue::Null)
-//         {}
-//         ordered_json()
-//             : QJsonValue()
-//         {}
-//         template<typename T>
-//             requires std::is_constructible_v<QJsonValue, T>
-//         ordered_json(T b)
-//             : QJsonValue(b)
-//         {}
-
-//         // You still need to explicitly handle types Qt doesn't know, like std::string
-//         ordered_json(const std::string &s)
-//             : QJsonValue(QString::fromStdString(s))
-//         {}
-//         // will loose precision
-//         ordered_json(uint64_t v)
-//             : QJsonValue(int64_t(v))
-//         {}
-//         ordered_json(const QJsonValueRef &r)
-//             : QJsonValue(r)
-//         {}
-
-//         static inline ordered_json array() { return QJsonArray(); }
-
-//         static inline ordered_json object() { return QJsonObject(); }
-
-//         static inline ordered_json array(std::initializer_list<ordered_json> args);
-//         static inline ordered_json object(
-//             std::initializer_list<std::pair<std::string, ordered_json>> args);
-
-//         template<typename T>
-//         void push_back(const T &v)
-//         {
-//         }
-
-//         inline bool is_null() const { return isNull(); }
-//         inline bool is_boolean() const { return isBool(); }
-//         inline bool is_string() const { return isString(); }
-//         inline bool is_array() const { return isArray(); }
-//         inline size_t size() const { return toArray().count(); }
-//         inline bool is_object() const { return isObject(); }
-//         inline bool is_number() const { return isDouble(); }
-//         inline bool is_number_integer() const
-//         {
-//             return isDouble() && toVariant().typeId() == QMetaType::LongLong;
-//         }
-//         inline bool is_number_float() const
-//         {
-//             return isDouble() && toVariant().typeId() == QMetaType::Double;
-//         }
-//         inline bool is_number_unsigned() const
-//         {
-//             if (!isDouble()) {
-//                 return false;
-//             }
-//             QVariant V = toVariant();
-//             return toVariant().typeId() == QMetaType::LongLong && V.toLongLong() >= 0;
-//         }
-//         template<typename T>
-//         T get() const
-//         {
-//             return toVariant().value<T>();
-//         }
-
-//         template<>
-//         std::string get() const
-//         {
-//             return get<QString>().toStdString();
-//         }
-
-//         bool contains(const char *v) const { return isObject() && toObject().contains(v); }
-
-//         // Template wrapper for all operator[] overloads
-//         template<typename T>
-//         const ordered_json operator[](const T &keyOrIndex) const
-//         {
-//             return ordered_json(QJsonValue::operator[](keyOrIndex));
-//         }
-
-//         const ordered_json operator[](const std::string &keyOrIndex) const
-//         {
-//             return ordered_json(QJsonValue::operator[](QString::fromStdString(keyOrIndex)));
-//         }
-
-// #include <string>
-
-//         std::string dump() const
-//         {
-//             return QJsonValue::toJson(QJsonDocument::Compact).toStdString();
-//         }
-
-//         bool empty() const
-//         {
-//             return isNull() || (isObject() && toObject().empty())
-//                    || (isArray() && toArray().empty());
-//         }
-
-//         // This allows: if (myJson != nullptr)
-//         bool operator!=(std::nullptr_t) const { return !isNull(); }
-
-//         bool operator==(std::nullptr_t) const { return isNull(); }
-// };
-
-// class json : public QJsonValue
-// {
-//     public:
-//         json()
-//             : QJsonValue()
-//         {}
-//         json(std::nullptr_t)
-//             : QJsonValue()
-//         {}
-//         template<typename T>
-//             requires std::is_constructible_v<QJsonValue, T>
-//                      && (!std::is_integral_v<T> || std::is_same_v<T, bool>)
-//         json(T b)
-//             : QJsonValue(b)
-//         {}
-
-//         // You still need to explicitly handle types Qt doesn't know, like std::string
-//         // will loose precision
-//         json(long v)
-//             : QJsonValue(qint64(v))
-//         {}
-//         json(long long v)
-//             : QJsonValue(qint64(v))
-//         {}
-//         json(uint64_t v)
-//             : QJsonValue(qint64(v))
-//         {}
-//         json(int v)
-//             : QJsonValue(qint64(v))
-//         {}
-//         json(const std::string &s)
-//             : QJsonValue(QString::fromStdString(s))
-//         {}
-//         json(const QJsonValueRef &r)
-//             : QJsonValue(r)
-//         {}
-
-//         static json array() { return QJsonArray(); }
-
-//         static json object() { return QJsonObject(); }
-
-//         static inline json array(std::initializer_list<json> args);
-//         static inline json object(std::initializer_list<std::pair<std::string, json>> args);
-
-//         template<typename T>
-//         void push_back(const T &v)
-//         {
-//             toArray().push_back(v);
-//         }
-
-//         inline bool is_null() const { return isNull(); }
-//         inline bool is_boolean() const { return isBool(); }
-//         inline bool is_string() const { return isString(); }
-//         inline bool is_array() const { return isArray(); }
-//         inline size_t size() const { return toArray().count(); }
-//         inline bool is_object() const { return isObject(); }
-//         inline bool is_number() const { return isDouble(); }
-//         inline bool is_number_integer() const
-//         {
-//             return isDouble() && toVariant().typeId() == QMetaType::LongLong;
-//         }
-//         inline bool is_number_float() const
-//         {
-//             return isDouble() && toVariant().typeId() == QMetaType::Double;
-//         }
-//         inline bool is_number_unsigned() const
-//         {
-//             if (!isDouble()) {
-//                 return false;
-//             }
-//             QVariant V = toVariant();
-//             return toVariant().typeId() == QMetaType::LongLong && V.toLongLong() >= 0;
-//         }
-//         template<typename T>
-//         T get() const
-//         {
-//             return toVariant().value<T>();
-//         }
-//         template<>
-//         std::string get() const
-//         {
-//             return toVariant().toString().toStdString();
-//         }
-
-//         static ordered_json parse(const std::string &s)
-//         {
-//             return ordered_json(QJsonValue::fromJson(s.data()));
-//         }
-
-//         std::string dump() const { return QJsonValue::toString().toStdString(); }
-
-//         bool empty() const
-//         {
-//             return isNull() || (isObject() && toObject().empty())
-//                    || (isArray() && toArray().empty());
-//         }
-//         bool contains(const std::string &key) const
-//         {
-//             return isObject() && toObject().contains(QString::fromStdString(key));
-//         }
-// };
-
-// #endif
-
-// ordered_json ordered_json::array(std::initializer_list<ordered_json> args)
-// {
-//     ordered_json a = ordered_json::array();
-//     copy(args, a, [](const ordered_json &j) -> QJsonValue { return j; });
-//     return a;
-// }
-
-// ordered_json ordered_json::object(std::initializer_list<std::pair<std::string, ordered_json>> args)
-// {
-//     ordered_json o = ordered_json::object();
-//     copy(args, o, [](const ordered_json &j) { return j; });
-//     return o;
-// }
-
-// json json::array(std::initializer_list<json> args)
-// {
-//     json a = json::array();
-//     copy(args, a, [](const json &j) -> QJsonValue { return j; });
-//     return a;
-// }
-
-// json json::object(std::initializer_list<std::pair<std::string, json>> args)
-// {
-//     json o = json::object();
-//     copy(args, o, [](const json &j) { return j; });
-//     return o;
-// }
-
-// template<>
-// std::string get() const
-// {
-//     return get<QString>().toStdString();
-// }
-
-// bool contains(const char *v) const
-// {
-//     return isObject() && toObject().contains(v);
-// }
-
-// // Template wrapper for all operator[] overloads
-// template<typename T>
-// const ordered_json operator[](const T &keyOrIndex) const
-// {
-//     return ordered_json(QJsonValue::operator[](keyOrIndex));
-// }
-
-// const ordered_json operator[](const std::string &keyOrIndex) const
-// {
-//     return ordered_json(QJsonValue::operator[](QString::fromStdString(keyOrIndex)));
-// }
-
-// #include <string>
-
-// static QString decodeUtfChars(const std::string &stdStr)
-// {
-//     QString str = QString::fromStdString(stdStr);
-
-//     // Regex to find \u followed by 4 hex digits
-//     static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
-
-//     QRegularExpressionMatchIterator i = re.globalMatch(str);
-//     int offset = 0;
-
-//     while (i.hasNext()) {
-//         QRegularExpressionMatch match = i.next();
-
-//         // Get the 4 hex digits (e.g., "D800")
-//         bool ok;
-//         ushort code = match.captured(1).toUShort(&ok, 16);
-
-//         if (ok) {
-//             // Convert hex to a single UTF-16 character (even if it's a lone surrogate)
-//             QString replacement = QChar(code);
-
-//             // Replace the "\uD800" text with the actual character
-//             str.replace(match.capturedStart() + offset, match.capturedLength(), replacement);
-
-//             // Adjust offset because we replaced 6 chars ("\uD800") with 1 char
-//             offset += (replacement.length() - match.capturedLength());
-//         }
-//     }
-//     return str;
-// }
-
-// static bool isValidUtf(const QString &str)
-// {
-//     for (int i = 0; i < str.length(); ++i) {
-//         if (str[i].isHighSurrogate()) {
-//             // Must be followed by a low surrogate
-//             if (i + 1 >= str.length() || !str[i + 1].isLowSurrogate()) {
-//                 return false; // Error: Unpaired high surrogate
-//             }
-//             i++; // Skip the low surrogate as we've validated the pair
-//         } else if (str[i].isLowSurrogate()) {
-//             // If we hit a low surrogate here, it means it wasn't
-//             // preceded by a high surrogate (which would have triggered the 'if' above)
-//             return false; // Error: Orphaned low surrogate
-//         }
-//     }
-//     return true;
-// }
-
-// static ordered_json parse(const std::string &s)
-// {
-//     QJsonParseError Err;
-//     QString S = decodeUtfChars(s);
-//     if (!isValidUtf(S)) {
-//         throw jsonata::JException("D3141", 0);
-//     }
-
-//     auto r = ordered_json(QJsonValue::fromJson(s.data(), &Err));
-//     if (Err.error != QJsonParseError::NoError) {
-//         throw jsonata::JException("D3141", Err.offset, Err.errorString().data());
-//     }
-//     return r;
-// }
-
-// std::string dump() const
-// {
-//     return QJsonValue::toJson(QJsonDocument::Compact).toStdString();
-// }
-
-// bool empty() const
-// {
-//     return isNull() || (isObject() && toObject().empty()) || (isArray() && toArray().empty());
-// }
-
-// // This allows: if (myJson != nullptr)
-// bool operator!=(std::nullptr_t) const
-// {
-//     return !isNull();
-// }
-
-// bool operator==(std::nullptr_t) const
-// {
-//     return isNull();
-// }
+
+}
diff --git a/include/jsonata/qtvariant_backend.h b/include/jsonata/qtvariant_backend.h
index e807d21..534e89a 100644
--- a/include/jsonata/qtvariant_backend.h
+++ b/include/jsonata/qtvariant_backend.h
@@ -1,40 +1,411 @@
 #pragma once
 
-#ifdef JSONATA_QTVARIANT_ENABLED
-
 #include "JException.h"
 #include "Utils.h"
 #include <concepts>
 
+#include "common_backend.h"
+
+// #include <array>
+// #include <any>
 #include <QJsonArray>
 #include <QJsonObject>
-#include <QJsonValue>
-#include <QRegularExpression>
+#include <QVariant>
 #include <QMap>
-#include <map>
+#include <QRegularExpression>
 
 template<typename T>
-concept IsQtVariant = std::is_base_of_v<QVariant, T> ||
-                   std::is_base_of_v<QVariantMap, T> ||
-                   std::is_base_of_v<QVariantList, T>;
+concept IsQVariant = std::is_base_of_v<QVariant, T>;
 
-template<typename collection, typename action>
-void qtvariant_mutateForAll(collection &from, action a)
+namespace jsonata
 {
-    // if (from.isArray()) {
-    //     int idx = 0;
-    //     for (const auto &el : from) {
-    //         a(std::to_string(idx++), el);
-    //     }
-    // } else {
-    //     for (const auto &[k, v] : from) {
-    //         a(k, v);
-    //     }
-    // }
-    // return;
-}
+    template<>
+    struct json_bridge_impl<QVariant,void>
+    {
+            using is_json_bridge_type = void; // Tag to satisfy the concept
 
-#else
-template<typename T>
-concept IsQtVariant = false;
-#endif
+            static QVariant create(auto &&value)
+            {
+                using V = std::decay_t<decltype(value)>;
+
+                if constexpr (std::is_same_v<V, std::nullptr_t>) {
+                    return QVariant();
+                } else if constexpr (std::is_same_v<V, std::string> || std::is_same_v<V, const char *>) {
+                    // Handle both std::string and literal "strings"
+                    if constexpr (std::is_same_v<V, const char *>)
+                        return QVariant(QString(value));
+                    else
+                        return QVariant(QString::fromStdString(value));
+                } else if constexpr (std::is_integral_v<V> && !std::is_same_v<V, bool>) {
+                    // Handle all integers (int, long, long long, size_t, etc.)
+                    // qlonglong is the safest sink for integral types in Qt
+                    return QVariant(static_cast<qlonglong>(value));
+                }
+                // Handle floating point
+                else if constexpr (std::is_floating_point_v<V>) {
+                    return QVariant(static_cast<double>(value));
+                } else if constexpr (std::is_constructible_v<QVariant, V>) {
+                    return QVariant(value);
+                } else {
+                    static_assert(false, "Unsupported type for QVariant creation");
+                }
+            }
+
+            static QVariant create() { return QVariant(); }
+
+            static size_t size(const QVariant &value)
+            {
+                return isArray(value) ? value.toList().size() : 0;
+            }
+
+            static bool isEmpty(const QVariant &value) {
+                return value.isNull() ||
+                       ( isObject( value ) && value.toMap().empty()) ||
+                       ( isArray( value ) && value.toList().empty());
+            }
+
+            static bool isObject(const QVariant &value) { return isOfType( value, QMetaType::QVariantMap ); }
+
+            static bool isArray(const QVariant &value) { return isOfType( value, QMetaType::QVariantList ); }
+
+            static bool isNumber(const QVariant &value) {
+                switch (value.typeId()) {
+                    case QMetaType::Int:
+                    case QMetaType::Long:
+                    case QMetaType::LongLong:
+                    case QMetaType::ULong:
+                    case QMetaType::UInt:
+                    case QMetaType::ULongLong:
+                    case QMetaType::Double:
+                    case QMetaType::Float:
+                        return true;
+                    default :
+                        return false;
+                }
+            }
+            static bool isInteger(const QVariant &value)
+            {
+                switch (value.typeId()) {
+                    case QMetaType::Int:
+                    case QMetaType::Long:
+                    case QMetaType::LongLong:
+                    case QMetaType::ULong:
+                    case QMetaType::UInt:
+                    case QMetaType::ULongLong:
+                        return true;
+                    default :
+                        return false;
+                }
+            }
+
+            static bool isFloat(const QVariant &value)
+            {
+                switch (value.typeId()) {
+                    case QMetaType::Double:
+                    case QMetaType::Float:
+                        return true;
+                    default :
+                        return false;
+                }
+            }
+
+            static bool isUnsignedInteger(const QVariant &value)
+            {
+                switch (value.typeId()) {
+                    case QMetaType::ULong:
+                    case QMetaType::UInt:
+                    case QMetaType::ULongLong:
+                        return true;
+                    default :
+                        return false;
+                }
+            }
+
+            static bool isBool(const QVariant &value) { return isOfType( value, QMetaType::Bool ); }
+
+            static bool isString(const QVariant &value) { return isOfType( value, QMetaType::QString ); }
+
+            static bool isNull(const QVariant &value) { return value.isNull(); }
+
+            static bool EQ(const QVariant &v1,const QVariant & v2) { return v1 == v2; }
+
+            static bool contains(const QVariant &value, const std::string &k)
+            {
+                return isObject(value) && value.toMap().contains(QString::fromStdString(k));
+            }
+
+            static QVariant at(const QVariant &value, const std::string &k)
+            {
+                if (!isObject(value)) {
+                    throw jsonata::JException("Value is not an object");
+                }
+                return value.toMap()[QString::fromStdString(k)];
+            }
+
+            static QVariant at(const QVariant &value, int k)
+            {
+                if (!isArray(value)) {
+                    throw jsonata::JException("Value is not an array");
+                }
+                return value.toList()[k];
+            }
+
+            template<typename outType>
+            static outType get(const QVariant &value)
+            {
+                return value.template value<outType>();
+            }
+
+            template<>
+            std::string get(const QVariant &value)
+            {
+                return get<QString>(value).toStdString();
+            }
+
+            static QVariant array() { return QVariantList(); }
+
+            static QVariant object() { return QVariantMap(); }
+
+            static void pushBack(QVariant &val, auto value)
+            {
+                QVariantList a = val.toList();
+                a.push_back(value);
+                val = a;
+            }
+
+            template<typename action>
+            static void mutateForAll(QVariant &from, action a)
+            {
+                using fromType = std::decay_t<decltype(from)>;
+                if (isArray(from)) {
+                    int idx = 0;
+                    bool changed = false;
+                    auto arr = from.toList();
+                    for (auto el : arr) {
+                        if (a(std::to_string(idx++), el)) {
+                            arr[idx - 1] = el;
+                            changed = true;
+                        }
+                    }
+                    if (changed) {
+                        from = arr;
+                    }
+                } else if (isObject(from)) {
+                    bool changed = false;
+                    auto obj = from.toMap();
+                    for (auto [key, value] : obj.asKeyValueRange()) {
+                        QVariant J(value);
+                        if (a(key.toStdString(), J)) {
+                            value = J;
+                            changed = true;
+                        }
+                    }
+                    if (changed) {
+                        from = obj;
+                    }
+                }
+            }
+
+            template<typename action>
+            static void forAll(const QVariant &from, action a)
+            {
+                if (isArray(from)) {
+                    int idx = 0;
+                    for (const auto &el : from.toList()) {
+                        a(std::to_string(idx++), QVariant(el));
+                    }
+                } else if (isObject(from)) {
+                    auto obj = from.toMap();
+                    for (auto [key, value] : obj.asKeyValueRange()) {
+                        a(key.toStdString(), QVariant(value));
+                    }
+                }
+            }
+
+            template<typename keyType, typename valueType>
+            static void appendValue(QVariant &to, const keyType &k, const valueType &v)
+            {
+                if (isArray(to)) {
+                    auto x = to.toList();
+                    if constexpr (std::is_convertible_v<valueType, std::string>) {
+                        x.push_back(QString::fromStdString(v));
+                    } else if constexpr (!std::is_convertible_v<valueType, std::string>) {
+                        x.push_back(v);
+                    }
+                    to = x;
+                } else {
+                    auto x = to.toMap();
+                    if constexpr (std::is_convertible_v<valueType, std::string>) {
+                        x[QString::fromStdString(k)] = QString::fromStdString(v);
+                    } else if constexpr (!std::is_convertible_v<valueType, std::string>) {
+                        x[QString::fromStdString(k)] = v;
+                    }
+                    to = x;
+                }
+            }
+
+            template<typename keyType, typename valueType>
+            static void set(QVariant &to, const keyType &k, const valueType &v)
+            {
+                if constexpr (std::is_same_v<keyType, QString>) {
+                    auto x = to.toMap();
+                    if constexpr (std::is_convertible_v<valueType, std::string>) {
+                        x[k] = QString::fromStdString(v);
+                    } else {
+                        x[k] = v;
+                    }
+                    to = x;
+                } else if constexpr (std::is_convertible_v<keyType, std::string>) {
+                    auto x = to.toMap();
+                    if constexpr (std::is_convertible_v<valueType, std::string>) {
+                        x[QString::fromStdString(k)] = QString::fromStdString(v);
+                    } else {
+                        x[QString::fromStdString(k)] = v;
+                    }
+                    to = x;
+                } else if constexpr (std::is_convertible_v<keyType, int>) {
+                    auto x = to.toList();
+                    if constexpr (std::is_convertible_v<valueType, std::string>) {
+                        x[k] = QString::fromStdString(v);
+                    } else {
+                        x[k] = v;
+                    }
+                    to = x;
+                }
+            }
+
+            static std::string dump(const QVariant &v)
+            {
+                return QString::fromUtf8(QJsonValue::fromVariant(v).toJson()).toStdString();
+            }
+
+            static QVariant parse(const std::string &s)
+            {
+                auto decodeUtfChars = [](const std::string &stdStr) -> QString {
+                    QString str = QString::fromStdString(stdStr);
+
+                    // Regex to find \u followed by 4 hex digits
+                    static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
+
+                    QRegularExpressionMatchIterator i = re.globalMatch(str);
+                    int offset = 0;
+
+                    while (i.hasNext()) {
+                        QRegularExpressionMatch match = i.next();
+
+                        // Get the 4 hex digits (e.g., "D800")
+                        bool ok;
+                        ushort code = match.captured(1).toUShort(&ok, 16);
+
+                        if (ok) {
+                            // Convert hex to a single UTF-16 character (even if it's a lone surrogate)
+                            QString replacement = QChar(code);
+
+                            // Replace the "\uD800" text with the actual character
+                            str.replace(match.capturedStart() + offset,
+                                        match.capturedLength(),
+                                        replacement);
+
+                            // Adjust offset because we replaced 6 chars ("\uD800") with 1 char
+                            offset += (replacement.length() - match.capturedLength());
+                        }
+                    }
+                    return str;
+                };
+
+                auto isValidUtf = [](const QString &str) -> bool {
+                    for (int i = 0; i < str.length(); ++i) {
+                        if (str[i].isHighSurrogate()) {
+                            // Must be followed by a low surrogate
+                            if (i + 1 >= str.length() || !str[i + 1].isLowSurrogate()) {
+                                return false; // Error: Unpaired high surrogate
+                            }
+                            i++; // Skip the low surrogate as we've validated the pair
+                        } else if (str[i].isLowSurrogate()) {
+                            // If we hit a low surrogate here, it means it wasn't
+                            // preceded by a high surrogate (which would have triggered the 'if' above)
+                            return false; // Error: Orphaned low surrogate
+                        }
+                    }
+                    return true;
+                };
+
+                QJsonParseError Err;
+                QString S = decodeUtfChars(s);
+                if (!isValidUtf(S)) {
+                    throw jsonata::JException("D3141", 0);
+                }
+
+                auto r = QJsonValue::fromJson(s.data(), &Err);
+                if (Err.error != QJsonParseError::NoError) {
+                    throw jsonata::JException("D3141", Err.offset, Err.errorString().data());
+                }
+                return r.toVariant();
+            }
+
+            // for simple types
+            static bool getPropertyValueOfType(const QVariant &root,
+                                               const std::string &propertyName,
+                                               auto &propertyValue)
+            {
+                using propertyType = std::decay_t<decltype(propertyValue)>;
+
+                auto obj = root.toMap();
+                QString S = QString::fromStdString(propertyName);
+                if( ! obj.contains( S )) {
+                    return false;
+                }
+
+                QVariant E = obj.value( S );
+
+                if constexpr (std::is_base_of_v<std::string, propertyType>) {
+                    // property must be string
+                    if ( isString( E ) ) {
+                        propertyValue = E.toString().toStdString();
+                        return true;
+                    }
+                } else if constexpr (std::is_same_v<propertyType, bool>) {
+                    if (isBool( E ) ) {
+                        propertyValue = E.toBool();
+                        return true;
+                    }
+                } else if constexpr (IsQVariant<propertyType>) {
+                    propertyValue = E;
+                    return true;
+                } else {
+                    // This triggers ONLY if none of the above branches are taken
+                    static_assert(sizeof(propertyType) == 0, "cannot get unknown propertytype");
+                }
+
+                return false;
+            }
+
+            static bool getPropertyValueOfType(const QVariant &root,
+                                               const std::string &propertyName,
+                                               TaggedProperty<QVariant,AsArray> propertyValue)
+            {
+                auto obj = root.toMap();
+                QString S = QString::fromStdString(propertyName);
+
+                if( ! obj.contains( S )) {
+                    return false;
+                }
+
+                QVariant E = obj.value( S );
+
+                if (isArray(E)) {
+                    // value MUST be an array
+                    propertyValue.value = E.toList();
+                    return true;
+                }
+                return false;
+            }
+
+        private :
+            static bool isOfType( const QVariant & v, int type ) {
+                return v.typeId() == type;
+            }
+
+    };
+
+}
diff --git a/src/jsonata/Jsonata.cpp b/src/jsonata/Jsonata.cpp
index ed78d3b..06784a9 100644
--- a/src/jsonata/Jsonata.cpp
+++ b/src/jsonata/Jsonata.cpp
@@ -2450,61 +2450,59 @@ Jsonata::Jsonata(const Jsonata& other) {
     timestamp_ = other.timestamp_;
 }
 
-// std::any Jsonata::evaluate(const std::any anyInput,
-//                                                  std::shared_ptr<Frame> bindings) {
-//     // Always evaluate in a fresh child frame of the shared environment,
-//     // then (optionally) copy provided bindings into it. This avoids
-//     // concurrent mutations of the shared environment.
-//     std::shared_ptr<Frame> exec_env = createFrame(environment_);
-//     if (bindings != nullptr) {
-//         for (const auto& [key, value] : bindings->getBindings()) {
-//             exec_env->bind(key, value);
-//         }
-//     }
+std::any Jsonata::evaluate(const std::any anyInput,
+                           std::shared_ptr<Frame> bindings) {
+    // Always evaluate in a fresh child frame of the shared environment,
+    // then (optionally) copy provided bindings into it. This avoids
+    // concurrent mutations of the shared environment.
+    std::shared_ptr<Frame> exec_env = createFrame(environment_);
+    if (bindings != nullptr) {
+        for (const auto& [key, value] : bindings->getBindings()) {
+            exec_env->bind(key, value);
+        }
+    }
 
-//     // TODO: capture timestamp for $now() and $millis() functions
-//     // timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
-//     //     std::chrono::system_clock::now().time_since_epoch()).count();
+    // TODO: capture timestamp for $now() and $millis() functions
+    // timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
+    //     std::chrono::system_clock::now().time_since_epoch()).count();
 
-//     // CRITICAL: if the input is a JSON array, wrap it in a singleton sequence
-//     // Java reference lines 2575-2579:
-//     // if((input instanceof List) && !Utils.isSequence(input)) {
-//     //     input = Utils.createSequence(input);
-//     //     ((JList)input).outerWrapper = true;
-//     // }
-//     std::any processedInput = anyInput;
-//     if (anyInput.has_value() && Utils::isArray(anyInput) &&
-//         !Utils::isSequence(anyInput)) {
-//         auto sequence = Utils::createSequence(anyInput);
-//         sequence.outerWrapper = true;
-//         processedInput = sequence;
-//     }
+    // CRITICAL: if the input is a JSON array, wrap it in a singleton sequence
+    // Java reference lines 2575-2579:
+    // if((input instanceof List) && !Utils.isSequence(input)) {
+    //     input = Utils.createSequence(input);
+    //     ((JList)input).outerWrapper = true;
+    // }
+    std::any processedInput = anyInput;
+    if (anyInput.has_value() && Utils::isArray(anyInput) &&
+        !Utils::isSequence(anyInput)) {
+        auto sequence = Utils::createSequence(anyInput);
+        sequence.outerWrapper = true;
+        processedInput = sequence;
+    }
 
-//     // CRITICAL: put the processed input (which may be wrapped) into the
-//     // fresh execution environment as the root object "$"
-//     exec_env->bind("$", processedInput);
+    // CRITICAL: put the processed input (which may be wrapped) into the
+    // fresh execution environment as the root object "$"
+    exec_env->bind("$", processedInput);
 
-//     if (validateInput_) {
-//         Functions::validateInput(processedInput);
-//     }
+    if (validateInput_) {
+        Functions::validateInput(processedInput);
+    }
 
-//     std::any result;
-//     try {
-//         // Set thread-local input/environment for this evaluation
-//         tls_input_ = processedInput;
-//         tls_environment_ = exec_env;
-//         result = evaluate(expression_, processedInput, exec_env);
-//         // Clear TLS after evaluation to avoid dangling references
-//         tls_input_.reset();
-//         tls_environment_.reset();
-//         result = Utils::convertNulls(result);
-//         // Convert result back to jsonata::ordered_json
-//         return fromAny(result);
-//     } catch (const std::exception& err) {
-//         // TODO: populateMessage(err);
-//         throw;
-//     }
-// }
+    std::any result;
+    try {
+        // Set thread-local input/environment for this evaluation
+        tls_input_ = processedInput;
+        tls_environment_ = exec_env;
+        result = evaluate(expression_, processedInput, exec_env);
+        // Clear TLS after evaluation to avoid dangling references
+        tls_input_.reset();
+        tls_environment_.reset();
+        return Utils::convertNulls(result);
+    } catch (const std::exception& err) {
+        // TODO: populateMessage(err);
+        throw;
+    }
+}
 
 // jsonata::ordered_json Jsonata::evaluate(const jsonata::ordered_json& input) {
 //     return evaluate(input, nullptr);
diff --git a/test/Generate.cpp b/test/Generate.cpp
index 647359f..e8d7cfa 100644
--- a/test/Generate.cpp
+++ b/test/Generate.cpp
@@ -113,6 +113,7 @@ class JsonataTestGenerator {
 
     // Extract expression from test case for comment
     static std::string getExpressionComment(const JSONATA_TEST_BACKEND& testCase) {
+        // If this assertion fails, the specialization is invisible to the compiler here
         if (jsonata::backend(testCase).isObject() &&
             jsonata::backend(testCase).contains("expr") &&
             jsonata::backend(testCase)["expr"].isString() )
diff --git a/test/JsonataTest.cpp b/test/JsonataTest.cpp
index 0edfc2b..af7784b 100644
--- a/test/JsonataTest.cpp
+++ b/test/JsonataTest.cpp
@@ -91,10 +91,10 @@ namespace jsonata
                         success = false;
                     else {
                         std::multiset<std::string> a, b;
-                        exp.forAll( [&a](auto k, auto v) {
+                        exp.forAll( [&a](const std::string & k, const auto & v) {
                             v.dump();
                         });
-                        exp.forAll( [&b](auto k, auto v) {
+                        exp.forAll( [&b](const std::string & k, const auto & v) {
                             v.dump();
                         });
                         // for (const auto& el : exp) a.insert(el.dump());
@@ -445,9 +445,9 @@ namespace jsonata
             testOverrides = new TestOverrides();
             auto overrideArray = jsonata::backend<JSONATA_TEST_BACKEND>::array();
 
-            if( ! jsonValue.template getPropertyValueOfType<std::vector<int>>(
+            if( ! jsonValue.getPropertyValueOfType(
                 "override",
-                overrideArray) ) {
+                Array(overrideArray)) ) {
                 std::cerr << "Warning: Missing or invalid 'override' array in test-overrides.json, " "using empty overrides"
                           << std::endl;
                 return testOverrides;
@@ -463,27 +463,27 @@ namespace jsonata
                 const auto &overrideObj = item;
                 TestOverride to;
 
-                overrideObj.template getPropertyValueOfType<std::string>(
+                overrideObj.getPropertyValueOfType(
                     "name",
                     to.name
                     );
 
-                overrideObj.template getPropertyValueOfType<bool>(
+                overrideObj.getPropertyValueOfType(
                     "ignoreError",
                     to.ignoreError
                     );
 
-                overrideObj.template getPropertyValueOfType<jsonata::backend<JSONATA_TEST_BACKEND>>(
+                overrideObj.getPropertyValueOfType(
                     "alternateResult",
-                    to.alternateResult
+                    Array(to.alternateResult)
                     );
 
-                overrideObj.template getPropertyValueOfType<std::string>(
+                overrideObj.getPropertyValueOfType(
                     "alternateCode",
                     to.alternateCode
                     );
 
-                overrideObj.template getPropertyValueOfType<std::string>(
+                overrideObj.getPropertyValueOfType(
                     "reason",
                     to.reason
                     );
@@ -656,7 +656,7 @@ namespace jsonata
             } else {
                 auto errorIt = testDef.find("error");
                 if (errorIt != testDef.end() && errorIt->second.isObject()) {
-                    errorIt->second.getPropertyValueOfType<std::string>(
+                    errorIt->second.getPropertyValueOfType(
                         "code",
                         code );
                     // auto errorCodeIt = errorObj.find("code");
diff --git a/test/gen/array_constructorTest.cpp b/test/gen/array_constructorTest.cpp
index 3cce350..f605127 100644
--- a/test/gen/array_constructorTest.cpp
+++ b/test/gen/array_constructorTest.cpp
@@ -6,112 +6,132 @@ using namespace jsonata;
 class array_constructorTest : public JsonataTest {
 };
 
-// 
-TEST_F(array_constructorTest, array_sequences) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json"));
+// $.[value,epochSeconds][]
+TEST_F(array_constructorTest, array_sequences_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 0));
 }
 
-// 
+// $.[value,epochSeconds][]
+TEST_F(array_constructorTest, array_sequences_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 1));
+}
+
+// $.[value,epochSeconds]
+TEST_F(array_constructorTest, array_sequences_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 2));
+}
+
+// singleArray
+TEST_F(array_constructorTest, array_sequences_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 3));
+}
+
+// singleArray[]
+TEST_F(array_constructorTest, array_sequences_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/array-constructor/array-sequences.json", 4));
+}
+
+// []
 TEST_F(array_constructorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case000.json"));
 }
 
-// 
+// [1]
 TEST_F(array_constructorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case001.json"));
 }
 
-// 
+// [1, 2]
 TEST_F(array_constructorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case002.json"));
 }
 
-// 
+// [1, 2,3]
 TEST_F(array_constructorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case003.json"));
 }
 
-// 
+// [1, 2, [3, 4]]
 TEST_F(array_constructorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case004.json"));
 }
 
-// 
+// [1, \"two\", [\"three\", 4]]
 TEST_F(array_constructorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case005.json"));
 }
 
-// 
+// [1, $two, [\"three\", $four]]
 TEST_F(array_constructorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case006.json"));
 }
 
-// 
+// [\"foo.bar\", foo.bar, [\"foo.baz\", foo.blah.baz]]
 TEST_F(array_constructorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case007.json"));
 }
 
-// 
+// [1, 2, 3][0]
 TEST_F(array_constructorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case008.json"));
 }
 
-// 
+// [1, 2, [3, 4]][-1]
 TEST_F(array_constructorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case009.json"));
 }
 
-// 
+// [1, 2, [3, 4]][-1][-1]
 TEST_F(array_constructorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case010.json"));
 }
 
-// 
+// foo.blah.baz.[fud, fud]
 TEST_F(array_constructorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case011.json"));
 }
 
-// 
+// foo.blah.baz.[[fud, fud]]
 TEST_F(array_constructorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case012.json"));
 }
 
-// 
+// foo.blah.[baz].fud
 TEST_F(array_constructorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case013.json"));
 }
 
-// 
+// foo.blah.[baz, buz].fud
 TEST_F(array_constructorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case014.json"));
 }
 
-// 
+// [Address, Other.\"Alternative.Address\"].City
 TEST_F(array_constructorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case015.json"));
 }
 
-// 
+// [Address, Other.`Alternative.Address`].City
 TEST_F(array_constructorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case016.json"));
 }
 
-// 
+// [0,1,2,3,4,5,6,7,8,9][$ % 2 = 0]
 TEST_F(array_constructorTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case017.json"));
 }
 
-// 
+// [1, 2, 3].$
 TEST_F(array_constructorTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case018.json"));
 }
 
-// 
+// [1, 2, 3].$
 TEST_F(array_constructorTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case019.json"));
 }
 
-// 
+// [1, 2, 3].$
 TEST_F(array_constructorTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/array-constructor/case020.json"));
 }
diff --git a/test/gen/blocksTest.cpp b/test/gen/blocksTest.cpp
index a5c7b4d..3e2ec50 100644
--- a/test/gen/blocksTest.cpp
+++ b/test/gen/blocksTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class blocksTest : public JsonataTest {
 };
 
-// 
+// ()
 TEST_F(blocksTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case000.json"));
 }
 
-// 
+// (1; 2; 3)
 TEST_F(blocksTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case001.json"));
 }
 
-// 
+// (1; 2; 3;)
 TEST_F(blocksTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case002.json"));
 }
 
-// 
+// ($a:=1; $b:=2; $c:=($a:=4; $a+$b); $a+$c)
 TEST_F(blocksTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case003.json"));
 }
 
-// 
+// Account.Order.Product.($var1 := Price ; $var2:=Quantity; $var1 * $var2)
 TEST_F(blocksTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case004.json"));
 }
 
-// 
+// (  $func := function($arg) {$arg.Account.Order[0].OrderID};  $func($))
 TEST_F(blocksTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case005.json"));
 }
 
-// 
+// (  $func := function($arg) {$arg.Account.Order[0]};  $func($).OrderID)
 TEST_F(blocksTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/blocks/case006.json"));
 }
diff --git a/test/gen/boolean_expresssionsTest.cpp b/test/gen/boolean_expresssionsTest.cpp
index 8da3fc2..7675082 100644
--- a/test/gen/boolean_expresssionsTest.cpp
+++ b/test/gen/boolean_expresssionsTest.cpp
@@ -6,157 +6,157 @@ using namespace jsonata;
 class boolean_expresssionsTest : public JsonataTest {
 };
 
-// 
+// true
 TEST_F(boolean_expresssionsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case000.json"));
 }
 
-// 
+// false
 TEST_F(boolean_expresssionsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case001.json"));
 }
 
-// 
+// false or false
 TEST_F(boolean_expresssionsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case002.json"));
 }
 
-// 
+// false or true
 TEST_F(boolean_expresssionsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case003.json"));
 }
 
-// 
+// true or false
 TEST_F(boolean_expresssionsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case004.json"));
 }
 
-// 
+// true or true
 TEST_F(boolean_expresssionsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case005.json"));
 }
 
-// 
+// false and false
 TEST_F(boolean_expresssionsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case006.json"));
 }
 
-// 
+// false and true
 TEST_F(boolean_expresssionsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case007.json"));
 }
 
-// 
+// true and false
 TEST_F(boolean_expresssionsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case008.json"));
 }
 
-// 
+// true and true
 TEST_F(boolean_expresssionsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case009.json"));
 }
 
-// 
+// $not(false)
 TEST_F(boolean_expresssionsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case010.json"));
 }
 
-// 
+// $not(true)
 TEST_F(boolean_expresssionsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case011.json"));
 }
 
-// 
+// and=1 and or=2
 TEST_F(boolean_expresssionsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case012.json"));
 }
 
-// 
+// and>1 or or<=2
 TEST_F(boolean_expresssionsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case013.json"));
 }
 
-// 
+// and>1 or or!=2
 TEST_F(boolean_expresssionsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case014.json"));
 }
 
-// 
+// and and and
 TEST_F(boolean_expresssionsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case015.json"));
 }
 
-// 
+// $[].content.origin.$lowercase(name)
 TEST_F(boolean_expresssionsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case016.json"));
 }
 
-// 
+// true or foo
 TEST_F(boolean_expresssionsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case017.json"));
 }
 
-// 
+// foo or true
 TEST_F(boolean_expresssionsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case018.json"));
 }
 
-// 
+// false or foo
 TEST_F(boolean_expresssionsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case019.json"));
 }
 
-// 
+// foo or false
 TEST_F(boolean_expresssionsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case020.json"));
 }
 
-// 
+// foo or bar
 TEST_F(boolean_expresssionsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case021.json"));
 }
 
-// 
+// true and foo
 TEST_F(boolean_expresssionsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case022.json"));
 }
 
-// 
+// foo and true
 TEST_F(boolean_expresssionsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case023.json"));
 }
 
-// 
+// false and foo
 TEST_F(boolean_expresssionsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case024.json"));
 }
 
-// 
+// foo and false
 TEST_F(boolean_expresssionsTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case025.json"));
 }
 
-// 
+// foo and bar
 TEST_F(boolean_expresssionsTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case026.json"));
 }
 
-// 
+// $not(nothing)
 TEST_F(boolean_expresssionsTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case027.json"));
 }
 
-// 
+// foo = '' or $number(foo) = 0
 TEST_F(boolean_expresssionsTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case028.json"));
 }
 
-// 
+// $type(data) = 'number' and data > 10
 TEST_F(boolean_expresssionsTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case029.json"));
 }
 
-// 
+// $type(age) = 'number' or $number(age) > 0
 TEST_F(boolean_expresssionsTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/boolean-expresssions/case030.json"));
 }
diff --git a/test/gen/closuresTest.cpp b/test/gen/closuresTest.cpp
index 2c122a2..6c43ef4 100644
--- a/test/gen/closuresTest.cpp
+++ b/test/gen/closuresTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class closuresTest : public JsonataTest {
 };
 
-// 
+// Account.(  $AccName := function() { $.\"Account Name\" };  Order[OrderID = \"order104\"].Product{    \"Account\": $AccName(),    \"SKU-\" & $string(ProductID): $.\"Product Name\"  } )
 TEST_F(closuresTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/closures/case000.json"));
 }
 
-// 
+// Account.(  $AccName := function() { `Account Name` };  Order[OrderID = \"order104\"].Product{    \"Account\": $AccName(),    \"SKU-\" & $string(ProductID): `Product Name`  } )
 TEST_F(closuresTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/closures/case001.json"));
 }
diff --git a/test/gen/coalescing_operatorTest.cpp b/test/gen/coalescing_operatorTest.cpp
index 4d80b9c..ab33e80 100644
--- a/test/gen/coalescing_operatorTest.cpp
+++ b/test/gen/coalescing_operatorTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class coalescing_operatorTest : public JsonataTest {
 };
 
-// 
+// bar ?? 42
 TEST_F(coalescing_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case000.json"));
 }
 
-// 
+// foo.bar ?? 98
 TEST_F(coalescing_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case001.json"));
 }
 
-// 
+// foo.blah[0].baz.fud ?? 98
 TEST_F(coalescing_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case002.json"));
 }
 
-// 
+// baz ?? 42
 TEST_F(coalescing_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case003.json"));
 }
 
-// 
+// foo.baz ?? 42
 TEST_F(coalescing_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case004.json"));
 }
 
-// 
+// foo.blah[9].baz.fud ?? 42
 TEST_F(coalescing_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case005.json"));
 }
 
-// 
+// null ?? 42
 TEST_F(coalescing_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case006.json"));
 }
 
-// 
+// false ?? 42
 TEST_F(coalescing_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case007.json"));
 }
 
-// 
+// true ?? 42
 TEST_F(coalescing_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case008.json"));
 }
 
-// 
+// 0 ?? 42
 TEST_F(coalescing_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case009.json"));
 }
 
-// 
+// [] ?? 42
 TEST_F(coalescing_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case010.json"));
 }
 
-// 
+// {} ?? 42
 TEST_F(coalescing_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case011.json"));
 }
 
-// 
+// \"\" ?? 42
 TEST_F(coalescing_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/coalescing-operator/case012.json"));
 }
diff --git a/test/gen/comparison_operatorsTest.cpp b/test/gen/comparison_operatorsTest.cpp
index 372690a..3e8d12d 100644
--- a/test/gen/comparison_operatorsTest.cpp
+++ b/test/gen/comparison_operatorsTest.cpp
@@ -6,153 +6,243 @@ using namespace jsonata;
 class comparison_operatorsTest : public JsonataTest {
 };
 
-// 
+// 3>-3
 TEST_F(comparison_operatorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case000.json"));
 }
 
-// 
+// 3>3
 TEST_F(comparison_operatorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case001.json"));
 }
 
-// 
+// 3=3
 TEST_F(comparison_operatorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case002.json"));
 }
 
-// 
+// \"3\"=\"3\"
 TEST_F(comparison_operatorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case003.json"));
 }
 
-// 
+// \"3\"=3
 TEST_F(comparison_operatorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case004.json"));
 }
 
-// 
+// \"hello\" = \"hello\"
 TEST_F(comparison_operatorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case005.json"));
 }
 
-// 
+// \"hello\" != \"world\"
 TEST_F(comparison_operatorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case006.json"));
 }
 
-// 
+// \"hello\" < \"world\"
 TEST_F(comparison_operatorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case007.json"));
 }
 
-// 
+// \"32\" < 42
 TEST_F(comparison_operatorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case008.json"));
 }
 
-// 
+// null <= \"world\"
 TEST_F(comparison_operatorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case009.json"));
 }
 
-// 
+// 3 >= true
 TEST_F(comparison_operatorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case010.json"));
 }
 
-// 
+// foo.bar > bar
 TEST_F(comparison_operatorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case011.json"));
 }
 
-// 
+// foo.bar >= bar
 TEST_F(comparison_operatorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case012.json"));
 }
 
-// 
+// foo.bar<bar
 TEST_F(comparison_operatorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case013.json"));
 }
 
-// 
+// foo.bar<=bar
 TEST_F(comparison_operatorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case014.json"));
 }
 
-// 
+// bar>foo.bar
 TEST_F(comparison_operatorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case015.json"));
 }
 
-// 
+// bar < foo.bar
 TEST_F(comparison_operatorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case016.json"));
 }
 
-// 
+// foo.bar = bar
 TEST_F(comparison_operatorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case017.json"));
 }
 
-// 
+// foo.bar!= bar
 TEST_F(comparison_operatorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case018.json"));
 }
 
-// 
+// bar = foo.bar + 56
 TEST_F(comparison_operatorsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case019.json"));
 }
 
-// 
+// bar !=foo.bar + 56
 TEST_F(comparison_operatorsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case020.json"));
 }
 
-// 
+// foo.blah.baz[fud = \"hello\"]
 TEST_F(comparison_operatorsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case021.json"));
 }
 
-// 
+// foo.blah.baz[fud != \"world\"]
 TEST_F(comparison_operatorsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case022.json"));
 }
 
-// 
+// Account.Order.Product[Price > 30].Price
 TEST_F(comparison_operatorsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case023.json"));
 }
 
-// 
+// Account.Order.Product.Price[$<=35]
 TEST_F(comparison_operatorsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case024.json"));
 }
 
-// 
+// false > 1
 TEST_F(comparison_operatorsTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case025.json"));
 }
 
-// 
+// false > $x
 TEST_F(comparison_operatorsTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case026.json"));
 }
 
-// 
+// 3 > $x
 TEST_F(comparison_operatorsTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case027.json"));
 }
 
-// 
+// $x <= 'hello'
 TEST_F(comparison_operatorsTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/case028.json"));
 }
 
-// 
-TEST_F(comparison_operatorsTest, deep_equals) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json"));
+// [1,2,3,4] = [1, 2, 3, 4]
+TEST_F(comparison_operatorsTest, deep_equals_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 0));
+}
+
+// [1,2] != [1, 2]
+TEST_F(comparison_operatorsTest, deep_equals_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 1));
+}
+
+// [1,2,[3],4] = [1, 2, [3], 4]
+TEST_F(comparison_operatorsTest, deep_equals_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 2));
+}
+
+// [1,2,3,4] = [1, 2, [3], 4]
+TEST_F(comparison_operatorsTest, deep_equals_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 3));
+}
+
+// [1,2,3,4] = [2, 3, 4]
+TEST_F(comparison_operatorsTest, deep_equals_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 4));
+}
+
+// data = [1, 2, 3, 4]
+TEST_F(comparison_operatorsTest, deep_equals_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 5));
+}
+
+// data[2] = 3
+TEST_F(comparison_operatorsTest, deep_equals_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 6));
+}
+
+// { 'one': 1, 'two': 2 } = { 'two': 2, 'one': 1 }
+TEST_F(comparison_operatorsTest, deep_equals_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 7));
+}
+
+// { 'one': 1, 'two': 2 } = { 'too': 2, 'one': 1 }
+TEST_F(comparison_operatorsTest, deep_equals_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 8));
+}
+
+// { 'one': 1, 'two': 3 } = { 'two': 2, 'one': 1 }
+TEST_F(comparison_operatorsTest, deep_equals_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 9));
+}
+
+// { 'one': 1, 'two': 2, 'three': 3 } = { 'two': 2, 'one': 1 }
+TEST_F(comparison_operatorsTest, deep_equals_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 10));
+}
+
+// two = 2
+TEST_F(comparison_operatorsTest, deep_equals_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 11));
+}
+
+// one + one = two
+TEST_F(comparison_operatorsTest, deep_equals_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 12));
+}
+
+// null = null
+TEST_F(comparison_operatorsTest, deep_equals_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 13));
+}
+
+// null != null
+TEST_F(comparison_operatorsTest, deep_equals_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 14));
+}
+
+// null = nothing
+TEST_F(comparison_operatorsTest, deep_equals_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 15));
+}
+
+// nothing = nothing
+TEST_F(comparison_operatorsTest, deep_equals_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 16));
+}
+
+// Account.Order[0].Product[0].Description = Account.Order[1].Product[0].Description
+TEST_F(comparison_operatorsTest, deep_equals_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 17));
+}
+
+// Account.Order[0].Product[0] = Account.Order[1].Product[0]
+TEST_F(comparison_operatorsTest, deep_equals_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/comparison-operators/deep-equals.json", 18));
 }
 
diff --git a/test/gen/conditionalsTest.cpp b/test/gen/conditionalsTest.cpp
index 9fbad66..ed32956 100644
--- a/test/gen/conditionalsTest.cpp
+++ b/test/gen/conditionalsTest.cpp
@@ -6,47 +6,47 @@ using namespace jsonata;
 class conditionalsTest : public JsonataTest {
 };
 
-// 
+// [\"Red\"[$$=\"Bus\"], \"White\"[$$=\"Police Car\"]][0]
 TEST_F(conditionalsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case000.json"));
 }
 
-// 
+// [\"Red\"[$$=\"Bus\"], \"White\"[$$=\"Police Car\"]][0]
 TEST_F(conditionalsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case001.json"));
 }
 
-// 
+// [\"Red\"[$$=\"Bus\"], \"White\"[$$=\"Police Car\"]][0]
 TEST_F(conditionalsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case002.json"));
 }
 
-// 
+// $lookup({\"Bus\": \"Red\", \"Police Car\": \"White\"}, $$)
 TEST_F(conditionalsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case003.json"));
 }
 
-// 
+// $lookup({\"Bus\": \"Red\", \"Police Car\": \"White\"}, $$)
 TEST_F(conditionalsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case004.json"));
 }
 
-// 
+// $lookup({\"Bus\": \"Red\", \"Police Car\": \"White\"}, $$)
 TEST_F(conditionalsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case005.json"));
 }
 
-// 
+// Account.Order.Product.(Price < 30 ? \"Cheap\")
 TEST_F(conditionalsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case006.json"));
 }
 
-// 
+// Account.Order.Product.(Price < 30 ? \"Cheap\" : \"Expensive\")
 TEST_F(conditionalsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case007.json"));
 }
 
-// 
+// Account.Order.Product.(Price < 30 ? \"Cheap\" : Price < 100 ? \"Expensive\" : \"Rip off\")
 TEST_F(conditionalsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/conditionals/case008.json"));
 }
diff --git a/test/gen/contextTest.cpp b/test/gen/contextTest.cpp
index e150b4e..bb1841f 100644
--- a/test/gen/contextTest.cpp
+++ b/test/gen/contextTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class contextTest : public JsonataTest {
 };
 
-// 
+// $number()
 TEST_F(contextTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case000.json"));
 }
 
-// 
+// [1..5].$string()
 TEST_F(contextTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case001.json"));
 }
 
-// 
+// [1..5].(\"Item \" & $string())
 TEST_F(contextTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case002.json"));
 }
 
-// 
+// Account.Order.Product.\"Product Name\".$uppercase().$substringBefore(\" \")
 TEST_F(contextTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/context/case003.json"));
 }
diff --git a/test/gen/default_operatorTest.cpp b/test/gen/default_operatorTest.cpp
index 81cfa53..804beba 100644
--- a/test/gen/default_operatorTest.cpp
+++ b/test/gen/default_operatorTest.cpp
@@ -6,72 +6,72 @@ using namespace jsonata;
 class default_operatorTest : public JsonataTest {
 };
 
-// 
+// true ?: 42
 TEST_F(default_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case000.json"));
 }
 
-// 
+// false ?: 42
 TEST_F(default_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case001.json"));
 }
 
-// 
+// 1 ?: 42
 TEST_F(default_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case002.json"));
 }
 
-// 
+// 0 ?: 42
 TEST_F(default_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case003.json"));
 }
 
-// 
+// \"hello\" ?: 42
 TEST_F(default_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case004.json"));
 }
 
-// 
+// \"\" ?: 42
 TEST_F(default_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case005.json"));
 }
 
-// 
+// [1] ?: 42
 TEST_F(default_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case006.json"));
 }
 
-// 
+// [0] ?: 42
 TEST_F(default_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case007.json"));
 }
 
-// 
+// [] ?: 42
 TEST_F(default_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case008.json"));
 }
 
-// 
+// { \"a\": 1 } ?: 42
 TEST_F(default_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case009.json"));
 }
 
-// 
+// {} ?: 42
 TEST_F(default_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case010.json"));
 }
 
-// 
+// function(){true} ?: 42
 TEST_F(default_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case011.json"));
 }
 
-// 
+// Account.blah ?: 42
 TEST_F(default_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case012.json"));
 }
 
-// 
+// Account.blah ?: 42
 TEST_F(default_operatorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/default-operator/case013.json"));
 }
diff --git a/test/gen/descendent_operatorTest.cpp b/test/gen/descendent_operatorTest.cpp
index 873837b..2366c17 100644
--- a/test/gen/descendent_operatorTest.cpp
+++ b/test/gen/descendent_operatorTest.cpp
@@ -6,87 +6,87 @@ using namespace jsonata;
 class descendent_operatorTest : public JsonataTest {
 };
 
-// 
+// foo.**.blah
 TEST_F(descendent_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case000.json"));
 }
 
-// 
+// foo.**.baz
 TEST_F(descendent_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case001.json"));
 }
 
-// 
+// foo.**.fud
 TEST_F(descendent_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case002.json"));
 }
 
-// 
+// \"foo\".**.fud
 TEST_F(descendent_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case003.json"));
 }
 
-// 
+// foo.**.\"fud\"
 TEST_F(descendent_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case004.json"));
 }
 
-// 
+// \"foo\".**.\"fud\"
 TEST_F(descendent_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case005.json"));
 }
 
-// 
+// foo.*.**.fud
 TEST_F(descendent_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case006.json"));
 }
 
-// 
+// foo.**.*.fud
 TEST_F(descendent_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case007.json"));
 }
 
-// 
+// Account.Order.**.Colour
 TEST_F(descendent_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case008.json"));
 }
 
-// 
+// foo.**.fud[0]
 TEST_F(descendent_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case009.json"));
 }
 
-// 
+// (foo.**.fud)[0]
 TEST_F(descendent_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case010.json"));
 }
 
-// 
+// (**.fud)[0]
 TEST_F(descendent_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case011.json"));
 }
 
-// 
+// **.Price
 TEST_F(descendent_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case012.json"));
 }
 
-// 
+// **.Price[0]
 TEST_F(descendent_operatorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case013.json"));
 }
 
-// 
+// (**.Price)[0]
 TEST_F(descendent_operatorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case014.json"));
 }
 
-// 
+// Account.Order.blah.**
 TEST_F(descendent_operatorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case015.json"));
 }
 
-// 
+// **
 TEST_F(descendent_operatorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/descendent-operator/case016.json"));
 }
diff --git a/test/gen/encodingTest.cpp b/test/gen/encodingTest.cpp
index c4d3ebf..6c23ffb 100644
--- a/test/gen/encodingTest.cpp
+++ b/test/gen/encodingTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class encodingTest : public JsonataTest {
 };
 
-// 
+// $base64encode(\"hello:world\")
 TEST_F(encodingTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case000.json"));
 }
 
-// 
+// $base64encode()
 TEST_F(encodingTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case001.json"));
 }
 
-// 
+// $base64decode(\"aGVsbG86d29ybGQ=\")
 TEST_F(encodingTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case002.json"));
 }
 
-// 
+// $base64decode()
 TEST_F(encodingTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/encoding/case003.json"));
 }
diff --git a/test/gen/errorsTest.cpp b/test/gen/errorsTest.cpp
index aaca7e0..409d21e 100644
--- a/test/gen/errorsTest.cpp
+++ b/test/gen/errorsTest.cpp
@@ -6,137 +6,137 @@ using namespace jsonata;
 class errorsTest : public JsonataTest {
 };
 
-// 
+// \"s\" - 1
 TEST_F(errorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case000.json"));
 }
 
-// 
+// 1 + null
 TEST_F(errorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case001.json"));
 }
 
-// 
+// \"no closing quote
 TEST_F(errorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case002.json"));
 }
 
-// 
+// `no closing backtick
 TEST_F(errorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case003.json"));
 }
 
-// 
+// - \"s\"
 TEST_F(errorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case004.json"));
 }
 
-// 
+// unknown(function)
 TEST_F(errorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case005.json"));
 }
 
-// 
+// sum(Account.Order.OrderID)
 TEST_F(errorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case006.json"));
 }
 
-// 
+// [1,2)
 TEST_F(errorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case007.json"));
 }
 
-// 
+// [1:2]
 TEST_F(errorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case008.json"));
 }
 
-// 
+// $replace(\"foo\", \"o, \"rr\")
 TEST_F(errorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case009.json"));
 }
 
-// 
+// [1!2]
 TEST_F(errorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case010.json"));
 }
 
-// 
+// @ bar
 TEST_F(errorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case011.json"));
 }
 
-// 
+// 2(blah)
 TEST_F(errorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case012.json"));
 }
 
-// 
+// 2()
 TEST_F(errorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case013.json"));
 }
 
-// 
+// 3(?)
 TEST_F(errorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case014.json"));
 }
 
-// 
+// 1=
 TEST_F(errorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case015.json"));
 }
 
-// 
+// function(x){$x}(3)
 TEST_F(errorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case016.json"));
 }
 
-// 
+// x:=1
 TEST_F(errorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case017.json"));
 }
 
-// 
+// 2:=1
 TEST_F(errorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case018.json"));
 }
 
-// 
+// $foo()
 TEST_F(errorsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case019.json"));
 }
 
-// 
+// 55=>5
 TEST_F(errorsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case020.json"));
 }
 
-// 
+// Ssum(:)
 TEST_F(errorsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case021.json"));
 }
 
-// 
+// [1,2,3]{\"num\": $}[true]
 TEST_F(errorsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case022.json"));
 }
 
-// 
+// [1,2,3]{\"num\": $}{\"num\": $}
 TEST_F(errorsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case023.json"));
 }
 
-// 
+// Account.Order[0].Product;
 TEST_F(errorsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case024.json"));
 }
 
-// 
+// ( $A := function(){$min(2, 3)}; $A() )
 TEST_F(errorsTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case025.json"));
 }
 
-// 
+// ( $B := function(){''}; $A := function(){2 + $B()}; $A() )
 TEST_F(errorsTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/errors/case026.json"));
 }
diff --git a/test/gen/fieldsTest.cpp b/test/gen/fieldsTest.cpp
index 8fc2679..1bea704 100644
--- a/test/gen/fieldsTest.cpp
+++ b/test/gen/fieldsTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class fieldsTest : public JsonataTest {
 };
 
-// 
+// foo.bar
 TEST_F(fieldsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case000.json"));
 }
 
-// 
+// foo.blah
 TEST_F(fieldsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case001.json"));
 }
 
-// 
+// foo.blah.bazz
 TEST_F(fieldsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case002.json"));
 }
 
-// 
+// foo.blah.baz
 TEST_F(fieldsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case003.json"));
 }
 
-// 
+// foo.blah.baz.fud
 TEST_F(fieldsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case004.json"));
 }
 
-// 
+// Other.Misc
 TEST_F(fieldsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case005.json"));
 }
 
-// 
+// bazz
 TEST_F(fieldsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case006.json"));
 }
 
-// 
+// fud
 TEST_F(fieldsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/fields/case007.json"));
 }
diff --git a/test/gen/flatteningTest.cpp b/test/gen/flatteningTest.cpp
index f5243de..e5a3846 100644
--- a/test/gen/flatteningTest.cpp
+++ b/test/gen/flatteningTest.cpp
@@ -6,253 +6,308 @@ using namespace jsonata;
 class flatteningTest : public JsonataTest {
 };
 
-// 
-TEST_F(flatteningTest, array_inputs) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/array-inputs.json"));
+// phone
+TEST_F(flatteningTest, array_inputs_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 0));
 }
 
-// 
+// phone[0]
+TEST_F(flatteningTest, array_inputs_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 1));
+}
+
+// phone[0][]
+TEST_F(flatteningTest, array_inputs_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 2));
+}
+
+// phone[0].number
+TEST_F(flatteningTest, array_inputs_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 3));
+}
+
+// (phone)[0].number
+TEST_F(flatteningTest, array_inputs_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 4));
+}
+
+// $.phone[0].number
+TEST_F(flatteningTest, array_inputs_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 5));
+}
+
+// {'Hello':'World'}
+TEST_F(flatteningTest, array_inputs_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 6));
+}
+
+// $.{'Hello':'World'}
+TEST_F(flatteningTest, array_inputs_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/array-inputs.json", 7));
+}
+
+// Account.Order.[Product.Price]
 TEST_F(flatteningTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case000.json"));
 }
 
-// 
+// $.nest0
 TEST_F(flatteningTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case001.json"));
 }
 
-// 
+// nest0
 TEST_F(flatteningTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case002.json"));
 }
 
-// 
+// $[0]
 TEST_F(flatteningTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case003.json"));
 }
 
-// 
+// $[1]
 TEST_F(flatteningTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case004.json"));
 }
 
-// 
+// $[-1]
 TEST_F(flatteningTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case005.json"));
 }
 
-// 
+// $[0].nest0
 TEST_F(flatteningTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case006.json"));
 }
 
-// 
+// $[1].nest0
 TEST_F(flatteningTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case007.json"));
 }
 
-// 
+// $[0].nest0[0]
 TEST_F(flatteningTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case008.json"));
 }
 
-// 
+// nest0.[nest1.[nest2.[nest3]]]
 TEST_F(flatteningTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case009.json"));
 }
 
-// 
+// nest0.nest1.[nest2.[nest3]]
 TEST_F(flatteningTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case010.json"));
 }
 
-// 
+// nest0.[nest1.nest2.[nest3]]
 TEST_F(flatteningTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case011.json"));
 }
 
-// 
+// nest0.[nest1.[nest2.nest3]]
 TEST_F(flatteningTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case012.json"));
 }
 
-// 
+// nest0.[nest1.nest2.nest3]
 TEST_F(flatteningTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case013.json"));
 }
 
-// 
+// nest0.nest1.[nest2.nest3]
 TEST_F(flatteningTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case014.json"));
 }
 
-// 
+// nest0.nest1.nest2.[nest3]
 TEST_F(flatteningTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case015.json"));
 }
 
-// 
+// nest0.nest1.nest2.nest3
 TEST_F(flatteningTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case016.json"));
 }
 
-// 
+// nest0.[nest1.[nest2.[nest3]]]
 TEST_F(flatteningTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case017.json"));
 }
 
-// 
+// nest0.nest1.[nest2.[nest3]]
 TEST_F(flatteningTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case018.json"));
 }
 
-// 
+// nest0.[nest1.nest2.[nest3]]
 TEST_F(flatteningTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case019.json"));
 }
 
-// 
+// nest0.[nest1.[nest2.nest3]]
 TEST_F(flatteningTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case020.json"));
 }
 
-// 
+// nest0.[nest1.nest2.nest3]
 TEST_F(flatteningTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case021.json"));
 }
 
-// 
+// nest0.nest1.[nest2.nest3]
 TEST_F(flatteningTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case022.json"));
 }
 
-// 
+// nest0.nest1.nest2.[nest3]
 TEST_F(flatteningTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case023.json"));
 }
 
-// 
+// nest0.nest1.nest2.nest3
 TEST_F(flatteningTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case024.json"));
 }
 
-// 
+// {\"a\": 1 }.a
 TEST_F(flatteningTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case025.json"));
 }
 
-// 
+// a
 TEST_F(flatteningTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case026.json"));
 }
 
-// 
+// {\"a\": [1] }.a
 TEST_F(flatteningTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case027.json"));
 }
 
-// 
+// a
 TEST_F(flatteningTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case028.json"));
 }
 
-// 
+// {\"a\": [[1]] }.a
 TEST_F(flatteningTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case029.json"));
 }
 
-// 
+// a
 TEST_F(flatteningTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case030.json"));
 }
 
-// 
+// [{\"a\":[1,2]}, {\"a\":[3]}].a
 TEST_F(flatteningTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case031.json"));
 }
 
-// 
+// a
 TEST_F(flatteningTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case032.json"));
 }
 
-// 
+// [{\"a\":[{\"b\":[1]}, {\"b\":[2]}]}, {\"a\":[{\"b\":[3]}, {\"b\":[4]}]}].a[0].b
 TEST_F(flatteningTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case033.json"));
 }
 
-// 
+// a[0].b
 TEST_F(flatteningTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case034.json"));
 }
 
-// 
+// $.a[0].b
 TEST_F(flatteningTest, case034a) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case034a.json"));
 }
 
-// 
+// a.b[0]
 TEST_F(flatteningTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case035.json"));
 }
 
-// 
+// Phone[type=\"mobile\"].number
 TEST_F(flatteningTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case036.json"));
 }
 
-// 
+// Phone[type=\"mobile\"][].number
 TEST_F(flatteningTest, case037) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case037.json"));
 }
 
-// 
+// Phone[][type=\"mobile\"].number
 TEST_F(flatteningTest, case038) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case038.json"));
 }
 
-// 
+// Phone[type=\"office\"][].number
 TEST_F(flatteningTest, case039) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case039.json"));
 }
 
-// 
+// Phone{type: number}
 TEST_F(flatteningTest, case040) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case040.json"));
 }
 
-// 
+// Phone{type: number[]}
 TEST_F(flatteningTest, case041) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case041.json"));
 }
 
-// 
+// $[type='command'][]
 TEST_F(flatteningTest, case042) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case042.json"));
 }
 
-// 
+// $[][type='command']
 TEST_F(flatteningTest, case043) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case043.json"));
 }
 
-// 
+// $filter($, function($e) { $e != 0 })[]
 TEST_F(flatteningTest, case044) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case044.json"));
 }
 
-// 
+// $.tags[title='example'][]
 TEST_F(flatteningTest, case045) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/case045.json"));
 }
 
-// 
-TEST_F(flatteningTest, large) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/large.json"));
+// ( $data := { 'number': [1..2e5].$string() }; $values := $data.number; $count($values) )
+TEST_F(flatteningTest, large_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/large.json", 0));
+}
+
+// ( $data := { 'number': [1..2e5].$string() }; $values := $lookup($data, 'number'); $count($values) )
+TEST_F(flatteningTest, large_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/large.json", 1));
+}
+
+// $.[value,epochSeconds]
+TEST_F(flatteningTest, sequence_of_arrays_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 0));
+}
+
+// $.[value,epochSeconds]
+TEST_F(flatteningTest, sequence_of_arrays_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 1));
+}
+
+// $.[value,epochSeconds][]
+TEST_F(flatteningTest, sequence_of_arrays_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 2));
 }
 
-// 
-TEST_F(flatteningTest, sequence_of_arrays) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json"));
+// $.[value,epochSeconds][]
+TEST_F(flatteningTest, sequence_of_arrays_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/flattening/sequence-of-arrays.json", 3));
 }
 
diff --git a/test/gen/function_absTest.cpp b/test/gen/function_absTest.cpp
index 5dafcdf..5561a25 100644
--- a/test/gen/function_absTest.cpp
+++ b/test/gen/function_absTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_absTest : public JsonataTest {
 };
 
-// 
+// $abs(3.7)
 TEST_F(function_absTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case000.json"));
 }
 
-// 
+// $abs(-3.7)
 TEST_F(function_absTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case001.json"));
 }
 
-// 
+// $abs(0)
 TEST_F(function_absTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case002.json"));
 }
 
-// 
+// $abs(nothing)
 TEST_F(function_absTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-abs/case003.json"));
 }
diff --git a/test/gen/function_appendTest.cpp b/test/gen/function_appendTest.cpp
index eef3608..97f328c 100644
--- a/test/gen/function_appendTest.cpp
+++ b/test/gen/function_appendTest.cpp
@@ -6,32 +6,32 @@ using namespace jsonata;
 class function_appendTest : public JsonataTest {
 };
 
-// 
+// $append([1,2], [3,4])
 TEST_F(function_appendTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case000.json"));
 }
 
-// 
+// $append(1, [3,4])
 TEST_F(function_appendTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case001.json"));
 }
 
-// 
+// $append(1,2)
 TEST_F(function_appendTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case002.json"));
 }
 
-// 
+// $append(1,notexist)
 TEST_F(function_appendTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case003.json"));
 }
 
-// 
+// $append(notexist, [2,3,4])
 TEST_F(function_appendTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case004.json"));
 }
 
-// 
+// ($append($data.a, [2]); $data.a)
 TEST_F(function_appendTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-append/case005.json"));
 }
diff --git a/test/gen/function_applicationsTest.cpp b/test/gen/function_applicationsTest.cpp
index 51fb5b3..70e63c9 100644
--- a/test/gen/function_applicationsTest.cpp
+++ b/test/gen/function_applicationsTest.cpp
@@ -6,112 +6,112 @@ using namespace jsonata;
 class function_applicationsTest : public JsonataTest {
 };
 
-// 
+// Account.Order[0].OrderID ~> $uppercase()
 TEST_F(function_applicationsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case000.json"));
 }
 
-// 
+// Account.Order[0].OrderID ~> $uppercase() ~> $lowercase()
 TEST_F(function_applicationsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case001.json"));
 }
 
-// 
+// Account.Order.OrderID ~> $join()
 TEST_F(function_applicationsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case002.json"));
 }
 
-// 
+// Account.Order.OrderID ~> $join(\", \")
 TEST_F(function_applicationsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case003.json"));
 }
 
-// 
+// Account.Order.Product.(Price * Quantity) ~> $sum()
 TEST_F(function_applicationsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case004.json"));
 }
 
-// 
+// ( $uppertrim := $trim ~> $uppercase;  $uppertrim(\"   Hello    World   \") )
 TEST_F(function_applicationsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case005.json"));
 }
 
-// 
+// \"john@example.com\" ~> $substringAfter(\"@\") ~> $substringBefore(\".\") 
 TEST_F(function_applicationsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case006.json"));
 }
 
-// 
+// \"\" ~> $substringAfter(\"@\") ~> $substringBefore(\".\") 
 TEST_F(function_applicationsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case007.json"));
 }
 
-// 
+// foo ~> $substringAfter(\"@\") ~> $substringBefore(\".\") 
 TEST_F(function_applicationsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case008.json"));
 }
 
-// 
+// ( $domain := $substringAfter(?,\"@\") ~> $substringBefore(?,\".\"); $domain(\"john@example.com\") )
 TEST_F(function_applicationsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case009.json"));
 }
 
-// 
+// ( $square := function($x){$x*$x}; [1..5] ~> $map($square) ) 
 TEST_F(function_applicationsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case010.json"));
 }
 
-// 
+// ( $square := function($x){$x*$x}; [1..5] ~> $map($square) ~> $sum() ) 
 TEST_F(function_applicationsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case011.json"));
 }
 
-// 
+// ($betweenBackets := $substringAfter(?, \"(\") ~> $substringBefore(?, \")\");$betweenBackets(\"test(foo)bar\")) 
 TEST_F(function_applicationsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case012.json"));
 }
 
-// 
+// ($square := function($x){$x*$x};$chain := λ($f, $g){λ($x){$g($f($x))}};$instructions := [$sum, $square];$sumsq := $instructions ~> $reduce($chain);[1..5] ~> $sumsq()) 
 TEST_F(function_applicationsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case013.json"));
 }
 
-// 
+// ($square := function($x){$x*$x};$chain := λ($f, $g){λ($x){ $x ~> $f ~> $g }};$instructions := [$sum, $square, $string];$sumsq := $instructions ~> $reduce($chain);[1..5] ~> $sumsq()) 
 TEST_F(function_applicationsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case014.json"));
 }
 
-// 
+// ($square := function($x){$x*$x};$instructions := $sum ~> $square;[1..5] ~> $instructions())  
 TEST_F(function_applicationsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case015.json"));
 }
 
-// 
+// ($square := function($x){$x*$x};$sum_of_squares := $map(?, $square) ~> $sum;[1..5] ~> $sum_of_squares())  
 TEST_F(function_applicationsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case016.json"));
 }
 
-// 
+// ($times := λ($x, $y) { $x * $y };$product := $reduce(?, $times);$square := function($x){$x*$x};$product_of_squares := $map(?, $square) ~> $product;[1..5] ~> $product_of_squares())
 TEST_F(function_applicationsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case017.json"));
 }
 
-// 
+// ($square := function($x){$x*$x};[1..5] ~> $map($square) ~> $reduce(λ($x, $y) { $x * $y });)
 TEST_F(function_applicationsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case018.json"));
 }
 
-// 
+// ($prices := Account.Order.Product.Price;$quantities := Account.Order.Product.Quantity;$product := λ($arr) { $arr[0] * $arr[1] };$zip($prices, $quantities) ~> $map($product) ~> $sum())
 TEST_F(function_applicationsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case019.json"));
 }
 
-// 
+// 42 ~> \"hello\"
 TEST_F(function_applicationsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case020.json"));
 }
 
-// 
+// Account.Order.Product[$.\"Product Name\" ~> /hat/i].ProductID
 TEST_F(function_applicationsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-applications/case021.json"));
 }
diff --git a/test/gen/function_assertTest.cpp b/test/gen/function_assertTest.cpp
index 2fef6c7..17dbf38 100644
--- a/test/gen/function_assertTest.cpp
+++ b/test/gen/function_assertTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class function_assertTest : public JsonataTest {
 };
 
-// 
+// $assert(Account.Order[0].Product[0].Price < 34, 'Too Expensive')
 TEST_F(function_assertTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case000.json"));
 }
 
-// 
+// $assert(Account.Order[0].Product[0].Price < 35, 'Too Expensive')
 TEST_F(function_assertTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case001.json"));
 }
 
-// 
+// ($assert(Account.Order[0].Product[0].Price < 35, 'Too Expensive'); Account.Order[0].Product[0].Price)
 TEST_F(function_assertTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case002.json"));
 }
 
-// 
+// ($assert(Account.Order[0].Product[0].Price < 34, 'Too Expensive'); Account.Order[0].Product[0].Price)
 TEST_F(function_assertTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case003.json"));
 }
 
-// 
+// $assert(null)
 TEST_F(function_assertTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case004.json"));
 }
 
-// 
+// $assert(5)
 TEST_F(function_assertTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case005.json"));
 }
 
-// 
+// $assert(false)
 TEST_F(function_assertTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case006.json"));
 }
 
-// 
+// $assert(true)
 TEST_F(function_assertTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-assert/case007.json"));
 }
diff --git a/test/gen/function_averageTest.cpp b/test/gen/function_averageTest.cpp
index 626845f..911067c 100644
--- a/test/gen/function_averageTest.cpp
+++ b/test/gen/function_averageTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class function_averageTest : public JsonataTest {
 };
 
-// 
+// $average(Account.Order.Product.(Price * Quantity))
 TEST_F(function_averageTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case000.json"));
 }
 
-// 
+// Account.Order.$average(Product.(Price * Quantity))
 TEST_F(function_averageTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case001.json"));
 }
 
-// 
+// Account.Order.(OrderID & \": \" & $average(Product.(Price*Quantity)))
 TEST_F(function_averageTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case002.json"));
 }
 
-// 
+// $average([])
 TEST_F(function_averageTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case003.json"));
 }
 
-// 
+// $average([1,2,3])
 TEST_F(function_averageTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case004.json"));
 }
 
-// 
+// $average([\"1\",\"2\",\"3\"])
 TEST_F(function_averageTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case005.json"));
 }
 
-// 
+// $average([\"1\",\"2\",3])
 TEST_F(function_averageTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case006.json"));
 }
 
-// 
+// $average(1)
 TEST_F(function_averageTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case007.json"));
 }
 
-// 
+// $average([],[])
 TEST_F(function_averageTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case008.json"));
 }
 
-// 
+// $average([1,2,3],[])
 TEST_F(function_averageTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case009.json"));
 }
 
-// 
+// $average([],[],[])
 TEST_F(function_averageTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case010.json"));
 }
 
-// 
+// $average([1,2],[],[])
 TEST_F(function_averageTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case011.json"));
 }
 
-// 
+// $average(undefined)
 TEST_F(function_averageTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-average/case012.json"));
 }
diff --git a/test/gen/function_booleanTest.cpp b/test/gen/function_booleanTest.cpp
index a37d540..a2006f8 100644
--- a/test/gen/function_booleanTest.cpp
+++ b/test/gen/function_booleanTest.cpp
@@ -6,122 +6,122 @@ using namespace jsonata;
 class function_booleanTest : public JsonataTest {
 };
 
-// 
+// $boolean(\"Hello World\")
 TEST_F(function_booleanTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case000.json"));
 }
 
-// 
+// $boolean(\"\")
 TEST_F(function_booleanTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case001.json"));
 }
 
-// 
+// $boolean(true)
 TEST_F(function_booleanTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case002.json"));
 }
 
-// 
+// $boolean(false)
 TEST_F(function_booleanTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case003.json"));
 }
 
-// 
+// $boolean(0)
 TEST_F(function_booleanTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case004.json"));
 }
 
-// 
+// $boolean(10)
 TEST_F(function_booleanTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case005.json"));
 }
 
-// 
+// $boolean(-0.5)
 TEST_F(function_booleanTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case006.json"));
 }
 
-// 
+// $boolean(null)
 TEST_F(function_booleanTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case007.json"));
 }
 
-// 
+// $boolean([])
 TEST_F(function_booleanTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case008.json"));
 }
 
-// 
+// $boolean([0])
 TEST_F(function_booleanTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case009.json"));
 }
 
-// 
+// $boolean([1])
 TEST_F(function_booleanTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case010.json"));
 }
 
-// 
+// $boolean([1,2,3])
 TEST_F(function_booleanTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case011.json"));
 }
 
-// 
+// $boolean([0,0])
 TEST_F(function_booleanTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case012.json"));
 }
 
-// 
+// $boolean([[]])
 TEST_F(function_booleanTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case013.json"));
 }
 
-// 
+// $boolean([[null]])
 TEST_F(function_booleanTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case014.json"));
 }
 
-// 
+// $boolean([[[true]]])
 TEST_F(function_booleanTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case015.json"));
 }
 
-// 
+// $boolean({})
 TEST_F(function_booleanTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case016.json"));
 }
 
-// 
+// $boolean({\"hello\":\"world\"})
 TEST_F(function_booleanTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case017.json"));
 }
 
-// 
+// $boolean(Account)
 TEST_F(function_booleanTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case018.json"));
 }
 
-// 
+// $boolean(Account.Order.Product.Price)
 TEST_F(function_booleanTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case019.json"));
 }
 
-// 
+// $boolean(Account.blah)
 TEST_F(function_booleanTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case020.json"));
 }
 
-// 
+// $boolean($boolean)
 TEST_F(function_booleanTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case021.json"));
 }
 
-// 
+// $boolean(function(){true})
 TEST_F(function_booleanTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case022.json"));
 }
 
-// 
+// $boolean(2,3)
 TEST_F(function_booleanTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-boolean/case023.json"));
 }
diff --git a/test/gen/function_ceilTest.cpp b/test/gen/function_ceilTest.cpp
index 0c4127c..d8dc699 100644
--- a/test/gen/function_ceilTest.cpp
+++ b/test/gen/function_ceilTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_ceilTest : public JsonataTest {
 };
 
-// 
+// $ceil(3.7)
 TEST_F(function_ceilTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case000.json"));
 }
 
-// 
+// $ceil(-3.7)
 TEST_F(function_ceilTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case001.json"));
 }
 
-// 
+// $ceil(0)
 TEST_F(function_ceilTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case002.json"));
 }
 
-// 
+// $ceil(nothing)
 TEST_F(function_ceilTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-ceil/case003.json"));
 }
diff --git a/test/gen/function_containsTest.cpp b/test/gen/function_containsTest.cpp
index 9f77d9a..f3c64e1 100644
--- a/test/gen/function_containsTest.cpp
+++ b/test/gen/function_containsTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_containsTest : public JsonataTest {
 };
 
-// 
+// $contains(\"Hello World\", \"lo\")
 TEST_F(function_containsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case000.json"));
 }
 
-// 
+// $contains(\"Hello World\", \"World\")
 TEST_F(function_containsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case001.json"));
 }
 
-// 
+// $contains(\"Hello World\", \"world\")
 TEST_F(function_containsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case002.json"));
 }
 
-// 
+// $contains(\"Hello World\", \"Word\")
 TEST_F(function_containsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case003.json"));
 }
 
-// 
+// $contains(nothing, \"World\")
 TEST_F(function_containsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case004.json"));
 }
 
-// 
+// $contains(23, 3)
 TEST_F(function_containsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case005.json"));
 }
 
-// 
+// $contains(\"23\", 3)
 TEST_F(function_containsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-contains/case006.json"));
 }
diff --git a/test/gen/function_countTest.cpp b/test/gen/function_countTest.cpp
index b6aee2d..0a2fc1e 100644
--- a/test/gen/function_countTest.cpp
+++ b/test/gen/function_countTest.cpp
@@ -6,72 +6,72 @@ using namespace jsonata;
 class function_countTest : public JsonataTest {
 };
 
-// 
+// $count(Account.Order.Product.(Price * Quantity))
 TEST_F(function_countTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case000.json"));
 }
 
-// 
+// Account.Order.$count(Product.(Price * Quantity))
 TEST_F(function_countTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case001.json"));
 }
 
-// 
+// Account.Order.(OrderID & \": \" & $count(Product.(Price*Quantity)))
 TEST_F(function_countTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case002.json"));
 }
 
-// 
+// $count([])
 TEST_F(function_countTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case003.json"));
 }
 
-// 
+// $count([1,2,3])
 TEST_F(function_countTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case004.json"));
 }
 
-// 
+// $count([\"1\",\"2\",\"3\"])
 TEST_F(function_countTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case005.json"));
 }
 
-// 
+// $count([\"1\",\"2\",3])
 TEST_F(function_countTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case006.json"));
 }
 
-// 
+// $count(1)
 TEST_F(function_countTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case007.json"));
 }
 
-// 
+// $count([],[])
 TEST_F(function_countTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case008.json"));
 }
 
-// 
+// $count([1,2,3],[])
 TEST_F(function_countTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case009.json"));
 }
 
-// 
+// $count([],[],[])
 TEST_F(function_countTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case010.json"));
 }
 
-// 
+// $count([1,2],[],[])
 TEST_F(function_countTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case011.json"));
 }
 
-// 
+// $count(undefined)
 TEST_F(function_countTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case012.json"));
 }
 
-// 
+// $count([1,2,3,4]) / 2
 TEST_F(function_countTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-count/case013.json"));
 }
diff --git a/test/gen/function_decodeUrlComponentTest.cpp b/test/gen/function_decodeUrlComponentTest.cpp
index 49bf765..c468356 100644
--- a/test/gen/function_decodeUrlComponentTest.cpp
+++ b/test/gen/function_decodeUrlComponentTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_decodeUrlComponentTest : public JsonataTest {
 };
 
-// 
+// $decodeUrlComponent(\"%3Fx%3Dtest\")
 TEST_F(function_decodeUrlComponentTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrlComponent/case000.json"));
 }
 
-// 
+// $decodeUrlComponent(blah)
 TEST_F(function_decodeUrlComponentTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrlComponent/case001.json"));
 }
 
-// 
+// $decodeUrlComponent('%E0%A4%A')
 TEST_F(function_decodeUrlComponentTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrlComponent/case002.json"));
 }
diff --git a/test/gen/function_decodeUrlTest.cpp b/test/gen/function_decodeUrlTest.cpp
index 25b13b4..dce3b99 100644
--- a/test/gen/function_decodeUrlTest.cpp
+++ b/test/gen/function_decodeUrlTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_decodeUrlTest : public JsonataTest {
 };
 
-// 
+// $decodeUrl(\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\")
 TEST_F(function_decodeUrlTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrl/case000.json"));
 }
 
-// 
+// $decodeUrl(blah)
 TEST_F(function_decodeUrlTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrl/case001.json"));
 }
 
-// 
+// $decodeUrl('%E0%A4%A')
 TEST_F(function_decodeUrlTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-decodeUrl/case002.json"));
 }
diff --git a/test/gen/function_distinctTest.cpp b/test/gen/function_distinctTest.cpp
index 2b400da..1867bad 100644
--- a/test/gen/function_distinctTest.cpp
+++ b/test/gen/function_distinctTest.cpp
@@ -6,8 +6,43 @@ using namespace jsonata;
 class function_distinctTest : public JsonataTest {
 };
 
-// 
-TEST_F(function_distinctTest, distinct) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-distinct/distinct.json"));
+// $distinct([1,2,3,4])
+TEST_F(function_distinctTest, distinct_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 0));
+}
+
+// $distinct([1])
+TEST_F(function_distinctTest, distinct_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 1));
+}
+
+// $distinct(nothing)
+TEST_F(function_distinctTest, distinct_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 2));
+}
+
+// $distinct(null)
+TEST_F(function_distinctTest, distinct_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 3));
+}
+
+// $distinct('hello')
+TEST_F(function_distinctTest, distinct_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 4));
+}
+
+// $distinct(Account.Order.Product.SKU)
+TEST_F(function_distinctTest, distinct_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 5));
+}
+
+// $distinct(Account.Order.Product.`Product Name`)
+TEST_F(function_distinctTest, distinct_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 6));
+}
+
+// $distinct(Account.Order.Product.Description)
+TEST_F(function_distinctTest, distinct_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-distinct/distinct.json", 7));
 }
 
diff --git a/test/gen/function_eachTest.cpp b/test/gen/function_eachTest.cpp
index ffaf601..3ed89c2 100644
--- a/test/gen/function_eachTest.cpp
+++ b/test/gen/function_eachTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_eachTest : public JsonataTest {
 };
 
-// 
+// $each(Address, λ($v, $k) {$k & \": \" & $v})
 TEST_F(function_eachTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-each/case000.json"));
 }
 
-// 
+// $each({'a': 'hello', 'b': 'world'}, $uppercase)
 TEST_F(function_eachTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-each/case001.json"));
 }
 
-// 
+// $each(function($v, $k) {$k[$v>2]})
 TEST_F(function_eachTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-each/case002.json"));
 }
diff --git a/test/gen/function_encodeUrlComponentTest.cpp b/test/gen/function_encodeUrlComponentTest.cpp
index 87bf227..2fda2d8 100644
--- a/test/gen/function_encodeUrlComponentTest.cpp
+++ b/test/gen/function_encodeUrlComponentTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_encodeUrlComponentTest : public JsonataTest {
 };
 
-// 
+// $encodeUrlComponent(\"?x=test\")
 TEST_F(function_encodeUrlComponentTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrlComponent/case000.json"));
 }
 
-// 
+// $encodeUrlComponent(blah)
 TEST_F(function_encodeUrlComponentTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrlComponent/case001.json"));
 }
diff --git a/test/gen/function_encodeUrlTest.cpp b/test/gen/function_encodeUrlTest.cpp
index 211368a..1cb059b 100644
--- a/test/gen/function_encodeUrlTest.cpp
+++ b/test/gen/function_encodeUrlTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_encodeUrlTest : public JsonataTest {
 };
 
-// 
+// $encodeUrl(\"https://mozilla.org/?x=шеллы\")
 TEST_F(function_encodeUrlTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrl/case000.json"));
 }
 
-// 
+// $encodeUrl(blah)
 TEST_F(function_encodeUrlTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-encodeUrl/case001.json"));
 }
diff --git a/test/gen/function_errorTest.cpp b/test/gen/function_errorTest.cpp
index 0fa645b..ce2d2c9 100644
--- a/test/gen/function_errorTest.cpp
+++ b/test/gen/function_errorTest.cpp
@@ -6,57 +6,57 @@ using namespace jsonata;
 class function_errorTest : public JsonataTest {
 };
 
-// 
+// Account.Order[0].Product[0].Price > 35 ? Account.Order[0].Product[0].Price : $error('Too Expensive')
 TEST_F(function_errorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case000.json"));
 }
 
-// 
+// Account.Order[0].Product[0].Price > 34 ? Account.Order[0].Product[0].Price : $error('Too Expensive')
 TEST_F(function_errorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case001.json"));
 }
 
-// 
+// Account.Order[0].Product[0].Price > 35 ? $error('Too Expensive') : Account.Order[0].Product[0].Price
 TEST_F(function_errorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case002.json"));
 }
 
-// 
+// Account.Order[0].Product[0].Price > 34 ? $error('Too Expensive') : Account.Order[0].Product[0].Price
 TEST_F(function_errorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case003.json"));
 }
 
-// 
+// $count(Account.Order[0].Product) < 2 ? $error('Not enough products in orders')
 TEST_F(function_errorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case004.json"));
 }
 
-// 
+// $count(Account.Order[0].Product) < 3 ? $error('Not enough products in orders')
 TEST_F(function_errorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case005.json"));
 }
 
-// 
+// ($msg:='My Message'; $error($msg); true)
 TEST_F(function_errorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case006.json"));
 }
 
-// 
+// $error(null)
 TEST_F(function_errorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case007.json"));
 }
 
-// 
+// $error(5)
 TEST_F(function_errorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case008.json"));
 }
 
-// 
+// $error()
 TEST_F(function_errorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case009.json"));
 }
 
-// 
+// $error(foo)
 TEST_F(function_errorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-error/case010.json"));
 }
diff --git a/test/gen/function_evalTest.cpp b/test/gen/function_evalTest.cpp
index f7cbcf6..bae4842 100644
--- a/test/gen/function_evalTest.cpp
+++ b/test/gen/function_evalTest.cpp
@@ -6,48 +6,63 @@ using namespace jsonata;
 class function_evalTest : public JsonataTest {
 };
 
-// 
+// $eval('[1,2,3]')
 TEST_F(function_evalTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case000.json"));
 }
 
-// 
+// $eval(nothing)
 TEST_F(function_evalTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case001.json"));
 }
 
-// 
+// $eval('[1,$string(2),3]')
 TEST_F(function_evalTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case002.json"));
 }
 
-// 
+// $eval('Account.Order.Product.Quantity ~> $sum()')
 TEST_F(function_evalTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case003.json"));
 }
 
-// 
+// Account.Order.Product.{'Name': `Product Name`, 'Total': $eval('Price * Quantity')}
 TEST_F(function_evalTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case004.json"));
 }
 
-// 
+// Account.Order.Product.{'Name': `Product Name`, 'Volume': $eval('Width*Height*Depth', Description)}
 TEST_F(function_evalTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case005.json"));
 }
 
-// 
+// $eval('[1,string(2),3]')
 TEST_F(function_evalTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case006.json"));
 }
 
-// 
+// $eval('[1,#string(2),3]')
 TEST_F(function_evalTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case007.json"));
 }
 
-// 
-TEST_F(function_evalTest, case008) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-eval/case008.json"));
+// $eval(\"{ 'test': 1 }\", [])
+TEST_F(function_evalTest, case008_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 0));
+}
+
+// $eval(\"{ 'test': 1 }\")
+TEST_F(function_evalTest, case008_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 1));
+}
+
+// $eval(\"{ 'test': 1 }\", [1,2,3])
+TEST_F(function_evalTest, case008_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 2));
+}
+
+// $eval(\"{ 'test': 1 }\")
+TEST_F(function_evalTest, case008_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-eval/case008.json", 3));
 }
 
diff --git a/test/gen/function_existsTest.cpp b/test/gen/function_existsTest.cpp
index 1767a9b..ce96890 100644
--- a/test/gen/function_existsTest.cpp
+++ b/test/gen/function_existsTest.cpp
@@ -6,127 +6,127 @@ using namespace jsonata;
 class function_existsTest : public JsonataTest {
 };
 
-// 
+// $exists(\"Hello World\")
 TEST_F(function_existsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case000.json"));
 }
 
-// 
+// $exists(\"\")
 TEST_F(function_existsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case001.json"));
 }
 
-// 
+// $exists(true)
 TEST_F(function_existsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case002.json"));
 }
 
-// 
+// $exists(false)
 TEST_F(function_existsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case003.json"));
 }
 
-// 
+// $exists(0)
 TEST_F(function_existsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case004.json"));
 }
 
-// 
+// $exists(-0.5)
 TEST_F(function_existsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case005.json"));
 }
 
-// 
+// $exists(null)
 TEST_F(function_existsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case006.json"));
 }
 
-// 
+// $exists([])
 TEST_F(function_existsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case007.json"));
 }
 
-// 
+// $exists([0])
 TEST_F(function_existsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case008.json"));
 }
 
-// 
+// $exists([1,2,3])
 TEST_F(function_existsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case009.json"));
 }
 
-// 
+// $exists([[]])
 TEST_F(function_existsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case010.json"));
 }
 
-// 
+// $exists([[null]])
 TEST_F(function_existsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case011.json"));
 }
 
-// 
+// $exists([[[true]]])
 TEST_F(function_existsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case012.json"));
 }
 
-// 
+// $exists({})
 TEST_F(function_existsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case013.json"));
 }
 
-// 
+// $exists({\"hello\":\"world\"})
 TEST_F(function_existsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case014.json"));
 }
 
-// 
+// $exists(Account)
 TEST_F(function_existsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case015.json"));
 }
 
-// 
+// $exists(Account.Order.Product.Price)
 TEST_F(function_existsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case016.json"));
 }
 
-// 
+// $exists($exists)
 TEST_F(function_existsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case017.json"));
 }
 
-// 
+// $exists(function(){true})
 TEST_F(function_existsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case018.json"));
 }
 
-// 
+// $exists(blah)
 TEST_F(function_existsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case019.json"));
 }
 
-// 
+// $exists(Account.blah)
 TEST_F(function_existsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case020.json"));
 }
 
-// 
+// $exists(Account.Order[2])
 TEST_F(function_existsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case021.json"));
 }
 
-// 
+// $exists(Account.Order[0].blah)
 TEST_F(function_existsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case022.json"));
 }
 
-// 
+// $exists(2,3)
 TEST_F(function_existsTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case023.json"));
 }
 
-// 
+// $exists()
 TEST_F(function_existsTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-exists/case024.json"));
 }
diff --git a/test/gen/function_floorTest.cpp b/test/gen/function_floorTest.cpp
index e5f23a8..dda475f 100644
--- a/test/gen/function_floorTest.cpp
+++ b/test/gen/function_floorTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_floorTest : public JsonataTest {
 };
 
-// 
+// $floor(3.7)
 TEST_F(function_floorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case000.json"));
 }
 
-// 
+// $floor(-3.7)
 TEST_F(function_floorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case001.json"));
 }
 
-// 
+// $floor(0)
 TEST_F(function_floorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case002.json"));
 }
 
-// 
+// $floor(nothing)
 TEST_F(function_floorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-floor/case003.json"));
 }
diff --git a/test/gen/function_formatBaseTest.cpp b/test/gen/function_formatBaseTest.cpp
index 681ebdc..123dfe1 100644
--- a/test/gen/function_formatBaseTest.cpp
+++ b/test/gen/function_formatBaseTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class function_formatBaseTest : public JsonataTest {
 };
 
-// 
+// $formatBase(100)
 TEST_F(function_formatBaseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case000.json"));
 }
 
-// 
+// $formatBase(nothing)
 TEST_F(function_formatBaseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case001.json"));
 }
 
-// 
+// $formatBase(100, 2)
 TEST_F(function_formatBaseTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case002.json"));
 }
 
-// 
+// $formatBase(-100, 2)
 TEST_F(function_formatBaseTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case003.json"));
 }
 
-// 
+// $formatBase(100, 36)
 TEST_F(function_formatBaseTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case004.json"));
 }
 
-// 
+// $formatBase(99.5, 2.5)
 TEST_F(function_formatBaseTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case005.json"));
 }
 
-// 
+// $formatBase(100, 1)
 TEST_F(function_formatBaseTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case006.json"));
 }
 
-// 
+// $formatBase(100, 37)
 TEST_F(function_formatBaseTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatBase/case007.json"));
 }
diff --git a/test/gen/function_formatIntegerTest.cpp b/test/gen/function_formatIntegerTest.cpp
index 6f6fe3b..a415a2a 100644
--- a/test/gen/function_formatIntegerTest.cpp
+++ b/test/gen/function_formatIntegerTest.cpp
@@ -6,8 +6,328 @@ using namespace jsonata;
 class function_formatIntegerTest : public JsonataTest {
 };
 
-// 
-TEST_F(function_formatIntegerTest, formatInteger) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json"));
+// $formatInteger(undefined, '0')
+TEST_F(function_formatIntegerTest, formatInteger_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 0));
+}
+
+// $formatInteger(123, '000')
+TEST_F(function_formatIntegerTest, formatInteger_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 1));
+}
+
+// $formatInteger(123, '0000')
+TEST_F(function_formatIntegerTest, formatInteger_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 2));
+}
+
+// $formatInteger(-3, '0000')
+TEST_F(function_formatIntegerTest, formatInteger_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 3));
+}
+
+// $formatInteger(1234, '0;c')
+TEST_F(function_formatIntegerTest, formatInteger_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 4));
+}
+
+// $formatInteger(1234, '###0')
+TEST_F(function_formatIntegerTest, formatInteger_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 5));
+}
+
+// $formatInteger(12, '###0')
+TEST_F(function_formatIntegerTest, formatInteger_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 6));
+}
+
+// $formatInteger(12.6, '###0')
+TEST_F(function_formatIntegerTest, formatInteger_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 7));
+}
+
+// $formatInteger(123, '000;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 8));
+}
+
+// $formatInteger(1, '0;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 9));
+}
+
+// $formatInteger(28, '#0;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 10));
+}
+
+// $formatInteger(1234, '###0;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 11));
+}
+
+// $formatInteger(12, '###0;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 12));
+}
+
+// $formatInteger(12340, '###١')
+TEST_F(function_formatIntegerTest, formatInteger_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 13));
+}
+
+// $formatInteger(12340, '###０')
+TEST_F(function_formatIntegerTest, formatInteger_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 14));
+}
+
+// $formatInteger(12340, '##0０')
+TEST_F(function_formatIntegerTest, formatInteger_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 15));
+}
+
+// $formatInteger(12, '#,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 16));
+}
+
+// $formatInteger(1200, '#,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 17));
+}
+
+// $formatInteger(120000, '#,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 18));
+}
+
+// $formatInteger(12345678, '#,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_19) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 19));
+}
+
+// $formatInteger(1234567890, '#,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_20) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 20));
+}
+
+// $formatInteger(1234567890, '#,###,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_21) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 21));
+}
+
+// $formatInteger(1234567890, '#:###,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_22) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 22));
+}
+
+// $formatInteger(1234567890, '##,##,##0')
+TEST_F(function_formatIntegerTest, formatInteger_case_23) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 23));
+}
+
+// $formatInteger(0, 'I')
+TEST_F(function_formatIntegerTest, formatInteger_case_24) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 24));
+}
+
+// $formatInteger(1984, 'I')
+TEST_F(function_formatIntegerTest, formatInteger_case_25) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 25));
+}
+
+// $formatInteger(99, 'i')
+TEST_F(function_formatIntegerTest, formatInteger_case_26) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 26));
+}
+
+// $formatInteger(12, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_27) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 27));
+}
+
+// $formatInteger(20, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_28) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 28));
+}
+
+// $formatInteger(34, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_29) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 29));
+}
+
+// $formatInteger(99, 'W')
+TEST_F(function_formatIntegerTest, formatInteger_case_30) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 30));
+}
+
+// $formatInteger(100, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_31) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 31));
+}
+
+// $formatInteger(555, 'W')
+TEST_F(function_formatIntegerTest, formatInteger_case_32) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 32));
+}
+
+// $formatInteger(555, 'Ww')
+TEST_F(function_formatIntegerTest, formatInteger_case_33) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 33));
+}
+
+// $formatInteger(919, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_34) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 34));
+}
+
+// $formatInteger(730, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_35) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 35));
+}
+
+// $formatInteger(1000, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_36) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 36));
+}
+
+// $formatInteger(3730, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_37) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 37));
+}
+
+// $formatInteger(327730, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_38) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 38));
+}
+
+// $formatInteger(4327730, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_39) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 39));
+}
+
+// $formatInteger(1000000000001, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_40) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 40));
+}
+
+// $formatInteger(1234567890123, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_41) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 41));
+}
+
+// $formatInteger(1000000000000000, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_42) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 42));
+}
+
+// $formatInteger(1e+46, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_43) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 43));
+}
+
+// $formatInteger(1234567890123456, 'w')
+TEST_F(function_formatIntegerTest, formatInteger_case_44) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 44));
+}
+
+// $formatInteger(12, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_45) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 45));
+}
+
+// $formatInteger(20, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_46) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 46));
+}
+
+// $formatInteger(34, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_47) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 47));
+}
+
+// $formatInteger(99, 'W;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_48) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 48));
+}
+
+// $formatInteger(100, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_49) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 49));
+}
+
+// $formatInteger(555, 'W;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_50) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 50));
+}
+
+// $formatInteger(919, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_51) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 51));
+}
+
+// $formatInteger(730, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_52) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 52));
+}
+
+// $formatInteger(1000, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_53) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 53));
+}
+
+// $formatInteger(3731, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_54) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 54));
+}
+
+// $formatInteger(327713, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_55) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 55));
+}
+
+// $formatInteger(4327732, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_56) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 56));
+}
+
+// $formatInteger(1000000000001, 'w;o')
+TEST_F(function_formatIntegerTest, formatInteger_case_57) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 57));
+}
+
+// $formatInteger(1, 'A')
+TEST_F(function_formatIntegerTest, formatInteger_case_58) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 58));
+}
+
+// $formatInteger(12, 'a')
+TEST_F(function_formatIntegerTest, formatInteger_case_59) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 59));
+}
+
+// $formatInteger(26, 'a')
+TEST_F(function_formatIntegerTest, formatInteger_case_60) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 60));
+}
+
+// $formatInteger(27, 'a')
+TEST_F(function_formatIntegerTest, formatInteger_case_61) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 61));
+}
+
+// $formatInteger(300, 'A')
+TEST_F(function_formatIntegerTest, formatInteger_case_62) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 62));
+}
+
+// $formatInteger(123456, 'A')
+TEST_F(function_formatIntegerTest, formatInteger_case_63) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 63));
+}
+
+// $formatInteger(123456, 'α')
+TEST_F(function_formatIntegerTest, formatInteger_case_64) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-formatInteger/formatInteger.json", 64));
 }
 
diff --git a/test/gen/function_formatNumberTest.cpp b/test/gen/function_formatNumberTest.cpp
index 80903d8..b1a7012 100644
--- a/test/gen/function_formatNumberTest.cpp
+++ b/test/gen/function_formatNumberTest.cpp
@@ -6,187 +6,187 @@ using namespace jsonata;
 class function_formatNumberTest : public JsonataTest {
 };
 
-// 
+// $formatNumber(12345.6, \"#,###.00\")
 TEST_F(function_formatNumberTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case000.json"));
 }
 
-// 
+// $formatNumber(12345678.9, \"9,999.99\")
 TEST_F(function_formatNumberTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case001.json"));
 }
 
-// 
+// $formatNumber(123412345678.9, \"9,9,99.99\")
 TEST_F(function_formatNumberTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case002.json"));
 }
 
-// 
+// $formatNumber(1234.56789, \"9,999.999,999\")
 TEST_F(function_formatNumberTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case003.json"));
 }
 
-// 
+// $formatNumber(123.9, \"9999\")
 TEST_F(function_formatNumberTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case004.json"));
 }
 
-// 
+// $formatNumber(0.14, \"01%\")
 TEST_F(function_formatNumberTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case005.json"));
 }
 
-// 
+// $formatNumber(0.4857,\"###.###‰\")
 TEST_F(function_formatNumberTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case006.json"));
 }
 
-// 
+// $formatNumber(0.14, \"###pm\", {\"per-mille\": \"pm\"})
 TEST_F(function_formatNumberTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case007.json"));
 }
 
-// 
+// $formatNumber(-6, \"000\")
 TEST_F(function_formatNumberTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case008.json"));
 }
 
-// 
+// $formatNumber(1234.5678, \"00.000e0\")
 TEST_F(function_formatNumberTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case009.json"));
 }
 
-// 
+// $formatNumber(1234.5678, \"00.000e000\")
 TEST_F(function_formatNumberTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case010.json"));
 }
 
-// 
+// $formatNumber(1234.5678, \"①①.①①①e①\", {\"zero-digit\": \"⑟\"})
 TEST_F(function_formatNumberTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case011.json"));
 }
 
-// 
+// $formatNumber(0.234, \"0.0e0\")
 TEST_F(function_formatNumberTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case012.json"));
 }
 
-// 
+// $formatNumber(0.234, \"#.00e0\")
 TEST_F(function_formatNumberTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case013.json"));
 }
 
-// 
+// $formatNumber(0.123, \"#.e9\")
 TEST_F(function_formatNumberTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case014.json"));
 }
 
-// 
+// $formatNumber(0.234, \".00e0\")
 TEST_F(function_formatNumberTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case015.json"));
 }
 
-// 
+// $formatNumber(2392.14*(-36.58), \"000,000.000###;###,###.000###\")
 TEST_F(function_formatNumberTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case016.json"));
 }
 
-// 
+// $formatNumber(2.14*86.58,\"PREFIX##00.000###SUFFIX\")
 TEST_F(function_formatNumberTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case017.json"));
 }
 
-// 
+// $formatNumber(1E20,\"#,######\")
 TEST_F(function_formatNumberTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case018.json"));
 }
 
-// 
+// $formatNumber(20,\"#;#;#\")
 TEST_F(function_formatNumberTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case019.json"));
 }
 
-// 
+// $formatNumber(20,\"#.0.0\")
 TEST_F(function_formatNumberTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case020.json"));
 }
 
-// 
+// $formatNumber(20,\"#0%%\")
 TEST_F(function_formatNumberTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case021.json"));
 }
 
-// 
+// $formatNumber(20,\"#0‰‰\")
 TEST_F(function_formatNumberTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case022.json"));
 }
 
-// 
+// $formatNumber(20,\"#0%‰\")
 TEST_F(function_formatNumberTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case023.json"));
 }
 
-// 
+// $formatNumber(20,\".e0\")
 TEST_F(function_formatNumberTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case024.json"));
 }
 
-// 
+// $formatNumber(20,\"0+.e0\")
 TEST_F(function_formatNumberTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case025.json"));
 }
 
-// 
+// $formatNumber(20,\"0,.e0\")
 TEST_F(function_formatNumberTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case026.json"));
 }
 
-// 
+// $formatNumber(20,\"0,\")
 TEST_F(function_formatNumberTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case027.json"));
 }
 
-// 
+// $formatNumber(20,\"0,,0\")
 TEST_F(function_formatNumberTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case028.json"));
 }
 
-// 
+// $formatNumber(20,\"0#.e0\")
 TEST_F(function_formatNumberTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case029.json"));
 }
 
-// 
+// $formatNumber(20,\"#0.#0e0\")
 TEST_F(function_formatNumberTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case030.json"));
 }
 
-// 
+// $formatNumber(20,\"#0.0e0%\")
 TEST_F(function_formatNumberTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case031.json"));
 }
 
-// 
+// $formatNumber(20,\"#0.0e0,0\")
 TEST_F(function_formatNumberTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case032.json"));
 }
 
-// 
+// $formatNumber(2, '000.000')
 TEST_F(function_formatNumberTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case033.json"));
 }
 
-// 
+// $formatNumber(2, 'AAA.AAA', {'zero-digit': 'A'})
 TEST_F(function_formatNumberTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case034.json"));
 }
 
-// 
+// $formatNumber(0.1, 'AeAAA', {'zero-digit': 'A'})
 TEST_F(function_formatNumberTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case035.json"));
 }
 
-// 
+// $formatNumber(foo, '#0.00')
 TEST_F(function_formatNumberTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-formatNumber/case036.json"));
 }
diff --git a/test/gen/function_fromMillisTest.cpp b/test/gen/function_fromMillisTest.cpp
index 8b79709..56be142 100644
--- a/test/gen/function_fromMillisTest.cpp
+++ b/test/gen/function_fromMillisTest.cpp
@@ -6,28 +6,468 @@ using namespace jsonata;
 class function_fromMillisTest : public JsonataTest {
 };
 
-// 
+// $fromMillis(1)
 TEST_F(function_fromMillisTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/case000.json"));
 }
 
-// 
+// $fromMillis(1509380732935)
 TEST_F(function_fromMillisTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/case001.json"));
 }
 
-// 
+// $fromMillis(foo)
 TEST_F(function_fromMillisTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/case002.json"));
 }
 
-// 
-TEST_F(function_fromMillisTest, formatDateTime) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json"));
+// $fromMillis(undefined, 'undefined')
+TEST_F(function_fromMillisTest, formatDateTime_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 0));
 }
 
-// 
-TEST_F(function_fromMillisTest, isoWeekDate) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json"));
+// $fromMillis(1521801216617, 'Hello')
+TEST_F(function_fromMillisTest, formatDateTime_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 1));
+}
+
+// $fromMillis(1521801216617, 'Year: [Y0001]')
+TEST_F(function_fromMillisTest, formatDateTime_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 2));
+}
+
+// $fromMillis(1521801216617, 'Year: <[Y0001]>')
+TEST_F(function_fromMillisTest, formatDateTime_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 3));
+}
+
+// $fromMillis(1521801216617, 'Year: <[Y9,999,*]>')
+TEST_F(function_fromMillisTest, formatDateTime_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 4));
+}
+
+// $fromMillis(1521801216617, '[[Year: <[Y0001]>')
+TEST_F(function_fromMillisTest, formatDateTime_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 5));
+}
+
+// $fromMillis(1521801216617, 'Year]]: <[Y0001]>')
+TEST_F(function_fromMillisTest, formatDateTime_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 6));
+}
+
+// $fromMillis(1521801216617, '[[Year]]: [[[Y0001]]]')
+TEST_F(function_fromMillisTest, formatDateTime_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 7));
+}
+
+// $fromMillis(1521801216617, '[D#1]/[M#1]/[Y0001]')
+TEST_F(function_fromMillisTest, formatDateTime_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 8));
+}
+
+// $fromMillis(1522616700000, '[F0] [FNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 9));
+}
+
+// $fromMillis(1522703100000, '[F0] [FNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 10));
+}
+
+// $fromMillis(1521801216617, '[Y0001]-[M01]-[D01]')
+TEST_F(function_fromMillisTest, formatDateTime_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 11));
+}
+
+// $fromMillis(1521801216617, '[M01]/[D01]/[Y0001] at [H01]:[m01]:[s01]')
+TEST_F(function_fromMillisTest, formatDateTime_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 12));
+}
+
+// $fromMillis(1521801216617, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z01:01t]')
+TEST_F(function_fromMillisTest, formatDateTime_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 13));
+}
+
+// $fromMillis(1521801216617, '[Y]-[ M01]-[D 01]T[H01 ]:[ m   ]:[s].[f0  01][Z01:  01t]')
+TEST_F(function_fromMillisTest, formatDateTime_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 14));
+}
+
+// $fromMillis(1521801216617, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z0101t]', '+0100')
+TEST_F(function_fromMillisTest, formatDateTime_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 15));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z01:01]')
+TEST_F(function_fromMillisTest, formatDateTime_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 16));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z01:01t]')
+TEST_F(function_fromMillisTest, formatDateTime_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 17));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z]', '-0500')
+TEST_F(function_fromMillisTest, formatDateTime_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 18));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z0]', '-0500')
+TEST_F(function_fromMillisTest, formatDateTime_case_19) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 19));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z]', '+1000')
+TEST_F(function_fromMillisTest, formatDateTime_case_20) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 20));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z0]', '+1000')
+TEST_F(function_fromMillisTest, formatDateTime_case_21) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 21));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][Z0]', '+0530')
+TEST_F(function_fromMillisTest, formatDateTime_case_22) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 22));
+}
+
+// $fromMillis(1531310400000, '[Y]-[M01]-[D01]T[H01]:[m]:[s][z]', '-0500')
+TEST_F(function_fromMillisTest, formatDateTime_case_23) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 23));
+}
+
+// $fromMillis(1204405500000, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z0101t]', '+0530')
+TEST_F(function_fromMillisTest, formatDateTime_case_24) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 24));
+}
+
+// $fromMillis(1230757500000, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z0101t]', '+0530')
+TEST_F(function_fromMillisTest, formatDateTime_case_25) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 25));
+}
+
+// $fromMillis(1230757500000, '[Y]-[M01]-[D01]T[H01]:[m]:[s].[f001][Z010101t]', '+0530')
+TEST_F(function_fromMillisTest, formatDateTime_case_26) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 26));
+}
+
+// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y,2]')
+TEST_F(function_fromMillisTest, formatDateTime_case_27) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 27));
+}
+
+// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y0001,2]')
+TEST_F(function_fromMillisTest, formatDateTime_case_28) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 28));
+}
+
+// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y##01,2-2]')
+TEST_F(function_fromMillisTest, formatDateTime_case_29) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 29));
+}
+
+// $fromMillis(1521801216617, '[D#1,2]/[M1,2]/[Y0001,2-2]')
+TEST_F(function_fromMillisTest, formatDateTime_case_30) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 30));
+}
+
+// $fromMillis(1521801216617, '[D1] [M01] [YI]')
+TEST_F(function_fromMillisTest, formatDateTime_case_31) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 31));
+}
+
+// $fromMillis(1521801216617, '[Da] [MA] [Yi]')
+TEST_F(function_fromMillisTest, formatDateTime_case_32) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 32));
+}
+
+// $fromMillis(1521801216617, '[D1o] [M01] [Y]')
+TEST_F(function_fromMillisTest, formatDateTime_case_33) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 33));
+}
+
+// $fromMillis(1521801216617, '[Yw]')
+TEST_F(function_fromMillisTest, formatDateTime_case_34) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 34));
+}
+
+// $fromMillis(1521801216617, '[Dwo] [M01] [Y]')
+TEST_F(function_fromMillisTest, formatDateTime_case_35) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 35));
+}
+
+// $fromMillis(1521801216617, '[D1o] [MNn] [Y]')
+TEST_F(function_fromMillisTest, formatDateTime_case_36) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 36));
+}
+
+// $fromMillis(1521801216617, '[D1o] [MN] [Y]')
+TEST_F(function_fromMillisTest, formatDateTime_case_37) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 37));
+}
+
+// $fromMillis(1521801216617, '[FNn], [D1o] [MNn] [Y]')
+TEST_F(function_fromMillisTest, formatDateTime_case_38) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 38));
+}
+
+// $fromMillis(1521801216617, '[FNn], the [Dwo] of [MNn] [Y] [E]')
+TEST_F(function_fromMillisTest, formatDateTime_case_39) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 39));
+}
+
+// $fromMillis(1521801216617, '[FNn,3-3], [D1o] [MNn,3-3] [Y] [C]')
+TEST_F(function_fromMillisTest, formatDateTime_case_40) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 40));
+}
+
+// $fromMillis(1521801216617, '[F], [D]/[M]/[Y] [h]:[m]:[s] [P]')
+TEST_F(function_fromMillisTest, formatDateTime_case_41) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 41));
+}
+
+// $fromMillis(1204405500000, '[F], [D]/[M]/[Y] [h]:[m]:[s] [P]')
+TEST_F(function_fromMillisTest, formatDateTime_case_42) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 42));
+}
+
+// $fromMillis(1199664000000, '[F], [D]/[M]/[Y] [h]:[m]:[s] [P]')
+TEST_F(function_fromMillisTest, formatDateTime_case_43) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 43));
+}
+
+// $fromMillis(1514808000000, '[dwo] day of the year')
+TEST_F(function_fromMillisTest, formatDateTime_case_44) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 44));
+}
+
+// $fromMillis(1546257600000, '[d] days in [Y0001]')
+TEST_F(function_fromMillisTest, formatDateTime_case_45) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 45));
+}
+
+// $fromMillis(1483185600000, '[d] days in [Y0001]')
+TEST_F(function_fromMillisTest, formatDateTime_case_46) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 46));
+}
+
+// $fromMillis(1514808000000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_47) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 47));
+}
+
+// $fromMillis(1515326400000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_48) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 48));
+}
+
+// $fromMillis(1545739200000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_49) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 49));
+}
+
+// $fromMillis(1388577600000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_50) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 50));
+}
+
+// $fromMillis(1419854400000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_51) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 51));
+}
+
+// $fromMillis(1419768000000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_52) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 52));
+}
+
+// $fromMillis(1419336000000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_53) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 53));
+}
+
+// $fromMillis(1420113600000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_54) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 54));
+}
+
+// $fromMillis(1420459200000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_55) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 55));
+}
+
+// $fromMillis(1451304000000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_56) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 56));
+}
+
+// $fromMillis(1451563200000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_57) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 57));
+}
+
+// $fromMillis(1451736000000, 'Week: [W]')
+TEST_F(function_fromMillisTest, formatDateTime_case_58) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 58));
+}
+
+// $fromMillis(1359460800000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_59) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 59));
+}
+
+// $fromMillis(1359633600000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_60) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 60));
+}
+
+// $fromMillis(1359720000000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_61) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 61));
+}
+
+// $fromMillis(1514808000000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_62) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 62));
+}
+
+// $fromMillis(1483272000000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_63) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 63));
+}
+
+// $fromMillis(1533038400000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_64) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 64));
+}
+
+// $fromMillis(1419940800000, 'Week: [w] of [xNn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_65) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 65));
+}
+
+// $toMillis('2018-10-21T13:05:00Z').[$fromMillis(), $fromMillis($, (),'-0500'), $fromMillis($, (),'0000')] 
+TEST_F(function_fromMillisTest, formatDateTime_case_66) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 66));
+}
+
+// $fromMillis(1521801216617, '[F], [D]/[M]/[Y] [h]:[m]:[s] [PN]')
+TEST_F(function_fromMillisTest, formatDateTime_case_67) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 67));
+}
+
+// $fromMillis(1521801216617, '[F], [D]/[M]/[Y] [h]:[m]:[s] [Pn]')
+TEST_F(function_fromMillisTest, formatDateTime_case_68) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 68));
+}
+
+// $fromMillis(1419940800000, '[YN]-[M]-[D]')
+TEST_F(function_fromMillisTest, formatDateTime_case_69) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 69));
+}
+
+// $fromMillis(1419940800000, '[YN]-[M')
+TEST_F(function_fromMillisTest, formatDateTime_case_70) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/formatDateTime.json", 70));
+}
+
+// ($ts := $toMillis('2005-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 0));
+}
+
+// ($ts := $toMillis('2005-01-02', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 1));
+}
+
+// ($ts := $toMillis('2005-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 2));
+}
+
+// ($ts := $toMillis('2006-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 3));
+}
+
+// ($ts := $toMillis('2006-01-02', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 4));
+}
+
+// ($ts := $toMillis('2006-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 5));
+}
+
+// ($ts := $toMillis('2007-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 6));
+}
+
+// ($ts := $toMillis('2007-12-30', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 7));
+}
+
+// ($ts := $toMillis('2007-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 8));
+}
+
+// ($ts := $toMillis('2008-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 9));
+}
+
+// ($ts := $toMillis('2008-12-28', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 10));
+}
+
+// ($ts := $toMillis('2008-12-29', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 11));
+}
+
+// ($ts := $toMillis('2008-12-30', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 12));
+}
+
+// ($ts := $toMillis('2008-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 13));
+}
+
+// ($ts := $toMillis('2009-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 14));
+}
+
+// ($ts := $toMillis('2009-12-31', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 15));
+}
+
+// ($ts := $toMillis('2010-01-01', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 16));
+}
+
+// ($ts := $toMillis('2010-01-02', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 17));
+}
+
+// ($ts := $toMillis('2010-01-03', '[Y]-[M]-[D]'); $fromMillis($ts, '[X0001]-W[W01]-[F1]') )
+TEST_F(function_fromMillisTest, isoWeekDate_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-fromMillis/isoWeekDate.json", 18));
 }
 
diff --git a/test/gen/function_joinTest.cpp b/test/gen/function_joinTest.cpp
index 35b36b8..3d4e72f 100644
--- a/test/gen/function_joinTest.cpp
+++ b/test/gen/function_joinTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class function_joinTest : public JsonataTest {
 };
 
-// 
+// $join(\"hello\")
 TEST_F(function_joinTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case000.json"));
 }
 
-// 
+// $join([\"hello\"])
 TEST_F(function_joinTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case001.json"));
 }
 
-// 
+// $join([\"hello\", \"world\"])
 TEST_F(function_joinTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case002.json"));
 }
 
-// 
+// $join([\"hello\", \"world\"], \", \")
 TEST_F(function_joinTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case003.json"));
 }
 
-// 
+// $join([], \", \")
 TEST_F(function_joinTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case004.json"));
 }
 
-// 
+// $join(Account.Order.Product.Description.Colour, \", \")
 TEST_F(function_joinTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case005.json"));
 }
 
-// 
+// $join(Account.Order.Product.Description.Colour, no.sep)
 TEST_F(function_joinTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case006.json"));
 }
 
-// 
+// $join(Account.blah.Product.Description.Colour, \", \")
 TEST_F(function_joinTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case007.json"));
 }
 
-// 
+// $join(true, \", \")
 TEST_F(function_joinTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case008.json"));
 }
 
-// 
+// $join([1,2,3], \", \")
 TEST_F(function_joinTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case009.json"));
 }
 
-// 
+// $join([\"hello\"], 3)
 TEST_F(function_joinTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case010.json"));
 }
 
-// 
+// $join()
 TEST_F(function_joinTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-join/case011.json"));
 }
diff --git a/test/gen/function_keysTest.cpp b/test/gen/function_keysTest.cpp
index 5e0d011..bbf30c9 100644
--- a/test/gen/function_keysTest.cpp
+++ b/test/gen/function_keysTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_keysTest : public JsonataTest {
 };
 
-// 
+// $keys(Account)
 TEST_F(function_keysTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case000.json"));
 }
 
-// 
+// $keys(Account.Order.Product)
 TEST_F(function_keysTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case001.json"));
 }
 
-// 
+// $keys({})
 TEST_F(function_keysTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case002.json"));
 }
 
-// 
+// $keys({\"foo\":{}})
 TEST_F(function_keysTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case003.json"));
 }
 
-// 
+// $keys(\"foo\")
 TEST_F(function_keysTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case004.json"));
 }
 
-// 
+// $keys(function(){1})
 TEST_F(function_keysTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case005.json"));
 }
 
-// 
+// $keys([\"foo\", \"bar\"])
 TEST_F(function_keysTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-keys/case006.json"));
 }
diff --git a/test/gen/function_lengthTest.cpp b/test/gen/function_lengthTest.cpp
index 870df01..1bc2348 100644
--- a/test/gen/function_lengthTest.cpp
+++ b/test/gen/function_lengthTest.cpp
@@ -6,87 +6,87 @@ using namespace jsonata;
 class function_lengthTest : public JsonataTest {
 };
 
-// 
+// $length(\"\")
 TEST_F(function_lengthTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case000.json"));
 }
 
-// 
+// $length(\"hello\")
 TEST_F(function_lengthTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case001.json"));
 }
 
-// 
+// $length(missing)
 TEST_F(function_lengthTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case002.json"));
 }
 
-// 
+// $length(\"\\u03BB-calculus\")
 TEST_F(function_lengthTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case003.json"));
 }
 
-// $length(\\\"\\\\uD834\\\\uDD1E\\\")
+// $length(\"\\uD834\\uDD1E\")
 TEST_F(function_lengthTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case004.json"));
 }
 
-// 
+// $length(\"𝄞\")
 TEST_F(function_lengthTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case005.json"));
 }
 
-// 
+// $length(\"超明體繁\")
 TEST_F(function_lengthTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case006.json"));
 }
 
-// 
+// $length(\"\\t\")
 TEST_F(function_lengthTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case007.json"));
 }
 
-// 
+// $length(\"\\n\")
 TEST_F(function_lengthTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case008.json"));
 }
 
-// 
+// $length(1234)
 TEST_F(function_lengthTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case009.json"));
 }
 
-// 
+// $length(null)
 TEST_F(function_lengthTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case010.json"));
 }
 
-// 
+// $length(true)
 TEST_F(function_lengthTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case011.json"));
 }
 
-// 
+// $length([\"str\"])
 TEST_F(function_lengthTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case012.json"));
 }
 
-// 
+// $length()
 TEST_F(function_lengthTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case013.json"));
 }
 
-// 
+// $length()
 TEST_F(function_lengthTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case014.json"));
 }
 
-// 
+// $length(\"Hello\", \"World\")
 TEST_F(function_lengthTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case015.json"));
 }
 
-// 
+// $length(\"𝄞💩\")
 TEST_F(function_lengthTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-length/case016.json"));
 }
diff --git a/test/gen/function_lookupTest.cpp b/test/gen/function_lookupTest.cpp
index 560ca64..c117769 100644
--- a/test/gen/function_lookupTest.cpp
+++ b/test/gen/function_lookupTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_lookupTest : public JsonataTest {
 };
 
-// 
+// $lookup(Account, \"Account Name\")
 TEST_F(function_lookupTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case000.json"));
 }
 
-// 
+// $lookup(Account.Order.Product, \"Product Name\")
 TEST_F(function_lookupTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case001.json"));
 }
 
-// 
+// $lookup(Account.Order.Product.ProductID, \"Product Name\")
 TEST_F(function_lookupTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case002.json"));
 }
 
-// 
+// $lookup($$, \"gust\")
 TEST_F(function_lookupTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lookup/case003.json"));
 }
diff --git a/test/gen/function_lowercaseTest.cpp b/test/gen/function_lowercaseTest.cpp
index a27d319..773f764 100644
--- a/test/gen/function_lowercaseTest.cpp
+++ b/test/gen/function_lowercaseTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_lowercaseTest : public JsonataTest {
 };
 
-// 
+// $lowercase(\"Hello World\")
 TEST_F(function_lowercaseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lowercase/case000.json"));
 }
 
-// 
+// $lowercase(blah)
 TEST_F(function_lowercaseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-lowercase/case001.json"));
 }
diff --git a/test/gen/function_maxTest.cpp b/test/gen/function_maxTest.cpp
index 44c0fa3..ab30d8e 100644
--- a/test/gen/function_maxTest.cpp
+++ b/test/gen/function_maxTest.cpp
@@ -6,137 +6,137 @@ using namespace jsonata;
 class function_maxTest : public JsonataTest {
 };
 
-// 
+// $max(Account.Order.Product.(Price * Quantity))
 TEST_F(function_maxTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case000.json"));
 }
 
-// 
+// Account.Order.$max(Product.(Price * Quantity))
 TEST_F(function_maxTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case001.json"));
 }
 
-// 
+// Account.Order.(OrderID & \": \" & $count(Product.(Price*Quantity)))
 TEST_F(function_maxTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case002.json"));
 }
 
-// 
+// $max([])
 TEST_F(function_maxTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case003.json"));
 }
 
-// 
+// $max([1,2,3])
 TEST_F(function_maxTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case004.json"));
 }
 
-// 
+// $max([\"1\",\"2\",\"3\"])
 TEST_F(function_maxTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case005.json"));
 }
 
-// 
+// $max([\"1\",\"2\",3])
 TEST_F(function_maxTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case006.json"));
 }
 
-// 
+// $max(1)
 TEST_F(function_maxTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case007.json"));
 }
 
-// 
+// $max([-1,-5])
 TEST_F(function_maxTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case008.json"));
 }
 
-// 
+// $max([],[])
 TEST_F(function_maxTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case009.json"));
 }
 
-// 
+// $max([1,2,3],[])
 TEST_F(function_maxTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case010.json"));
 }
 
-// 
+// $max([],[],[])
 TEST_F(function_maxTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case011.json"));
 }
 
-// 
+// $max([1,2],[],[])
 TEST_F(function_maxTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case012.json"));
 }
 
-// 
+// $max(undefined)
 TEST_F(function_maxTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case013.json"));
 }
 
-// 
+// $min(Account.Order.Product.(Price * Quantity))
 TEST_F(function_maxTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case014.json"));
 }
 
-// 
+// Account.Order.$min(Product.(Price * Quantity))
 TEST_F(function_maxTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case015.json"));
 }
 
-// 
+// Account.Order.(OrderID & \": \" & $min(Product.(Price*Quantity)))
 TEST_F(function_maxTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case016.json"));
 }
 
-// 
+// $min([])
 TEST_F(function_maxTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case017.json"));
 }
 
-// 
+// $min([1,2,3])
 TEST_F(function_maxTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case018.json"));
 }
 
-// 
+// $min([\"1\",\"2\",\"3\"])
 TEST_F(function_maxTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case019.json"));
 }
 
-// 
+// $min([\"1\",\"2\",3])
 TEST_F(function_maxTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case020.json"));
 }
 
-// 
+// $min(1)
 TEST_F(function_maxTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case021.json"));
 }
 
-// 
+// $min([],[])
 TEST_F(function_maxTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case022.json"));
 }
 
-// 
+// $min([1,2,3],[])
 TEST_F(function_maxTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case023.json"));
 }
 
-// 
+// $min([],[],[])
 TEST_F(function_maxTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case024.json"));
 }
 
-// 
+// $min([1,2],[],[])
 TEST_F(function_maxTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case025.json"));
 }
 
-// 
+// $min(undefined)
 TEST_F(function_maxTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-max/case026.json"));
 }
diff --git a/test/gen/function_mergeTest.cpp b/test/gen/function_mergeTest.cpp
index 237117f..f0ae95b 100644
--- a/test/gen/function_mergeTest.cpp
+++ b/test/gen/function_mergeTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_mergeTest : public JsonataTest {
 };
 
-// 
+// $merge(nothing)
 TEST_F(function_mergeTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case000.json"));
 }
 
-// 
+// $merge({\"a\":1})
 TEST_F(function_mergeTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case001.json"));
 }
 
-// 
+// $merge([{\"a\":1}, {\"b\":2}])
 TEST_F(function_mergeTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case002.json"));
 }
 
-// 
+// $merge([{\"a\": 1}, {\"b\": 2, \"c\": 3}])
 TEST_F(function_mergeTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case003.json"));
 }
 
-// 
+// $merge([{\"a\": 1}, {\"b\": 2, \"a\": 3}])
 TEST_F(function_mergeTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-merge/case004.json"));
 }
diff --git a/test/gen/function_numberTest.cpp b/test/gen/function_numberTest.cpp
index b97eda8..c56bf32 100644
--- a/test/gen/function_numberTest.cpp
+++ b/test/gen/function_numberTest.cpp
@@ -6,172 +6,172 @@ using namespace jsonata;
 class function_numberTest : public JsonataTest {
 };
 
-// 
+// $number(0)
 TEST_F(function_numberTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case000.json"));
 }
 
-// 
+// $number(10)
 TEST_F(function_numberTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case001.json"));
 }
 
-// 
+// $number(-0.05)
 TEST_F(function_numberTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case002.json"));
 }
 
-// 
+// $number(\"0\")
 TEST_F(function_numberTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case003.json"));
 }
 
-// 
+// $number(\"-0.05\")
 TEST_F(function_numberTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case004.json"));
 }
 
-// 
+// $number(\"1e2\")
 TEST_F(function_numberTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case005.json"));
 }
 
-// 
+// $number(\"1.0e-2\")
 TEST_F(function_numberTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case006.json"));
 }
 
-// 
+// $number(\"1e0\")
 TEST_F(function_numberTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case007.json"));
 }
 
-// 
+// $number(\"10e500\")
 TEST_F(function_numberTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case008.json"));
 }
 
-// 
+// $number(\"Hello world\")
 TEST_F(function_numberTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case009.json"));
 }
 
-// 
+// $number(\"1/2\")
 TEST_F(function_numberTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case010.json"));
 }
 
-// 
+// $number(\"1234 hello\")
 TEST_F(function_numberTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case011.json"));
 }
 
-// 
+// $number(\"\")
 TEST_F(function_numberTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case012.json"));
 }
 
-// 
+// $number(true)
 TEST_F(function_numberTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case013.json"));
 }
 
-// 
+// $number(false)
 TEST_F(function_numberTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case014.json"));
 }
 
-// 
+// $number(Account.blah)
 TEST_F(function_numberTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case015.json"));
 }
 
-// 
+// $number(null)
 TEST_F(function_numberTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case016.json"));
 }
 
-// 
+// $number([])
 TEST_F(function_numberTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case017.json"));
 }
 
-// 
+// $number(\"[1]\")
 TEST_F(function_numberTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case018.json"));
 }
 
-// 
+// $number([1,2])
 TEST_F(function_numberTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case019.json"));
 }
 
-// 
+// $number([\"hello\"])
 TEST_F(function_numberTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case020.json"));
 }
 
-// 
+// $number([\"2\"])
 TEST_F(function_numberTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case021.json"));
 }
 
-// 
+// $number({})
 TEST_F(function_numberTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case022.json"));
 }
 
-// 
+// $number({\"hello\":\"world\"})
 TEST_F(function_numberTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case023.json"));
 }
 
-// 
+// $number($number)
 TEST_F(function_numberTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case024.json"));
 }
 
-// 
+// $number(function(){5})
 TEST_F(function_numberTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case025.json"));
 }
 
-// 
+// $number(1,2)
 TEST_F(function_numberTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case026.json"));
 }
 
-// 
+// $number('00')
 TEST_F(function_numberTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case027.json"));
 }
 
-// 
+// $number('0123')
 TEST_F(function_numberTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case028.json"));
 }
 
-// 
+// $number('-007')
 TEST_F(function_numberTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case029.json"));
 }
 
-// 
+// $number('000.00123000')
 TEST_F(function_numberTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case030.json"));
 }
 
-// 
+// $number('0x12')
 TEST_F(function_numberTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case031.json"));
 }
 
-// 
+// $number('0B101')
 TEST_F(function_numberTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case032.json"));
 }
 
-// 
+// $number('0O12')
 TEST_F(function_numberTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-number/case033.json"));
 }
diff --git a/test/gen/function_padTest.cpp b/test/gen/function_padTest.cpp
index 1599604..8744a11 100644
--- a/test/gen/function_padTest.cpp
+++ b/test/gen/function_padTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class function_padTest : public JsonataTest {
 };
 
-// 
+// $pad(\"foo\", 5)
 TEST_F(function_padTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case000.json"));
 }
 
-// 
+// $pad(\"foo\", -5)
 TEST_F(function_padTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case001.json"));
 }
 
-// 
+// $pad(\"foo\", -5, \"#\")
 TEST_F(function_padTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case002.json"));
 }
 
-// 
+// $pad(\"foo\", 5, \"\")
 TEST_F(function_padTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case003.json"));
 }
 
-// 
+// $pad(\"foo\", 1)
 TEST_F(function_padTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case004.json"));
 }
 
-// 
+// $pad(\"foo\", 8, \"-+\")
 TEST_F(function_padTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case005.json"));
 }
 
-// 
+// $pad(nothing, 1)
 TEST_F(function_padTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case006.json"));
 }
 
-// 
+// $pad('a𝄞💩', 7)
 TEST_F(function_padTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case007.json"));
 }
 
-// 
+// $pad('𝄞💩', -7)
 TEST_F(function_padTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case008.json"));
 }
 
-// 
+// $pad('a𝄞💩', 7, '💩')
 TEST_F(function_padTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case009.json"));
 }
 
-// 
+// $pad('a𝄞💩', 6, '💩')
 TEST_F(function_padTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case010.json"));
 }
 
-// 
+// $pad('foo', 5.7, ' ')
 TEST_F(function_padTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case011.json"));
 }
 
-// 
+// $pad('foo', -5.7, ' ')
 TEST_F(function_padTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-pad/case012.json"));
 }
diff --git a/test/gen/function_parseIntegerTest.cpp b/test/gen/function_parseIntegerTest.cpp
index 02e4c02..414d623 100644
--- a/test/gen/function_parseIntegerTest.cpp
+++ b/test/gen/function_parseIntegerTest.cpp
@@ -6,8 +6,308 @@ using namespace jsonata;
 class function_parseIntegerTest : public JsonataTest {
 };
 
-// 
-TEST_F(function_parseIntegerTest, parseInteger) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json"));
+// $parseInteger(undefined, '0')
+TEST_F(function_parseIntegerTest, parseInteger_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 0));
+}
+
+// $parseInteger('123', '000')
+TEST_F(function_parseIntegerTest, parseInteger_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 1));
+}
+
+// $parseInteger('0123', '0000')
+TEST_F(function_parseIntegerTest, parseInteger_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 2));
+}
+
+// $parseInteger('1234', '0')
+TEST_F(function_parseIntegerTest, parseInteger_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 3));
+}
+
+// $parseInteger('1234', '###0')
+TEST_F(function_parseIntegerTest, parseInteger_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 4));
+}
+
+// $parseInteger('12', '###0')
+TEST_F(function_parseIntegerTest, parseInteger_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 5));
+}
+
+// $parseInteger('123rd', '000;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 6));
+}
+
+// $parseInteger('1st', '0;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 7));
+}
+
+// $parseInteger('28th', '#0;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 8));
+}
+
+// $parseInteger('1234th', '###0;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 9));
+}
+
+// $parseInteger('12th', '###0;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 10));
+}
+
+// $parseInteger('١٢٣٤٠', '###١')
+TEST_F(function_parseIntegerTest, parseInteger_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 11));
+}
+
+// $parseInteger('１２３４０', '###０')
+TEST_F(function_parseIntegerTest, parseInteger_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 12));
+}
+
+// $parseInteger('12', '#,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 13));
+}
+
+// $parseInteger('1,200', '#,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 14));
+}
+
+// $parseInteger('12,345,678', '#,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 15));
+}
+
+// $parseInteger('1,234,567,890', '#,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 16));
+}
+
+// $parseInteger('1,234,567,890', '#,###,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 17));
+}
+
+// $parseInteger('1234:567,890', '#:###,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 18));
+}
+
+// $parseInteger('12345,67,890', '##,##,##0')
+TEST_F(function_parseIntegerTest, parseInteger_case_19) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 19));
+}
+
+// $parseInteger('', 'I')
+TEST_F(function_parseIntegerTest, parseInteger_case_20) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 20));
+}
+
+// $parseInteger('MCMLXXXIV', 'I')
+TEST_F(function_parseIntegerTest, parseInteger_case_21) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 21));
+}
+
+// $parseInteger('xcix', 'i')
+TEST_F(function_parseIntegerTest, parseInteger_case_22) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 22));
+}
+
+// $parseInteger('twelve', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_23) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 23));
+}
+
+// $parseInteger('twenty', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_24) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 24));
+}
+
+// $parseInteger('thirty-four', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_25) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 25));
+}
+
+// $parseInteger('NINETY-NINE', 'W')
+TEST_F(function_parseIntegerTest, parseInteger_case_26) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 26));
+}
+
+// $parseInteger('one hundred', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_27) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 27));
+}
+
+// $parseInteger('FIVE HUNDRED AND FIFTY-FIVE', 'W')
+TEST_F(function_parseIntegerTest, parseInteger_case_28) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 28));
+}
+
+// $parseInteger('Five Hundred and Fifty-Five', 'Ww')
+TEST_F(function_parseIntegerTest, parseInteger_case_29) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 29));
+}
+
+// $parseInteger('nine hundred and nineteen', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_30) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 30));
+}
+
+// $parseInteger('seven hundred and thirty', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_31) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 31));
+}
+
+// $parseInteger('one thousand', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_32) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 32));
+}
+
+// $parseInteger('three thousand, seven hundred and thirty', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_33) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 33));
+}
+
+// $parseInteger('three hundred and twenty-seven thousand, seven hundred and thirty', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_34) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 34));
+}
+
+// $parseInteger('four million, three hundred and twenty-seven thousand, seven hundred and thirty', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_35) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 35));
+}
+
+// $parseInteger('one trillion and one', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_36) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 36));
+}
+
+// $parseInteger('one trillion, two hundred and thirty-four billion, five hundred and sixty-seven million, eight hundred and ninety thousand, one hundred and twenty-three', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_37) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 37));
+}
+
+// $parseInteger('one thousand trillion', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_38) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 38));
+}
+
+// $parseInteger('ten billion trillion trillion trillion', 'w')
+TEST_F(function_parseIntegerTest, parseInteger_case_39) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 39));
+}
+
+// $parseInteger('twelfth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_40) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 40));
+}
+
+// $parseInteger('twentieth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_41) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 41));
+}
+
+// $parseInteger('thirty-fourth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_42) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 42));
+}
+
+// $parseInteger('NINETY-NINTH', 'W;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_43) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 43));
+}
+
+// $parseInteger('one hundredth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_44) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 44));
+}
+
+// $parseInteger('FIVE HUNDRED AND FIFTY-FIFTH', 'W;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_45) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 45));
+}
+
+// $parseInteger('nine hundred and nineteenth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_46) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 46));
+}
+
+// $parseInteger('seven hundred and thirtieth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_47) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 47));
+}
+
+// $parseInteger('Seven Hundred and Thirty-Third', 'Ww;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_48) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 48));
+}
+
+// $parseInteger('one thousandth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_49) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 49));
+}
+
+// $parseInteger('three thousand, seven hundred and thirty-first', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_50) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 50));
+}
+
+// $parseInteger('three hundred and twenty-seven thousand, seven hundred and thirteenth', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_51) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 51));
+}
+
+// $parseInteger('four million, three hundred and twenty-seven thousand, seven hundred and thirty-second', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_52) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 52));
+}
+
+// $parseInteger('one trillion and first', 'w;o')
+TEST_F(function_parseIntegerTest, parseInteger_case_53) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 53));
+}
+
+// $parseInteger('A', 'A')
+TEST_F(function_parseIntegerTest, parseInteger_case_54) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 54));
+}
+
+// $parseInteger('l', 'a')
+TEST_F(function_parseIntegerTest, parseInteger_case_55) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 55));
+}
+
+// $parseInteger('z', 'a')
+TEST_F(function_parseIntegerTest, parseInteger_case_56) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 56));
+}
+
+// $parseInteger('aa', 'a')
+TEST_F(function_parseIntegerTest, parseInteger_case_57) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 57));
+}
+
+// $parseInteger('KN', 'A')
+TEST_F(function_parseIntegerTest, parseInteger_case_58) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 58));
+}
+
+// $parseInteger('FZPH', 'A')
+TEST_F(function_parseIntegerTest, parseInteger_case_59) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 59));
+}
+
+// $parseInteger('50', '#')
+TEST_F(function_parseIntegerTest, parseInteger_case_60) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-parseInteger/parseInteger.json", 60));
 }
 
diff --git a/test/gen/function_powerTest.cpp b/test/gen/function_powerTest.cpp
index f3293bd..e73cae9 100644
--- a/test/gen/function_powerTest.cpp
+++ b/test/gen/function_powerTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_powerTest : public JsonataTest {
 };
 
-// 
+// $power(4, 2)
 TEST_F(function_powerTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case000.json"));
 }
 
-// 
+// $power(4, 0.5)
 TEST_F(function_powerTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case001.json"));
 }
 
-// 
+// $power(10, -2)
 TEST_F(function_powerTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case002.json"));
 }
 
-// 
+// $power(-2, 3)
 TEST_F(function_powerTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case003.json"));
 }
 
-// 
+// $power(nothing, 3)
 TEST_F(function_powerTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case004.json"));
 }
 
-// 
+// $power(-2, 1/3)
 TEST_F(function_powerTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case005.json"));
 }
 
-// 
+// $power(100, 1000)
 TEST_F(function_powerTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-power/case006.json"));
 }
diff --git a/test/gen/function_replaceTest.cpp b/test/gen/function_replaceTest.cpp
index 7d724f2..c4d80a3 100644
--- a/test/gen/function_replaceTest.cpp
+++ b/test/gen/function_replaceTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class function_replaceTest : public JsonataTest {
 };
 
-// 
+// $replace(\"Hello World\", \"World\", \"Everyone\")
 TEST_F(function_replaceTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case000.json"));
 }
 
-// 
+// $replace(\"the cat sat on the mat\", \"at\", \"it\")
 TEST_F(function_replaceTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case001.json"));
 }
 
-// 
+// $replace(\"the cat sat on the mat\", \"at\", \"it\", 0)
 TEST_F(function_replaceTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case002.json"));
 }
 
-// 
+// $replace(\"the cat sat on the mat\", \"at\", \"it\", 2)
 TEST_F(function_replaceTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case003.json"));
 }
 
-// 
+// $replace(nothing, \"at\", \"it\", 2)
 TEST_F(function_replaceTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case004.json"));
 }
 
-// 
+// $replace(\"hello\")
 TEST_F(function_replaceTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case005.json"));
 }
 
-// 
+// $replace(\"hello\", \"l\", \"1\", null)
 TEST_F(function_replaceTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case006.json"));
 }
 
-// 
+// $replace(\"hello\", \"l\", \"1\", -2)
 TEST_F(function_replaceTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case007.json"));
 }
 
-// 
+// $replace(\"hello\", 1)
 TEST_F(function_replaceTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case008.json"));
 }
 
-// 
+// $replace(\"hello\", \"\", \"bye\")
 TEST_F(function_replaceTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case009.json"));
 }
 
-// 
+// $replace(\"hello\", 2, 1)
 TEST_F(function_replaceTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case010.json"));
 }
 
-// 
+// $replace(123, 2, 1)
 TEST_F(function_replaceTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-replace/case011.json"));
 }
diff --git a/test/gen/function_reverseTest.cpp b/test/gen/function_reverseTest.cpp
index 79a0d04..df52963 100644
--- a/test/gen/function_reverseTest.cpp
+++ b/test/gen/function_reverseTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_reverseTest : public JsonataTest {
 };
 
-// 
+// $reverse([1..5])
 TEST_F(function_reverseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case000.json"));
 }
 
-// 
+// [[$], [$reverse($)], [$]]
 TEST_F(function_reverseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case001.json"));
 }
 
-// 
+// $reverse(nothing)
 TEST_F(function_reverseTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case002.json"));
 }
 
-// 
+// $reverse([1])
 TEST_F(function_reverseTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-reverse/case003.json"));
 }
diff --git a/test/gen/function_roundTest.cpp b/test/gen/function_roundTest.cpp
index d111de5..b4e6a9b 100644
--- a/test/gen/function_roundTest.cpp
+++ b/test/gen/function_roundTest.cpp
@@ -6,92 +6,92 @@ using namespace jsonata;
 class function_roundTest : public JsonataTest {
 };
 
-// 
+// $round(4)
 TEST_F(function_roundTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case000.json"));
 }
 
-// 
+// $round(2.3)
 TEST_F(function_roundTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case001.json"));
 }
 
-// 
+// $round(2.7)
 TEST_F(function_roundTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case002.json"));
 }
 
-// 
+// $round(2.5)
 TEST_F(function_roundTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case003.json"));
 }
 
-// 
+// $round(3.5)
 TEST_F(function_roundTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case004.json"));
 }
 
-// 
+// $round(-0.5)
 TEST_F(function_roundTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case005.json"));
 }
 
-// 
+// $round(-0.3)
 TEST_F(function_roundTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case006.json"));
 }
 
-// 
+// $round(0.5)
 TEST_F(function_roundTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case007.json"));
 }
 
-// 
+// $round(-7.5)
 TEST_F(function_roundTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case008.json"));
 }
 
-// 
+// $round(-8.5)
 TEST_F(function_roundTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case009.json"));
 }
 
-// 
+// $round(4.49, 1)
 TEST_F(function_roundTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case010.json"));
 }
 
-// 
+// $round(4.525, 2)
 TEST_F(function_roundTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case011.json"));
 }
 
-// 
+// $round(4.515, 2)
 TEST_F(function_roundTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case012.json"));
 }
 
-// 
+// $round(12345, -2)
 TEST_F(function_roundTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case013.json"));
 }
 
-// 
+// $round(12450, -2)
 TEST_F(function_roundTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case014.json"));
 }
 
-// 
+// $round(12350, -2)
 TEST_F(function_roundTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case015.json"));
 }
 
-// 
+// $round(6.022e-23, 24)
 TEST_F(function_roundTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case016.json"));
 }
 
-// 
+// $round(unknown)
 TEST_F(function_roundTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-round/case017.json"));
 }
diff --git a/test/gen/function_shuffleTest.cpp b/test/gen/function_shuffleTest.cpp
index d15e443..6c2a749 100644
--- a/test/gen/function_shuffleTest.cpp
+++ b/test/gen/function_shuffleTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_shuffleTest : public JsonataTest {
 };
 
-// 
+// $count($shuffle([1..10]))
 TEST_F(function_shuffleTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case000.json"));
 }
 
-// 
+// $sort($shuffle([1..10]))
 TEST_F(function_shuffleTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case001.json"));
 }
 
-// 
+// $shuffle(nothing)
 TEST_F(function_shuffleTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case002.json"));
 }
 
-// 
+// $shuffle([1])
 TEST_F(function_shuffleTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-shuffle/case003.json"));
 }
diff --git a/test/gen/function_siftTest.cpp b/test/gen/function_siftTest.cpp
index 3324109..a16d43c 100644
--- a/test/gen/function_siftTest.cpp
+++ b/test/gen/function_siftTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_siftTest : public JsonataTest {
 };
 
-// 
+// $sift(λ($v){$v.**.Postcode})
 TEST_F(function_siftTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case000.json"));
 }
 
-// 
+// **[*].$sift(λ($v){$v.Postcode})
 TEST_F(function_siftTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case001.json"));
 }
 
-// 
+// $sift(λ($v, $k){$k ~> /^A/})
 TEST_F(function_siftTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case002.json"));
 }
 
-// 
+// $sift({'a': 1, 'b': 0}, $boolean)
 TEST_F(function_siftTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case003.json"));
 }
 
-// 
+// $sift({'a': 'hello', 'b': 'world', 'hello': 'again'}, λ($v,$k,$o){$lookup($o, $v)})
 TEST_F(function_siftTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sift/case004.json"));
 }
diff --git a/test/gen/function_signaturesTest.cpp b/test/gen/function_signaturesTest.cpp
index 1ed1d00..95147be 100644
--- a/test/gen/function_signaturesTest.cpp
+++ b/test/gen/function_signaturesTest.cpp
@@ -6,177 +6,177 @@ using namespace jsonata;
 class function_signaturesTest : public JsonataTest {
 };
 
-// 
+// λ($arg)<b:b>{$not($arg)}(true)
 TEST_F(function_signaturesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case000.json"));
 }
 
-// 
+// λ($arg)<b:b>{$not($arg)}(foo)
 TEST_F(function_signaturesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case001.json"));
 }
 
-// 
+// λ($arg)<x:b>{$not($arg)}(null)
 TEST_F(function_signaturesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case002.json"));
 }
 
-// 
+// function($x,$y)<n-n:n>{$x+$y}(2, 6)
 TEST_F(function_signaturesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case003.json"));
 }
 
-// 
+// [1..5].function($x,$y)<n-n:n>{$x+$y}(6)
 TEST_F(function_signaturesTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case004.json"));
 }
 
-// 
+// [1..5].function($x,$y)<n-n:n>{$x+$y}(2, 6)
 TEST_F(function_signaturesTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case005.json"));
 }
 
-// 
+// Age.function($x,$y)<n-n:n>{$x+$y}(6)
 TEST_F(function_signaturesTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case006.json"));
 }
 
-// 
+// λ($str)<s->{$uppercase($str)}(\"hello\")
 TEST_F(function_signaturesTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case007.json"));
 }
 
-// 
+// Account.Order.Product.Description.Colour.λ($str)<s->{$uppercase($str)}()
 TEST_F(function_signaturesTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case008.json"));
 }
 
-// 
+// λ($str, $prefix)<s-s>{$prefix & $str}(\"World\", \"Hello \")
 TEST_F(function_signaturesTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case009.json"));
 }
 
-// 
+// FirstName.λ($str, $prefix)<s-s>{$prefix & $str}(\"Hello \")
 TEST_F(function_signaturesTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case010.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}(\"a\")
 TEST_F(function_signaturesTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case011.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([\"a\"])
 TEST_F(function_signaturesTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case012.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}(\"a\", \"-\")
 TEST_F(function_signaturesTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case013.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([\"a\"], \"-\")
 TEST_F(function_signaturesTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case014.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([\"a\", \"b\"], \"-\")
 TEST_F(function_signaturesTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case015.json"));
 }
 
-// 
+// λ($arr, $sep)<as?:s>{$join($arr, $sep)}([\"a\", \"b\"], \"-\")
 TEST_F(function_signaturesTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case016.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}([], \"-\")
 TEST_F(function_signaturesTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case017.json"));
 }
 
-// 
+// λ($arr, $sep)<a<s>s?:s>{$join($arr, $sep)}(foo, \"-\")
 TEST_F(function_signaturesTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case018.json"));
 }
 
-// 
+// λ($obj)<o>{$obj}({\"hello\": \"world\"})
 TEST_F(function_signaturesTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case019.json"));
 }
 
-// 
+// λ($arr)<a<a<n>>>{$arr}([[1]])
 TEST_F(function_signaturesTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case020.json"));
 }
 
-// 
+// λ($num)<(ns)-:n>{$number($num)}(5)
 TEST_F(function_signaturesTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case021.json"));
 }
 
-// 
+// λ($num)<(ns)-:n>{$number($num)}(\"5\")
 TEST_F(function_signaturesTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case022.json"));
 }
 
-// 
+// [1..5].λ($num)<(ns)-:n>{$number($num)}()
 TEST_F(function_signaturesTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case023.json"));
 }
 
-// 
+// ($twice := function($f)<f:f>{function($x)<n:n>{$f($f($x))}};$add2 := function($x)<n:n>{$x+2};$add4 := $twice($add2);$add4(5))
 TEST_F(function_signaturesTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case024.json"));
 }
 
-// 
+// ($twice := function($f)<f<n:n>:f<n:n>>{function($x)<n:n>{$f($f($x))}};$add2 := function($x)<n:n>{$x+2};$add4 := $twice($add2);$add4(5))
 TEST_F(function_signaturesTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case025.json"));
 }
 
-// 
+// λ($arg)<n<n>>{$arg}(5)
 TEST_F(function_signaturesTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case026.json"));
 }
 
-// 
+// λ($arg1, $arg2)<nn:a>{[$arg1, $arg2]}(1,\"2\")
 TEST_F(function_signaturesTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case027.json"));
 }
 
-// 
+// λ($arg1, $arg2)<nn:a>{[$arg1, $arg2]}(1,3,\"2\")
 TEST_F(function_signaturesTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case028.json"));
 }
 
-// 
+// λ($arg1, $arg2)<nn+:a>{[$arg1, $arg2]}(1,3, 2,\"g\")
 TEST_F(function_signaturesTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case029.json"));
 }
 
-// 
+// λ($arr)<a<n>>{$arr}([\"3\"]) 
 TEST_F(function_signaturesTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case030.json"));
 }
 
-// 
+// λ($arr)<a<n>>{$arr}([1, 2, \"3\"]) 
 TEST_F(function_signaturesTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case031.json"));
 }
 
-// 
+// λ($arr)<a<n>>{$arr}(\"f\")
 TEST_F(function_signaturesTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case032.json"));
 }
 
-// 
+// ($fun := λ($arr)<a<n>>{$arr};$fun(\"f\"))
 TEST_F(function_signaturesTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case033.json"));
 }
 
-// 
+// λ($arr)<(sa<n>)>>{$arr}([[1]])
 TEST_F(function_signaturesTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-signatures/case034.json"));
 }
diff --git a/test/gen/function_sortTest.cpp b/test/gen/function_sortTest.cpp
index 248944c..dcfb1d5 100644
--- a/test/gen/function_sortTest.cpp
+++ b/test/gen/function_sortTest.cpp
@@ -6,57 +6,57 @@ using namespace jsonata;
 class function_sortTest : public JsonataTest {
 };
 
-// 
+// $sort(nothing)
 TEST_F(function_sortTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case000.json"));
 }
 
-// 
+// $sort(1)
 TEST_F(function_sortTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case001.json"));
 }
 
-// 
+// $sort([1,3,2])
 TEST_F(function_sortTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case002.json"));
 }
 
-// 
+// $sort([1,3,22,11])
 TEST_F(function_sortTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case003.json"));
 }
 
-// 
+// [[$], [$sort($)], [$]]
 TEST_F(function_sortTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case004.json"));
 }
 
-// 
+// $sort(Account.Order.Product.Price)
 TEST_F(function_sortTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case005.json"));
 }
 
-// 
+// $sort(Account.Order.Product.\"Product Name\")
 TEST_F(function_sortTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case006.json"));
 }
 
-// 
+// $sort(Account.Order.Product)
 TEST_F(function_sortTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case007.json"));
 }
 
-// 
+// $sort(Account.Order.Product, function($a, $b) { $a.(Price * Quantity) > $b.(Price * Quantity) }).(Price & \" x \" & Quantity)
 TEST_F(function_sortTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case008.json"));
 }
 
-// 
+// $sort(Account.Order.Product, function($a, $b) { $a.Price > $b.Price }).SKU
 TEST_F(function_sortTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case009.json"));
 }
 
-// 
+//                  (Account.Order.Product                   ~> $sort(λ($a,$b){$a.Quantity < $b.Quantity})                   ~> $sort(λ($a,$b){$a.Price > $b.Price})                 ).SKU             
 TEST_F(function_sortTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sort/case010.json"));
 }
diff --git a/test/gen/function_splitTest.cpp b/test/gen/function_splitTest.cpp
index 358a699..e5279f2 100644
--- a/test/gen/function_splitTest.cpp
+++ b/test/gen/function_splitTest.cpp
@@ -6,97 +6,97 @@ using namespace jsonata;
 class function_splitTest : public JsonataTest {
 };
 
-// 
+// $split(\"Hello World\", \" \")
 TEST_F(function_splitTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case000.json"));
 }
 
-// 
+// $split(\"Hello\", \" \")
 TEST_F(function_splitTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case001.json"));
 }
 
-// 
+// $split(\"Hello  World\", \" \")
 TEST_F(function_splitTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case002.json"));
 }
 
-// 
+// $split(\"Hello\", \"\")
 TEST_F(function_splitTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case003.json"));
 }
 
-// 
+// $sum($split(\"12345\", \"\").$number($))
 TEST_F(function_splitTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case004.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \")
 TEST_F(function_splitTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case005.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", 2)
 TEST_F(function_splitTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case006.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", 2.5)
 TEST_F(function_splitTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case007.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", 10)
 TEST_F(function_splitTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case008.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", 0)
 TEST_F(function_splitTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case009.json"));
 }
 
-// 
+// $split(nothing, \" \")
 TEST_F(function_splitTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case010.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", -3)
 TEST_F(function_splitTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case011.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", null)
 TEST_F(function_splitTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case012.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", -5)
 TEST_F(function_splitTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case013.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", \", \", \"2\")
 TEST_F(function_splitTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case014.json"));
 }
 
-// 
+// $split(\"a, b, c, d\", true)
 TEST_F(function_splitTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case015.json"));
 }
 
-// 
+// $split(12345, 3)
 TEST_F(function_splitTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case016.json"));
 }
 
-// 
+// $split(12345)
 TEST_F(function_splitTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case017.json"));
 }
 
-// 
+// $split('12💩345💩6', '💩')
 TEST_F(function_splitTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-split/case018.json"));
 }
diff --git a/test/gen/function_spreadTest.cpp b/test/gen/function_spreadTest.cpp
index 2b627a1..063ea98 100644
--- a/test/gen/function_spreadTest.cpp
+++ b/test/gen/function_spreadTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_spreadTest : public JsonataTest {
 };
 
-// 
+// $spread(\"Hello World\")
 TEST_F(function_spreadTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case000.json"));
 }
 
-// 
+// $spread((Account.Order.Product.Description))
 TEST_F(function_spreadTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case001.json"));
 }
 
-// 
+// $spread(blah)
 TEST_F(function_spreadTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case002.json"));
 }
 
-// 
+// $string($spread(function($x){$x*$x}))
 TEST_F(function_spreadTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-spread/case003.json"));
 }
diff --git a/test/gen/function_sqrtTest.cpp b/test/gen/function_sqrtTest.cpp
index 69e66f6..d926385 100644
--- a/test/gen/function_sqrtTest.cpp
+++ b/test/gen/function_sqrtTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class function_sqrtTest : public JsonataTest {
 };
 
-// 
+// $sqrt(4)
 TEST_F(function_sqrtTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case000.json"));
 }
 
-// 
+// $sqrt(2)
 TEST_F(function_sqrtTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case001.json"));
 }
 
-// 
+// $sqrt(nothing)
 TEST_F(function_sqrtTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case002.json"));
 }
 
-// 
+// $sqrt(-2)
 TEST_F(function_sqrtTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sqrt/case003.json"));
 }
diff --git a/test/gen/function_stringTest.cpp b/test/gen/function_stringTest.cpp
index 21a658b..5289f0f 100644
--- a/test/gen/function_stringTest.cpp
+++ b/test/gen/function_stringTest.cpp
@@ -6,152 +6,152 @@ using namespace jsonata;
 class function_stringTest : public JsonataTest {
 };
 
-// 
+// $string(5)
 TEST_F(function_stringTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case000.json"));
 }
 
-// 
+// $string(22/7)
 TEST_F(function_stringTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case001.json"));
 }
 
-// 
+// $string(1e100)
 TEST_F(function_stringTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case002.json"));
 }
 
-// 
+// $string(1e-100)
 TEST_F(function_stringTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case003.json"));
 }
 
-// 
+// $string(1e-6)
 TEST_F(function_stringTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case004.json"));
 }
 
-// 
+// $string(1e-7)
 TEST_F(function_stringTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case005.json"));
 }
 
-// 
+// $string(1e20)
 TEST_F(function_stringTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case006.json"));
 }
 
-// 
+// $string(1e21)
 TEST_F(function_stringTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case007.json"));
 }
 
-// 
+// Account.Order.$string($sum(Product.(Price* Quantity)))
 TEST_F(function_stringTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case008.json"));
 }
 
-// 
+// $string(true)
 TEST_F(function_stringTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case009.json"));
 }
 
-// 
+// $string(false)
 TEST_F(function_stringTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case010.json"));
 }
 
-// 
+// $string(null)
 TEST_F(function_stringTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case011.json"));
 }
 
-// 
+// $string(blah)
 TEST_F(function_stringTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case012.json"));
 }
 
-// 
+// $string($string)
 TEST_F(function_stringTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case013.json"));
 }
 
-// 
+// $string(function(){true})
 TEST_F(function_stringTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case014.json"));
 }
 
-// 
+// $string(function(){1})
 TEST_F(function_stringTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case015.json"));
 }
 
-// 
+// $string({\"string\": \"hello\"})
 TEST_F(function_stringTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case016.json"));
 }
 
-// 
+// $string([\"string\", 5])
 TEST_F(function_stringTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case017.json"));
 }
 
-// 
+// $string({  \"string\": \"hello\",  \"number\": 78.8 / 2,  \"null\":null,  \"boolean\": false,  \"function\": $sum,  \"lambda\": function(){true},  \"object\": {    \"str\": \"another\",    \"lambda2\": function($n){$n}  },  \"array\": []})
 TEST_F(function_stringTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case018.json"));
 }
 
-// 
+// $string(1/0)
 TEST_F(function_stringTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case019.json"));
 }
 
-// 
+// $string({\"inf\": 1/0})
 TEST_F(function_stringTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case020.json"));
 }
 
-// 
+// $string(2,3)
 TEST_F(function_stringTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case021.json"));
 }
 
-// 
+// $string()
 TEST_F(function_stringTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case022.json"));
 }
 
-// 
+// $string({\"string\": \"hello\"}, false)
 TEST_F(function_stringTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case023.json"));
 }
 
-// 
+// $string({\"string\": \"hello\"}, true)
 TEST_F(function_stringTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case024.json"));
 }
 
-// 
+// $string([\"string\", 5], false)
 TEST_F(function_stringTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case025.json"));
 }
 
-// 
+// $string([\"string\", 5], true)
 TEST_F(function_stringTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case026.json"));
 }
 
-// 
+// $string({  \"string\": \"hello\",  \"number\": 78.8 / 2,  \"null\":null,  \"boolean\": false,  \"function\": $sum,  \"lambda\": function(){true},  \"object\": {    \"str\": \"another\",    \"lambda2\": function($n){$n}  },  \"array\": []}, false)
 TEST_F(function_stringTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case027.json"));
 }
 
-// 
+// $string({  \"string\": \"hello\",  \"number\": 78.8 / 2,  \"null\":null,  \"boolean\": false,  \"function\": $sum,  \"lambda\": function(){true},  \"object\": {    \"str\": \"another\",    \"lambda2\": function($n){$n}  },  \"array\": []}, true)
 TEST_F(function_stringTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case028.json"));
 }
 
-// 
+// $string()
 TEST_F(function_stringTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-string/case029.json"));
 }
diff --git a/test/gen/function_substringAfterTest.cpp b/test/gen/function_substringAfterTest.cpp
index 7944dc0..31d9c20 100644
--- a/test/gen/function_substringAfterTest.cpp
+++ b/test/gen/function_substringAfterTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_substringAfterTest : public JsonataTest {
 };
 
-// 
+// $substringAfter(\"Hello World\", \" \")
 TEST_F(function_substringAfterTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case000.json"));
 }
 
-// 
+// $substringAfter(\"Hello World\", \"l\")
 TEST_F(function_substringAfterTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case001.json"));
 }
 
-// 
+// $substringAfter(\"Hello World\", \"f\")
 TEST_F(function_substringAfterTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case002.json"));
 }
 
-// 
+// $substringAfter(\"Hello World\", \"ld\")
 TEST_F(function_substringAfterTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case003.json"));
 }
 
-// 
+// $substringAfter(blah, \"ld\")
 TEST_F(function_substringAfterTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringAfter/case004.json"));
 }
diff --git a/test/gen/function_substringBeforeTest.cpp b/test/gen/function_substringBeforeTest.cpp
index e4034be..9074e5d 100644
--- a/test/gen/function_substringBeforeTest.cpp
+++ b/test/gen/function_substringBeforeTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class function_substringBeforeTest : public JsonataTest {
 };
 
-// 
+// $substringBefore(\"Hello World\", \" \")
 TEST_F(function_substringBeforeTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case000.json"));
 }
 
-// 
+// $substringBefore(\"Hello World\", \"l\")
 TEST_F(function_substringBeforeTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case001.json"));
 }
 
-// 
+// $substringBefore(\"Hello World\", \"f\")
 TEST_F(function_substringBeforeTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case002.json"));
 }
 
-// 
+// $substringBefore(\"Hello World\", \"He\")
 TEST_F(function_substringBeforeTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case003.json"));
 }
 
-// 
+// $substringBefore(blah, \"He\")
 TEST_F(function_substringBeforeTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substringBefore/case004.json"));
 }
diff --git a/test/gen/function_substringTest.cpp b/test/gen/function_substringTest.cpp
index 7746f7f..1b090d8 100644
--- a/test/gen/function_substringTest.cpp
+++ b/test/gen/function_substringTest.cpp
@@ -6,97 +6,97 @@ using namespace jsonata;
 class function_substringTest : public JsonataTest {
 };
 
-// 
+// $substring(\"hello world\", 0, 5)
 TEST_F(function_substringTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case000.json"));
 }
 
-// 
+// $substring(\"hello world\", -5, 5)
 TEST_F(function_substringTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case001.json"));
 }
 
-// 
+// $substring(\"hello world\", 6)
 TEST_F(function_substringTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case002.json"));
 }
 
-// 
+// $substring(blah, 6)
 TEST_F(function_substringTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case003.json"));
 }
 
-// 
+// $substring('𝄞💩', 0, 2)
 TEST_F(function_substringTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case004.json"));
 }
 
-// 
+// $substring('𝄞💩', 0, 1)
 TEST_F(function_substringTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case005.json"));
 }
 
-// 
+// $substring('𝄞💩', 1, 1)
 TEST_F(function_substringTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case006.json"));
 }
 
-// 
+// $substring(\"hello world\", -5)
 TEST_F(function_substringTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case007.json"));
 }
 
-// 
+// $substring(\"hello world\", -5, 5)
 TEST_F(function_substringTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case008.json"));
 }
 
-// 
+// $substring(\"hello world\", -5, 4)
 TEST_F(function_substringTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case009.json"));
 }
 
-// 
+// $substring(\"hello world\", -5, 1)
 TEST_F(function_substringTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case010.json"));
 }
 
-// 
+// $substring(\"hello world\", -5, 0)
 TEST_F(function_substringTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case011.json"));
 }
 
-// 
+// $substring(\"hello world\", -5, -1)
 TEST_F(function_substringTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case012.json"));
 }
 
-// 
+// $substring(\"hello world\", 0, -6)
 TEST_F(function_substringTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case013.json"));
 }
 
-// 
+// $substring(\"hello world\", -100, 3)
 TEST_F(function_substringTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case014.json"));
 }
 
-// 
+// $substring(\"😂😁😀\", -2, 1)
 TEST_F(function_substringTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case015.json"));
 }
 
-// 
+// $substring(\"😂😁😀\", -3, 1)
 TEST_F(function_substringTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case016.json"));
 }
 
-// 
+// $substring(\"😂😁😀\", -4, 1)
 TEST_F(function_substringTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case017.json"));
 }
 
-// 
+// $substring(\"😂😁😀\", -5, 1)
 TEST_F(function_substringTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-substring/case018.json"));
 }
diff --git a/test/gen/function_sumTest.cpp b/test/gen/function_sumTest.cpp
index 7ebcd38..16ff875 100644
--- a/test/gen/function_sumTest.cpp
+++ b/test/gen/function_sumTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class function_sumTest : public JsonataTest {
 };
 
-// 
+// $sum(Account.Order.Product.(Price * Quantity))
 TEST_F(function_sumTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case000.json"));
 }
 
-// 
+// Account.Order.$sum(Product.(Price * Quantity))
 TEST_F(function_sumTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case001.json"));
 }
 
-// 
+// Account.Order.(OrderID & \": \" & $sum(Product.(Price*Quantity)))
 TEST_F(function_sumTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case002.json"));
 }
 
-// 
+// $sum()
 TEST_F(function_sumTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case003.json"));
 }
 
-// 
+// $sum(1)
 TEST_F(function_sumTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case004.json"));
 }
 
-// 
+// $sum(Account.Order)
 TEST_F(function_sumTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case005.json"));
 }
 
-// 
+// $sum(undefined)
 TEST_F(function_sumTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-sum/case006.json"));
 }
diff --git a/test/gen/function_tomillisTest.cpp b/test/gen/function_tomillisTest.cpp
index d7276ec..bade2d7 100644
--- a/test/gen/function_tomillisTest.cpp
+++ b/test/gen/function_tomillisTest.cpp
@@ -6,73 +6,298 @@ using namespace jsonata;
 class function_tomillisTest : public JsonataTest {
 };
 
-// 
+// $toMillis(\"1970-01-01T00:00:00.001Z\")
 TEST_F(function_tomillisTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case001.json"));
 }
 
-// 
+// $toMillis(\"2018-02-01T09:42:13.123+0000\")
 TEST_F(function_tomillisTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case002.json"));
 }
 
-// 
+// $toMillis(\"2017-10-30\")
 TEST_F(function_tomillisTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case003.json"));
 }
 
-// 
+// $toMillis(\"2017-10-30T15:28:34Z\")
 TEST_F(function_tomillisTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case004.json"));
 }
 
-// 
+// $toMillis(\"2018\")
 TEST_F(function_tomillisTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case005.json"));
 }
 
-// 
+// $toMillis(foo)
 TEST_F(function_tomillisTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case006.json"));
 }
 
-// 
+// $toMillis(\"foo\")
 TEST_F(function_tomillisTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case007.json"));
 }
 
-// 
+// $toMillis(\"01-02-2018\")
 TEST_F(function_tomillisTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case008.json"));
 }
 
-// 
+// $toMillis(\"2018-02-03 11:15:33\")
 TEST_F(function_tomillisTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case009.json"));
 }
 
-// 
+// $toMillis(\"201802\", \"[Y0001][M01]\")
 TEST_F(function_tomillisTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case010.json"));
 }
 
-// 
+// $toMillis(\"201802\", \"[Y,*-4][M01]\")
 TEST_F(function_tomillisTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case011.json"));
 }
 
-// 
+// $toMillis(\"20180205\", \"[Y0001][M01][D01]\")
 TEST_F(function_tomillisTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case012.json"));
 }
 
-// 
+// $toMillis('2024-01-01T12:38:49Z') = $toMillis('20240101123849', '[Y0000][M00][D00][H00][m00][s00]')
 TEST_F(function_tomillisTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/case013.json"));
 }
 
-// 
-TEST_F(function_tomillisTest, parseDateTime) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json"));
+// $toMillis(undefined, 'pic')
+TEST_F(function_tomillisTest, parseDateTime_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 0));
+}
+
+// $toMillis('Hello', 'Hello')
+TEST_F(function_tomillisTest, parseDateTime_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 1));
+}
+
+// $toMillis('2018', '[Y1]')
+TEST_F(function_tomillisTest, parseDateTime_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 2));
+}
+
+// $toMillis('2018-03-27', '[Y1]-[M01]-[D01]')
+TEST_F(function_tomillisTest, parseDateTime_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 3));
+}
+
+// $toMillis('2018-03-27T14:03:00.123Z', '[Y0001]-[M01]-[D01]T[H01]:[m01]:[s01].[f001]Z')
+TEST_F(function_tomillisTest, parseDateTime_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 4));
+}
+
+// $toMillis('27th 3 1976', '[D1o] [M#1] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 5));
+}
+
+// $toMillis('21st 12 1881', '[D1o] [M01] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 6));
+}
+
+// $toMillis('2nd 12 2012', '[D1o] [M01] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 7));
+}
+
+// $toMillis('MCMLXXXIV', '[YI]')
+TEST_F(function_tomillisTest, parseDateTime_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 8));
+}
+
+// $toMillis('27 03 MMXVIII', '[D1] [M01] [YI]')
+TEST_F(function_tomillisTest, parseDateTime_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 9));
+}
+
+// $toMillis('27 iii MMXVIII', '[D1] [Mi] [YI]')
+TEST_F(function_tomillisTest, parseDateTime_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 10));
+}
+
+// $toMillis('w C mmxviii', '[Da] [MA] [Yi]')
+TEST_F(function_tomillisTest, parseDateTime_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 11));
+}
+
+// $toMillis('ae C mmxviii', '[Da] [MA] [Yi]')
+TEST_F(function_tomillisTest, parseDateTime_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 12));
+}
+
+// $toMillis('27th April 2008', '[D1o] [MNn] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 13));
+}
+
+// $toMillis('21 August 2017', '[D1] [MNn] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 14));
+}
+
+// $toMillis('2 Feb 2012', '[D1] [MNn,3-3] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 15));
+}
+
+// $toMillis('one thousand, nine hundred and eighty-four', '[Yw]')
+TEST_F(function_tomillisTest, parseDateTime_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 16));
+}
+
+// $toMillis('nineteen hundred and eighty-four', '[Yw]')
+TEST_F(function_tomillisTest, parseDateTime_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 17));
+}
+
+// $toMillis('twenty-seven April 2008', '[Dw] [MNn] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 18));
+}
+
+// $toMillis('twenty-seventh April 2008', '[Dw] [MNn] [Y0001]')
+TEST_F(function_tomillisTest, parseDateTime_case_19) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 19));
+}
+
+// $toMillis('twenty-first August two thousand and seventeen', '[Dw] [MNn] [Yw]')
+TEST_F(function_tomillisTest, parseDateTime_case_20) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 20));
+}
+
+// $toMillis('TWENTY-SECOND August two thousand and seventeen', '[DW] [MNn] [Yw]')
+TEST_F(function_tomillisTest, parseDateTime_case_21) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 21));
+}
+
+// $toMillis('Twentieth of August, two thousand and seventeen', '[DW] of [MNn], [Yw]')
+TEST_F(function_tomillisTest, parseDateTime_case_22) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 22));
+}
+
+// $toMillis('4/4/2018 12:06 am', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
+TEST_F(function_tomillisTest, parseDateTime_case_23) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 23));
+}
+
+// $toMillis('4/4/2018 06:30 am', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
+TEST_F(function_tomillisTest, parseDateTime_case_24) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 24));
+}
+
+// $toMillis('4/4/2018 12:06 pm', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
+TEST_F(function_tomillisTest, parseDateTime_case_25) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 25));
+}
+
+// $toMillis('4/4/2018 11:30 pm', '[D1]/[M1]/[Y0001] [h]:[m] [P]')
+TEST_F(function_tomillisTest, parseDateTime_case_26) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 26));
+}
+
+// $toMillis('2018-094', '[Y0001]-[d001]')
+TEST_F(function_tomillisTest, parseDateTime_case_27) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 27));
+}
+
+// $toMillis('13:45', '[H]:[m]') ~> $fromMillis() ~> $substringBefore('T') = $substringBefore($now(), 'T')
+TEST_F(function_tomillisTest, parseDateTime_case_28) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 28));
+}
+
+// $toMillis('13:45', '[H]:[m]') ~> $fromMillis() ~> $substringAfter('T')
+TEST_F(function_tomillisTest, parseDateTime_case_29) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 29));
+}
+
+// $toMillis('Wednesday, 14th November 2018', '[FNn], [D1o] [MNn] [Y]') ~> $fromMillis()
+TEST_F(function_tomillisTest, parseDateTime_case_30) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 30));
+}
+
+// $toMillis('Mon, Twelfth November 2018', '[FNn,*-3], [DWwo] [MNn] [Y]') ~> $fromMillis()
+TEST_F(function_tomillisTest, parseDateTime_case_31) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 31));
+}
+
+// $toMillis('2018--180', '[Y]--[d]') ~> $fromMillis()
+TEST_F(function_tomillisTest, parseDateTime_case_32) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 32));
+}
+
+// $toMillis('three hundred and sixty-fifth day of 2018', '[dwo] day of [Y]') ~> $fromMillis()
+TEST_F(function_tomillisTest, parseDateTime_case_33) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 33));
+}
+
+// $toMillis('irrelevent string', '[Y]-[M]-[D]')
+TEST_F(function_tomillisTest, parseDateTime_case_34) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 34));
+}
+
+// $toMillis('2018-05-22', '[Y]-[M]-[q]')
+TEST_F(function_tomillisTest, parseDateTime_case_35) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 35));
+}
+
+// $toMillis('2018-05-22', '[YN]-[M]-[D]')
+TEST_F(function_tomillisTest, parseDateTime_case_36) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 36));
+}
+
+// $toMillis('2018-22', '[Y]-[D]')
+TEST_F(function_tomillisTest, parseDateTime_case_37) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 37));
+}
+
+// $toMillis('5-22 23:59', '[M]-[D] [m]:[s]')
+TEST_F(function_tomillisTest, parseDateTime_case_38) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 38));
+}
+
+// $toMillis('2018-3-2-5', '[X]-[x]-[w]-[F1]')
+TEST_F(function_tomillisTest, parseDateTime_case_39) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 39));
+}
+
+// $toMillis('2018-32-5', '[X]-[W]-[F1]')
+TEST_F(function_tomillisTest, parseDateTime_case_40) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 40));
+}
+
+// $toMillis('2020-09-09 08:00:00 +02:00', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [Z]') ~> $fromMillis() 
+TEST_F(function_tomillisTest, parseDateTime_case_41) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 41));
+}
+
+// $toMillis('2020-09-09 08:00:00 GMT-05:00', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [z]') ~> $fromMillis() 
+TEST_F(function_tomillisTest, parseDateTime_case_42) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 42));
+}
+
+// $toMillis('2020-09-09 12:00:00 +05:30', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [Z]') ~> $fromMillis() 
+TEST_F(function_tomillisTest, parseDateTime_case_43) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 43));
+}
+
+// $toMillis('2020-09-09 12:00:00 GMT-5', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [z01]') ~> $fromMillis() 
+TEST_F(function_tomillisTest, parseDateTime_case_44) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 44));
+}
+
+// $toMillis('2020-09-09 12:00:00 +0530', '[Y0001]-[M01]-[D01] [H01]:[m01]:[s01] [Z0001]') ~> $fromMillis() 
+TEST_F(function_tomillisTest, parseDateTime_case_45) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/function-tomillis/parseDateTime.json", 45));
 }
 
diff --git a/test/gen/function_trimTest.cpp b/test/gen/function_trimTest.cpp
index fe155a3..5f395c1 100644
--- a/test/gen/function_trimTest.cpp
+++ b/test/gen/function_trimTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class function_trimTest : public JsonataTest {
 };
 
-// 
+// $trim(\"Hello World\")
 TEST_F(function_trimTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-trim/case000.json"));
 }
 
-// 
+// $trim(\"   Hello     \t World  \t \")
 TEST_F(function_trimTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-trim/case001.json"));
 }
 
-// 
+// $trim()
 TEST_F(function_trimTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-trim/case002.json"));
 }
diff --git a/test/gen/function_typeOfTest.cpp b/test/gen/function_typeOfTest.cpp
index 948be23..7eb6e2e 100644
--- a/test/gen/function_typeOfTest.cpp
+++ b/test/gen/function_typeOfTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class function_typeOfTest : public JsonataTest {
 };
 
-// 
+// ($var:= undefined; $type($var))
 TEST_F(function_typeOfTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case001.json"));
 }
 
-// 
+// ($var:= null; $type($var))
 TEST_F(function_typeOfTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case002.json"));
 }
 
-// 
+// ($var:= 123; $type($var))
 TEST_F(function_typeOfTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case003.json"));
 }
 
-// 
+// ($var:= '123'; $type($var))
 TEST_F(function_typeOfTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case004.json"));
 }
 
-// 
+// ($var:= true; $type($var))
 TEST_F(function_typeOfTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case005.json"));
 }
 
-// 
+// ($var:= 'true'; $type($var))
 TEST_F(function_typeOfTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case006.json"));
 }
 
-// 
+// ($var:= []; $type($var))
 TEST_F(function_typeOfTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case007.json"));
 }
 
-// 
+// ($var:= ['a']; $type($var))
 TEST_F(function_typeOfTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case008.json"));
 }
 
-// 
+// ($var:= ['a','b']; $type($var))
 TEST_F(function_typeOfTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case009.json"));
 }
 
-// 
+// ($var:= function(){true}; $type($var))
 TEST_F(function_typeOfTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case010.json"));
 }
 
-// 
+// ($var:= (λ($v, $i, $a) {$v.price = $max($a.price)}); $type($var))
 TEST_F(function_typeOfTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case011.json"));
 }
 
-// 
+// ($var:= {}; $type($var))
 TEST_F(function_typeOfTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case012.json"));
 }
 
-// 
+// ($var:= {\"foo\":\"bar\"}; $type($var))
 TEST_F(function_typeOfTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-typeOf/case013.json"));
 }
diff --git a/test/gen/function_uppercaseTest.cpp b/test/gen/function_uppercaseTest.cpp
index 51a8d2c..32887c9 100644
--- a/test/gen/function_uppercaseTest.cpp
+++ b/test/gen/function_uppercaseTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class function_uppercaseTest : public JsonataTest {
 };
 
-// 
+// $uppercase(\"Hello World\")
 TEST_F(function_uppercaseTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-uppercase/case000.json"));
 }
 
-// 
+// $uppercase(blah)
 TEST_F(function_uppercaseTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-uppercase/case001.json"));
 }
diff --git a/test/gen/function_zipTest.cpp b/test/gen/function_zipTest.cpp
index 519e76a..2ed15c4 100644
--- a/test/gen/function_zipTest.cpp
+++ b/test/gen/function_zipTest.cpp
@@ -6,32 +6,32 @@ using namespace jsonata;
 class function_zipTest : public JsonataTest {
 };
 
-// 
+// $zip([1,2,3],[4,5,6])
 TEST_F(function_zipTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case000.json"));
 }
 
-// 
+// $zip([1,2,3],[4,5,6],[7,8,9])
 TEST_F(function_zipTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case001.json"));
 }
 
-// 
+// $zip([1,2,3],[4,5],[7,8,9])
 TEST_F(function_zipTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case002.json"));
 }
 
-// 
+// $zip([1,2,3])
 TEST_F(function_zipTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case003.json"));
 }
 
-// 
+// $zip(1,2,3)
 TEST_F(function_zipTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case004.json"));
 }
 
-// 
+// $zip([1,2,3], [4,5,6], nothing)
 TEST_F(function_zipTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/function-zip/case005.json"));
 }
diff --git a/test/gen/higher_order_functionsTest.cpp b/test/gen/higher_order_functionsTest.cpp
index 0457a2c..bad559e 100644
--- a/test/gen/higher_order_functionsTest.cpp
+++ b/test/gen/higher_order_functionsTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class higher_order_functionsTest : public JsonataTest {
 };
 
-// 
+// ($twice:=function($f){function($x){$f($f($x))}}; $add3:=function($y){$y+3}; $add6:=$twice($add3); $add6(7))
 TEST_F(higher_order_functionsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/higher-order-functions/case000.json"));
 }
 
-// 
+// λ($f) { λ($x) { $x($x) }( λ($g) { $f( (λ($a) {$g($g)($a)}))})}(λ($f) { λ($n) { $n < 2 ? 1 : $n * $f($n - 1) } })(6)
 TEST_F(higher_order_functionsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/higher-order-functions/case001.json"));
 }
 
-// 
+// λ($f) { λ($x) { $x($x) }( λ($g) { $f( (λ($a) {$g($g)($a)}))})}(λ($f) { λ($n) { $n <= 1 ? $n : $f($n-1) + $f($n-2) } })(6) 
 TEST_F(higher_order_functionsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/higher-order-functions/case002.json"));
 }
diff --git a/test/gen/hof_filterTest.cpp b/test/gen/hof_filterTest.cpp
index cad9e43..7b213f8 100644
--- a/test/gen/hof_filterTest.cpp
+++ b/test/gen/hof_filterTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class hof_filterTest : public JsonataTest {
 };
 
-// 
+// (library.books~>$filter(λ($v, $i, $a) {$v.price = $max($a.price)})).isbn
 TEST_F(hof_filterTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case000.json"));
 }
 
-// 
+// nothing~>$filter(λ($v, $i, $a) {$v.price = $max($a.price)})
 TEST_F(hof_filterTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case001.json"));
 }
 
-// 
+// $filter(data, function($d) { true })
 TEST_F(hof_filterTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case002.json"));
 }
 
-// 
+// $filter([0, 1, 2], $boolean)
 TEST_F(hof_filterTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-filter/case003.json"));
 }
diff --git a/test/gen/hof_mapTest.cpp b/test/gen/hof_mapTest.cpp
index 28ae115..51c1741 100644
--- a/test/gen/hof_mapTest.cpp
+++ b/test/gen/hof_mapTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class hof_mapTest : public JsonataTest {
 };
 
-// 
+// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $add := function($x){$x*$x};  $map($data.one, $add) )  
 TEST_F(hof_mapTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case000.json"));
 }
 
-// 
+// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $add := function($x){$x*$x};  $map($add) )  
 TEST_F(hof_mapTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case001.json"));
 }
 
-// 
+// ( $square := function($x){$x*$x}; $map([1], $square)[] )
 TEST_F(hof_mapTest, case0010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case0010.json"));
 }
 
-// 
+// ( $data := [1]; $square := function($x){$x*$x}; $data ~> $map($square)[] )
 TEST_F(hof_mapTest, case0011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case0011.json"));
 }
 
-// 
+// $map([1,2,3], $string)
 TEST_F(hof_mapTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case002.json"));
 }
 
-// 
+// Account.Order.Product ~> $map(λ($prod, $index) { $index+1 & \": \" & $prod.\"Product Name\" })
 TEST_F(hof_mapTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case003.json"));
 }
 
-// 
+// Account.Order.Product ~> $map(λ($prod, $index, $arr) { $index+1 & \"/\" & $count($arr) & \": \" & $prod.\"Product Name\" })
 TEST_F(hof_mapTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case004.json"));
 }
 
-// 
+// $map(Phone, function($v, $i) {$i[$v.type=\"office\"]})
 TEST_F(hof_mapTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case005.json"));
 }
 
-// 
+// $map(Phone, function($v, $i) {$v.type=\"office\" ? $i})
 TEST_F(hof_mapTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case006.json"));
 }
 
-// 
+// $map(Phone, function($v, $i) {$v.type=\"office\" ? $i: null})
 TEST_F(hof_mapTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case007.json"));
 }
 
-// 
+// $map(Phone, function($v, $i) {$v.type=\"office\" ? $i: null})
 TEST_F(hof_mapTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case008.json"));
 }
 
-// 
+// $map([0, 1, 2], $boolean)
 TEST_F(hof_mapTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-map/case009.json"));
 }
diff --git a/test/gen/hof_reduceTest.cpp b/test/gen/hof_reduceTest.cpp
index 1e0d87b..7007898 100644
--- a/test/gen/hof_reduceTest.cpp
+++ b/test/gen/hof_reduceTest.cpp
@@ -6,47 +6,47 @@ using namespace jsonata;
 class hof_reduceTest : public JsonataTest {
 };
 
-// 
+// (  $seq := [1,2,3,4,5];  $reduce($seq, function($x, $y){$x+$y})) 
 TEST_F(hof_reduceTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case000.json"));
 }
 
-// 
+// (  $concat := function($s){function($a, $b){$string($a) & $s & $string($b)}};  $comma_join := $concat(' ... ');  $reduce([1,2,3,4,5], $comma_join))      
 TEST_F(hof_reduceTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case001.json"));
 }
 
-// 
+// (  $seq := [1,2,3,4,5];  $reduce($seq, function($x, $y){$x+$y}, 2))
 TEST_F(hof_reduceTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case002.json"));
 }
 
-// 
+// (  $seq := 1;  $reduce($seq, function($x, $y){$x+$y}))
 TEST_F(hof_reduceTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case003.json"));
 }
 
-// 
+// (  $seq := 1;  $reduce($seq, function($x, $y){$x+$y}))
 TEST_F(hof_reduceTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case004.json"));
 }
 
-// 
+// $reduce(Account.Order.Product.Quantity, $append)
 TEST_F(hof_reduceTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case005.json"));
 }
 
-// 
+// $reduce(Account.Order.Product.Quantity, $append)
 TEST_F(hof_reduceTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case006.json"));
 }
 
-// 
+// ($product := function($a, $b) { $a * $b };$power := function($x, $n) { $n = 0 ? 1 : $reduce([1..$n].($x), $product) };[0..5].$power(2, $))
 TEST_F(hof_reduceTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case007.json"));
 }
 
-// 
+// (  $seq := 1;  $reduce($seq, function($x){$x}))
 TEST_F(hof_reduceTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-reduce/case008.json"));
 }
diff --git a/test/gen/hof_singleTest.cpp b/test/gen/hof_singleTest.cpp
index d7802ba..3c916d3 100644
--- a/test/gen/hof_singleTest.cpp
+++ b/test/gen/hof_singleTest.cpp
@@ -6,57 +6,57 @@ using namespace jsonata;
 class hof_singleTest : public JsonataTest {
 };
 
-// 
+// (library.books~>$single(λ($v, $i, $a) {$v.price = $max($a.price)})).isbn
 TEST_F(hof_singleTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case000.json"));
 }
 
-// 
+// nothing~>$single(λ($v, $i, $a) {$v.price = $max($a.price)})
 TEST_F(hof_singleTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case001.json"));
 }
 
-// 
+// $single(data, function($d) { true })
 TEST_F(hof_singleTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case002.json"));
 }
 
-// 
+// $single([0, 1, 2], $boolean)
 TEST_F(hof_singleTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case003.json"));
 }
 
-// 
+// $single([0, 1, 2], function($v) {$v = 3})
 TEST_F(hof_singleTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case004.json"));
 }
 
-// 
+// $single([0, 1, 2])
 TEST_F(hof_singleTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case005.json"));
 }
 
-// 
+// $single([0])
 TEST_F(hof_singleTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case006.json"));
 }
 
-// 
+// $single([])
 TEST_F(hof_singleTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case007.json"));
 }
 
-// 
+// $single([true, false, true], function($v) {$v=false})
 TEST_F(hof_singleTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case008.json"));
 }
 
-// 
+// $single(['zero', 'one', 'two'], function($v, $i, $k) {$i=1})
 TEST_F(hof_singleTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case009.json"));
 }
 
-// 
+// Phone ~> $filter(function($p) {$p.type = 'home'}) ~> $single(function($p) {$p.number = '0203 544 1234'})
 TEST_F(hof_singleTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-single/case010.json"));
 }
diff --git a/test/gen/hof_zip_mapTest.cpp b/test/gen/hof_zip_mapTest.cpp
index a6e7ac2..bc9eb75 100644
--- a/test/gen/hof_zip_mapTest.cpp
+++ b/test/gen/hof_zip_mapTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class hof_zip_mapTest : public JsonataTest {
 };
 
-// 
+// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $map($zip($data.one, $data.two), $sum)) 
 TEST_F(hof_zip_mapTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case000.json"));
 }
 
-// 
+// (  $data := {    \"one\": [1,2,3,4,5],    \"two\": [5,4,3,2,1]  };  $data.$zip(one, two) ~> $map($sum)) 
 TEST_F(hof_zip_mapTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case001.json"));
 }
 
-// 
+// (  $data := {    \"one\": [1],    \"two\": [5]  };  $data.$zip(one, two) ~> $map($sum)) 
 TEST_F(hof_zip_mapTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case002.json"));
 }
 
-// 
+// (  $data := {    \"one\": 1,    \"two\": 5  };  $data.$zip(one, two) ~> $map($sum)) 
 TEST_F(hof_zip_mapTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/hof-zip-map/case003.json"));
 }
diff --git a/test/gen/inclusion_operatorTest.cpp b/test/gen/inclusion_operatorTest.cpp
index 0a61049..13f9bbe 100644
--- a/test/gen/inclusion_operatorTest.cpp
+++ b/test/gen/inclusion_operatorTest.cpp
@@ -6,47 +6,47 @@ using namespace jsonata;
 class inclusion_operatorTest : public JsonataTest {
 };
 
-// 
+// 1 in [1,2]
 TEST_F(inclusion_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case000.json"));
 }
 
-// 
+// 3 in [1,2]
 TEST_F(inclusion_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case001.json"));
 }
 
-// 
+// \"hello\" in [1,2]
 TEST_F(inclusion_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case002.json"));
 }
 
-// 
+// \"world\" in [\"hello\", \"world\"]
 TEST_F(inclusion_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case003.json"));
 }
 
-// 
+// in in [\"hello\", \"world\"]
 TEST_F(inclusion_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case004.json"));
 }
 
-// 
+// \"world\" in in
 TEST_F(inclusion_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case005.json"));
 }
 
-// 
+// \"hello\" in \"hello\"
 TEST_F(inclusion_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case006.json"));
 }
 
-// 
+// library.books[\"Aho\" in authors].title
 TEST_F(inclusion_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case007.json"));
 }
 
-// 
+// content.integration.$lowercase(name)
 TEST_F(inclusion_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/inclusion-operator/case008.json"));
 }
diff --git a/test/gen/joinsTest.cpp b/test/gen/joinsTest.cpp
index 50a673d..9200f71 100644
--- a/test/gen/joinsTest.cpp
+++ b/test/gen/joinsTest.cpp
@@ -6,23 +6,218 @@ using namespace jsonata;
 class joinsTest : public JsonataTest {
 };
 
+// Employee@$e.(Contact)[ssn = $e.SSN].{ 'name': $e.(FirstName & ' ' & Surname), 'phone': Phone[type='mobile'].number }
+TEST_F(joinsTest, employee_map_reduce_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 0));
+}
+
+// Employee@$e.(Contact)[ssn = $e.SSN]{ $e.FirstName: Phone[type='mobile'].number }
+TEST_F(joinsTest, employee_map_reduce_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 1));
+}
+
+// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $join($c.Phone.number, ', ') }
+TEST_F(joinsTest, employee_map_reduce_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 2));
+}
+
+// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $c.Phone[type != 'home'].number ~> $join(', ') }
+TEST_F(joinsTest, employee_map_reduce_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 3));
+}
+
+// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $c.Phone[type != 'home'].number }
+TEST_F(joinsTest, employee_map_reduce_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 4));
+}
+
+// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.(FirstName & ' ' & Surname): $c.Phone[type != 'home'].number[] }
+TEST_F(joinsTest, employee_map_reduce_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 5));
+}
+
+// Employee@$e.Contact@$c[$c.ssn = $e.SSN]{ $e.FirstName: $c.Phone.number }
+TEST_F(joinsTest, employee_map_reduce_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 6));
+}
+
+// Employee@$e^($e.Surname).Contact@$c[$e.SSN=$c.ssn].{ 'name': $e.Surname, 'phone': $c.Phone.number }
+TEST_F(joinsTest, employee_map_reduce_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 7));
+}
+
+// Employee@$e^($e.FirstName).Contact@$c[$e.SSN=$c.ssn].{ 'name': $e.Surname, 'phone': $c.Phone.number }
+TEST_F(joinsTest, employee_map_reduce_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 8));
+}
+
+// Employee@$e.Contact@$c[$e.SSN=$c.ssn]{ $e.Surname: $c.Phone.number^($) }
+TEST_F(joinsTest, employee_map_reduce_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 9));
+}
+
+// Employee@$e.Contact@$c[$e.SSN=$c.ssn]{ $e.Surname: $c.Phone.number^(>$) }
+TEST_F(joinsTest, employee_map_reduce_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 10));
+}
+
+// $@$i
+TEST_F(joinsTest, employee_map_reduce_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json", 11));
+}
+
+// Account.Order@o.Product
+TEST_F(joinsTest, errors_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 0));
+}
+
+// Account.Order@$o#i.Product
+TEST_F(joinsTest, errors_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 1));
+}
+
+// Account.Order[1]@$o.Product
+TEST_F(joinsTest, errors_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 2));
+}
+
+// Account.Order^(>OrderID)@$o.Product.{ 'name':`Product Name`, 'orderid':$o.OrderID }
+TEST_F(joinsTest, errors_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/errors.json", 3));
+}
+
+// $#$pos[$pos<3]
+TEST_F(joinsTest, index_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 0));
+}
+
+// $#$pos[$pos<3] = $[[0..2]]
+TEST_F(joinsTest, index_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 1));
+}
+
+// $.$#$pos[$pos<3]
+TEST_F(joinsTest, index_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 2));
+}
+
+// $.$#$pos[$pos<3] = $.$[[0..2]]
+TEST_F(joinsTest, index_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 3));
+}
+
+// $#$pos[$pos<3]^($)
+TEST_F(joinsTest, index_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 4));
+}
+
+// $#$pos[$pos<3]^(>$)
+TEST_F(joinsTest, index_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 5));
+}
+
+// $^($)#$pos[$pos<3] 
+TEST_F(joinsTest, index_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 6));
+}
+
+// $#$pos[$pos<3][1]
+TEST_F(joinsTest, index_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 7));
+}
+
+// $#$pos[$pos<3][1][]
+TEST_F(joinsTest, index_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 8));
+}
+
+// $#$pos[$pos<3]^($)[-1]
+TEST_F(joinsTest, index_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 9));
+}
+
+// $#$pos[][$pos<3]^($)[-1]
+TEST_F(joinsTest, index_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 10));
+}
+
+// $#$pos[$pos<3]^($)[-1][]
+TEST_F(joinsTest, index_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 11));
+}
+
+// $[[1..4]]#$pos[$pos>=2]
+TEST_F(joinsTest, index_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 12));
+}
+
+// Account.Order#$o.Product[ProductID=858383].{ 'Product': `Product Name`, 'Order Index': $o }
+TEST_F(joinsTest, index_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 13));
+}
+
+// Account.Order#$i.Missing
+TEST_F(joinsTest, index_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 14));
+}
+
+// Account.Order#$i.Product{ $string(ProductID): $i }
+TEST_F(joinsTest, index_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/index.json", 15));
+}
+
+// 
+TEST_F(joinsTest, library_joins_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 0));
+}
+
+// 
+TEST_F(joinsTest, library_joins_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 1));
+}
+
+// library.books#$pos.$[$substring(title,0,3) = 'The'].$pos
+TEST_F(joinsTest, library_joins_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 2));
+}
+
+// 
+TEST_F(joinsTest, library_joins_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 3));
+}
+
+// 
+TEST_F(joinsTest, library_joins_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 4));
+}
+
+// 
+TEST_F(joinsTest, library_joins_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 5));
+}
+
+// 
+TEST_F(joinsTest, library_joins_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 6));
+}
+
 // 
-TEST_F(joinsTest, employee_map_reduce) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/employee-map-reduce.json"));
+TEST_F(joinsTest, library_joins_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 7));
 }
 
 // 
-TEST_F(joinsTest, errors) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/errors.json"));
+TEST_F(joinsTest, library_joins_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 8));
 }
 
 // 
-TEST_F(joinsTest, index) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/index.json"));
+TEST_F(joinsTest, library_joins_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 9));
 }
 
 // 
-TEST_F(joinsTest, library_joins) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/joins/library-joins.json"));
+TEST_F(joinsTest, library_joins_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/joins/library-joins.json", 10));
 }
 
diff --git a/test/gen/lambdasTest.cpp b/test/gen/lambdasTest.cpp
index 8c680eb..50a9a44 100644
--- a/test/gen/lambdasTest.cpp
+++ b/test/gen/lambdasTest.cpp
@@ -6,72 +6,72 @@ using namespace jsonata;
 class lambdasTest : public JsonataTest {
 };
 
-// 
+// function($x){$x*$x}(5)
 TEST_F(lambdasTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case000.json"));
 }
 
-// 
+// function($x){$x>5 ? \"foo\"}(6)
 TEST_F(lambdasTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case001.json"));
 }
 
-// 
+// function($x){$x>5 ? \"foo\"}(3)
 TEST_F(lambdasTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case002.json"));
 }
 
-// 
+// ($factorial:= function($x){$x <= 1 ? 1 : $x * $factorial($x-1)}; $factorial(4))
 TEST_F(lambdasTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case003.json"));
 }
 
-// 
+// ($fibonacci := function($x){$x <= 1 ? $x : $fibonacci($x-1) + $fibonacci($x-2)}; [1,2,3,4,5,6,7,8,9].$fibonacci($))
 TEST_F(lambdasTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case004.json"));
 }
 
-// 
+// ($nth_price := function($n) { (Account.Order.Product.Price)[$n] }; $nth_price(1) )
 TEST_F(lambdasTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case005.json"));
 }
 
-// 
+//             (              $even := function($n) { $n = 0 ? true : $odd($n-1) };              $odd := function($n) { $n = 0 ? false : $even($n-1) };              $even(82)            )
 TEST_F(lambdasTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case006.json"));
 }
 
-// 
+//             (              $even := function($n) { $n = 0 ? true : $odd($n-1) };               $odd := function($n) { $n = 0 ? false : $even($n-1) };               $even(65) )
 TEST_F(lambdasTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case007.json"));
 }
 
-// 
+//         (          $even := function($n) { $n = 0 ? true : $odd($n-1) };           $odd := function($n) { $n = 0 ? false : $even($n-1) };           $odd(65)         )
 TEST_F(lambdasTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case008.json"));
 }
 
-// 
+// (  $gcd := λ($a, $b){$b = 0 ? $a : $gcd($b, $a%$b) };  [$gcd(8,12), $gcd(9,12)])
 TEST_F(lambdasTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case009.json"));
 }
 
-// 
+// (  $range := function($start, $end, $step) { (    $step:=($step?$step:1);    $start+$step > $end ? $start : $append($start, $range($start+$step, $end, $step))   )};  $range(0,15))        
 TEST_F(lambdasTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case010.json"));
 }
 
-// 
+// (  $range := function($start, $end, $step) { (      $step:=($step?$step:1);        $start+$step > $end ? $start : $append($start, $range($start+$step, $end, $step))   )};  $range(0,15,2))        
 TEST_F(lambdasTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case011.json"));
 }
 
-// 
+// ( $median := λ($x){$sort($x)[$count($x)/2]};  $median([5,4,3,2,1,6,7,8,1]) )
 TEST_F(lambdasTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case012.json"));
 }
 
-// 
+// ( $f := function(){1}; $f.environment )
 TEST_F(lambdasTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/lambdas/case013.json"));
 }
diff --git a/test/gen/literalsTest.cpp b/test/gen/literalsTest.cpp
index 21ba44d..fd3cf33 100644
--- a/test/gen/literalsTest.cpp
+++ b/test/gen/literalsTest.cpp
@@ -6,107 +6,122 @@ using namespace jsonata;
 class literalsTest : public JsonataTest {
 };
 
-// 
-TEST_F(literalsTest, array_inputs) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/array-inputs.json"));
+// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
+TEST_F(literalsTest, array_inputs_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 0));
 }
 
-// 
+// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
+TEST_F(literalsTest, array_inputs_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 1));
+}
+
+// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
+TEST_F(literalsTest, array_inputs_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 2));
+}
+
+// {'fgFoo:0:hausnummer': {'type': 'de.example.api.PossibleValuesList', 'value': [{'label': '', 'value': ''}] }}
+TEST_F(literalsTest, array_inputs_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/literals/array-inputs.json", 3));
+}
+
+// \"hello\"
 TEST_F(literalsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case000.json"));
 }
 
-// 
+// 'hello'
 TEST_F(literalsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case001.json"));
 }
 
-// 
+// \"Wayne's World\"
 TEST_F(literalsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case002.json"));
 }
 
-// 
+// 42
 TEST_F(literalsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case003.json"));
 }
 
-// 
+// -42
 TEST_F(literalsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case004.json"));
 }
 
-// 
+// 3.14159
 TEST_F(literalsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case005.json"));
 }
 
-// 
+// 6.022e23
 TEST_F(literalsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case006.json"));
 }
 
-// 
+// 1.602E-19
 TEST_F(literalsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case007.json"));
 }
 
-// 
+// 10e1000
 TEST_F(literalsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case008.json"));
 }
 
-// 
+// \"hello\\tworld\"
 TEST_F(literalsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case009.json"));
 }
 
-// 
+// \"hello\\nworld\"
 TEST_F(literalsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case010.json"));
 }
 
-// 
+// \"hello \\\"world\\\"\"
 TEST_F(literalsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case011.json"));
 }
 
-// 
+// \"C:\\\\Test\\\\test.txt\"
 TEST_F(literalsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case012.json"));
 }
 
-// 
+// \"\\u03BB-calculus rocks\"
 TEST_F(literalsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case013.json"));
 }
 
-// 
+// \"𝄞\"
 TEST_F(literalsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case014.json"));
 }
 
-// 
+// \"\\y\"
 TEST_F(literalsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case015.json"));
 }
 
-// 
+// \"\\u\"
 TEST_F(literalsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case016.json"));
 }
 
-// 
+// \"\\u123t\"
 TEST_F(literalsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case017.json"));
 }
 
-// 
+// { 'foo': { 'sequence': 123, 'bar': 'baz' } } 
 TEST_F(literalsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case018.json"));
 }
 
-// 
+// { 'foo': { 'sequence': true, 'bar': 'baz' } } 
 TEST_F(literalsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/literals/case019.json"));
 }
diff --git a/test/gen/matchersTest.cpp b/test/gen/matchersTest.cpp
index b11340a..5d947c5 100644
--- a/test/gen/matchersTest.cpp
+++ b/test/gen/matchersTest.cpp
@@ -11,7 +11,7 @@ TEST_F(matchersTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/matchers/case000.json"));
 }
 
-// 
+// $split('some text', $uppercase)
 TEST_F(matchersTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/matchers/case001.json"));
 }
diff --git a/test/gen/missing_pathsTest.cpp b/test/gen/missing_pathsTest.cpp
index c3802c9..562fe25 100644
--- a/test/gen/missing_pathsTest.cpp
+++ b/test/gen/missing_pathsTest.cpp
@@ -6,32 +6,32 @@ using namespace jsonata;
 class missing_pathsTest : public JsonataTest {
 };
 
-// 
+// fdf
 TEST_F(missing_pathsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case000.json"));
 }
 
-// 
+// fdf.ett
 TEST_F(missing_pathsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case001.json"));
 }
 
-// 
+// fdf.ett[10]
 TEST_F(missing_pathsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case002.json"));
 }
 
-// 
+// fdf.ett[vc > 10]
 TEST_F(missing_pathsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case003.json"));
 }
 
-// 
+// fdf.ett + 27
 TEST_F(missing_pathsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case004.json"));
 }
 
-// 
+// $fdsd
 TEST_F(missing_pathsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/missing-paths/case005.json"));
 }
diff --git a/test/gen/multiple_array_selectorsTest.cpp b/test/gen/multiple_array_selectorsTest.cpp
index ca7e94b..2b8d916 100644
--- a/test/gen/multiple_array_selectorsTest.cpp
+++ b/test/gen/multiple_array_selectorsTest.cpp
@@ -6,17 +6,17 @@ using namespace jsonata;
 class multiple_array_selectorsTest : public JsonataTest {
 };
 
-// 
+// [1..10][[1..3,8,-1]]
 TEST_F(multiple_array_selectorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/multiple-array-selectors/case000.json"));
 }
 
-// 
+// [1..10][[1..3,8,5]]
 TEST_F(multiple_array_selectorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/multiple-array-selectors/case001.json"));
 }
 
-// 
+// [1..10][[1..3,8,false]]
 TEST_F(multiple_array_selectorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/multiple-array-selectors/case002.json"));
 }
diff --git a/test/gen/nullTest.cpp b/test/gen/nullTest.cpp
index b7dd607..e067966 100644
--- a/test/gen/nullTest.cpp
+++ b/test/gen/nullTest.cpp
@@ -6,37 +6,37 @@ using namespace jsonata;
 class nullTest : public JsonataTest {
 };
 
-// 
+// null
 TEST_F(nullTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case000.json"));
 }
 
-// 
+// [null]
 TEST_F(nullTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case001.json"));
 }
 
-// 
+// [null, null]
 TEST_F(nullTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case002.json"));
 }
 
-// 
+// $not(null)
 TEST_F(nullTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case003.json"));
 }
 
-// 
+// null = null
 TEST_F(nullTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case004.json"));
 }
 
-// 
+// null != null
 TEST_F(nullTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case005.json"));
 }
 
-// 
+// {\"true\": true, \"false\":false, \"null\": null}
 TEST_F(nullTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/null/case006.json"));
 }
diff --git a/test/gen/numeric_operatorsTest.cpp b/test/gen/numeric_operatorsTest.cpp
index 28e5689..a388e28 100644
--- a/test/gen/numeric_operatorsTest.cpp
+++ b/test/gen/numeric_operatorsTest.cpp
@@ -6,97 +6,97 @@ using namespace jsonata;
 class numeric_operatorsTest : public JsonataTest {
 };
 
-// 
+// foo.bar + bar
 TEST_F(numeric_operatorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case000.json"));
 }
 
-// 
+// bar + foo.bar
 TEST_F(numeric_operatorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case001.json"));
 }
 
-// 
+// foo.bar - bar
 TEST_F(numeric_operatorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case002.json"));
 }
 
-// 
+// bar - foo.bar
 TEST_F(numeric_operatorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case003.json"));
 }
 
-// 
+// foo.bar * bar
 TEST_F(numeric_operatorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case004.json"));
 }
 
-// 
+// bar * foo.bar
 TEST_F(numeric_operatorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case005.json"));
 }
 
-// 
+// foo.bar / bar
 TEST_F(numeric_operatorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case006.json"));
 }
 
-// 
+// bar / foo.bar
 TEST_F(numeric_operatorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case007.json"));
 }
 
-// 
+// foo.bar % bar
 TEST_F(numeric_operatorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case008.json"));
 }
 
-// 
+// bar % foo.bar
 TEST_F(numeric_operatorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case009.json"));
 }
 
-// 
+// bar + foo.bar * bar
 TEST_F(numeric_operatorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case010.json"));
 }
 
-// 
+// foo.bar * bar + bar
 TEST_F(numeric_operatorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case011.json"));
 }
 
-// 
+// 24 * notexist
 TEST_F(numeric_operatorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case012.json"));
 }
 
-// 
+// notexist + 1
 TEST_F(numeric_operatorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case013.json"));
 }
 
-// 
+// 1/(10e300 * 10e100) 
 TEST_F(numeric_operatorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case014.json"));
 }
 
-// 
+// \"5\" + \"5\"
 TEST_F(numeric_operatorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case015.json"));
 }
 
-// 
+// - notexist
 TEST_F(numeric_operatorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case016.json"));
 }
 
-// 
+// false + 1
 TEST_F(numeric_operatorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case017.json"));
 }
 
-// 
+// false + $x
 TEST_F(numeric_operatorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/numeric-operators/case018.json"));
 }
diff --git a/test/gen/object_constructorTest.cpp b/test/gen/object_constructorTest.cpp
index 3a92032..23659fd 100644
--- a/test/gen/object_constructorTest.cpp
+++ b/test/gen/object_constructorTest.cpp
@@ -6,127 +6,127 @@ using namespace jsonata;
 class object_constructorTest : public JsonataTest {
 };
 
-// 
+// {}
 TEST_F(object_constructorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case000.json"));
 }
 
-// 
+// {\"key\": \"value\"}
 TEST_F(object_constructorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case001.json"));
 }
 
-// 
+// {\"one\": 1, \"two\": 2}
 TEST_F(object_constructorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case002.json"));
 }
 
-// 
+// {\"one\": 1, \"two\": 2}.two
 TEST_F(object_constructorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case003.json"));
 }
 
-// 
+// {\"one\": 1, \"two\": {\"three\": 3, \"four\": \"4\"}}
 TEST_F(object_constructorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case004.json"));
 }
 
-// 
+// {\"one\": 1, \"two\": [3, \"four\"]}
 TEST_F(object_constructorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case005.json"));
 }
 
-// 
+// {\"test\": ()}
 TEST_F(object_constructorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case006.json"));
 }
 
-// 
+// blah.{}
 TEST_F(object_constructorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case007.json"));
 }
 
-// 
+// Account.Order{OrderID: Product.\"Product Name\"}
 TEST_F(object_constructorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case008.json"));
 }
 
-// 
+// Account.Order.{OrderID: Product.\"Product Name\"}
 TEST_F(object_constructorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case009.json"));
 }
 
-// 
+// Account.Order.Product{$string(ProductID): Price}
 TEST_F(object_constructorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case010.json"));
 }
 
-// 
+// Account.Order.Product{$string(ProductID): (Price)[0]}
 TEST_F(object_constructorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case011.json"));
 }
 
-// 
+// Account.Order.Product.{$string(ProductID): Price}
 TEST_F(object_constructorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case012.json"));
 }
 
-// 
+// Account.Order.Product{ProductID: \"Product Name\"}
 TEST_F(object_constructorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case013.json"));
 }
 
-// 
+// Account.Order.Product.{ProductID: \"Product Name\"}
 TEST_F(object_constructorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case014.json"));
 }
 
-// 
+// Account.Order{OrderID: $sum(Product.(Price*Quantity))}
 TEST_F(object_constructorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case015.json"));
 }
 
-// 
+// Account.Order.{OrderID: $sum(Product.(Price*Quantity))}
 TEST_F(object_constructorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case016.json"));
 }
 
-// 
+// Account.Order.Product{$.\"Product Name\": Price, $.\"Product Name\": Price}
 TEST_F(object_constructorTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case017.json"));
 }
 
-// 
+// Account.Order.Product{`Product Name`: Price, SKU: Price}
 TEST_F(object_constructorTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case018.json"));
 }
 
-// 
+// Account.Order{  OrderID: {    \"TotalPrice\":$sum(Product.(Price * Quantity)),    \"Items\": Product.\"Product Name\"  }}
 TEST_F(object_constructorTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case019.json"));
 }
 
-// 
+// {  \"Order\": Account.Order.{      \"ID\": OrderID,      \"Product\": Product.{          \"Name\": $.\"Product Name\",          \"SKU\": ProductID,          \"Details\": {            \"Weight\": Description.Weight,            \"Dimensions\": Description.(Width & \" x \" & Height & \" x \" & Depth)          }        },      \"Total Price\": $sum(Product.(Price * Quantity))    }}
 TEST_F(object_constructorTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case020.json"));
 }
 
-// 
+// {  \"Order\": Account.Order.{      \"ID\": OrderID,      \"Product\": Product.{          \"Name\": `Product Name`,          \"SKU\": ProductID,          \"Details\": {            \"Weight\": Description.Weight,            \"Dimensions\": Description.(Width & \" x \" & Height & \" x \" & Depth)          }        },      \"Total Price\": $sum(Product.(Price * Quantity))    }}
 TEST_F(object_constructorTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case021.json"));
 }
 
-// 
+// Phone{type: $join(number, \", \"), \"phone\":number}
 TEST_F(object_constructorTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case022.json"));
 }
 
-// 
+// $.{ type: $average(value), kind: $sum(value) } 
 TEST_F(object_constructorTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case023.json"));
 }
 
-// 
+// { type: $average(value), kind: $sum(value) } 
 TEST_F(object_constructorTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case024.json"));
 }
@@ -136,7 +136,7 @@ TEST_F(object_constructorTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case025.json"));
 }
 
-// 
+// $${id:{'label':label,'value':value}}
 TEST_F(object_constructorTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/object-constructor/case026.json"));
 }
diff --git a/test/gen/parent_operatorTest.cpp b/test/gen/parent_operatorTest.cpp
index 0248614..b657eff 100644
--- a/test/gen/parent_operatorTest.cpp
+++ b/test/gen/parent_operatorTest.cpp
@@ -6,13 +6,223 @@ using namespace jsonata;
 class parent_operatorTest : public JsonataTest {
 };
 
+// {'hello': 'world'}.% 
+TEST_F(parent_operatorTest, errors_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 0));
+}
+
+// %
+TEST_F(parent_operatorTest, errors_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 1));
+}
+
+// %()
+TEST_F(parent_operatorTest, errors_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 2));
+}
+
+// %(1)
+TEST_F(parent_operatorTest, errors_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 3));
+}
+
+// %%
+TEST_F(parent_operatorTest, errors_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 4));
+}
+
+// (%)
+TEST_F(parent_operatorTest, errors_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 5));
+}
+
+// (%%)
+TEST_F(parent_operatorTest, errors_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 6));
+}
+
+// library.loans.%%
+TEST_F(parent_operatorTest, errors_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 7));
+}
+
+// $.%
+TEST_F(parent_operatorTest, errors_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 8));
+}
+
+// $$.%
+TEST_F(parent_operatorTest, errors_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 9));
+}
+
+// library.loans.%.%.%
+TEST_F(parent_operatorTest, errors_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 10));
+}
+
+// library.%%%
+TEST_F(parent_operatorTest, errors_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 11));
+}
+
+// library.(%%%)
+TEST_F(parent_operatorTest, errors_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 12));
+}
+
+// library.(%% %)
+TEST_F(parent_operatorTest, errors_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 13));
+}
+
+// library.(% %%)
+TEST_F(parent_operatorTest, errors_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 14));
+}
+
+// library.(% % %)
+TEST_F(parent_operatorTest, errors_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/errors.json", 15));
+}
+
 // 
-TEST_F(parent_operatorTest, errors) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parent-operator/errors.json"));
+TEST_F(parent_operatorTest, parent_case_0) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 0));
 }
 
 // 
-TEST_F(parent_operatorTest, parent) {
-    EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parent-operator/parent.json"));
+TEST_F(parent_operatorTest, parent_case_1) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 1));
+}
+
+// Account.Order.Product.[`Product Name`, %.OrderID]
+TEST_F(parent_operatorTest, parent_case_2) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 2));
+}
+
+// Account.Order.Product.{ `Product Name`: [Quantity, %.OrderID] }
+TEST_F(parent_operatorTest, parent_case_3) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 3));
+}
+
+// Account.Order.Product.{ `Product Name`: [Quantity, (%.OrderID)] }
+TEST_F(parent_operatorTest, parent_case_4) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 4));
+}
+
+// Account.Order.Product[%.OrderID='order104'].SKU
+TEST_F(parent_operatorTest, parent_case_5) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 5));
+}
+
+// Account.Order.Product[%.%.`Account Name`='Firefly'].SKU
+TEST_F(parent_operatorTest, parent_case_6) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 6));
+}
+
+// Account.Order.Product.Price[%.%.OrderID='order103']
+TEST_F(parent_operatorTest, parent_case_7) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 7));
+}
+
+// Account.Order.Product.Price.%[%.OrderID='order103'].SKU
+TEST_F(parent_operatorTest, parent_case_8) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 8));
+}
+
+// Account.Order.Product[%.OrderID='order104'][%.%.`Account Name`='Firefly'].SKU
+TEST_F(parent_operatorTest, parent_case_9) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 9));
+}
+
+// (Account.Order.Product)[%.OrderID='order104'].SKU
+TEST_F(parent_operatorTest, parent_case_10) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 10));
+}
+
+// Account.Order.Product.{ %.OrderID: Price * Quantity }
+TEST_F(parent_operatorTest, parent_case_11) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 11));
+}
+
+// Account.Order.().%
+TEST_F(parent_operatorTest, parent_case_12) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 12));
+}
+
+// 
+TEST_F(parent_operatorTest, parent_case_13) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 13));
+}
+
+// 
+TEST_F(parent_operatorTest, parent_case_14) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 14));
+}
+
+// 
+TEST_F(parent_operatorTest, parent_case_15) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 15));
+}
+
+// 
+TEST_F(parent_operatorTest, parent_case_16) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 16));
+}
+
+// 
+TEST_F(parent_operatorTest, parent_case_17) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 17));
+}
+
+// Account.Order.Product.SKU^(%.Price)
+TEST_F(parent_operatorTest, parent_case_18) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 18));
+}
+
+// Account.Order.Product.SKU^(%.Price, >%.%.OrderID)
+TEST_F(parent_operatorTest, parent_case_19) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 19));
+}
+
+// Account.Order.Product.Description.{ 'Colour': Colour, 'Total': %.Price * %.Quantity }
+TEST_F(parent_operatorTest, parent_case_20) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 20));
+}
+
+// Account.Order.Product.Description.{ 'Item': Colour & ' ' & %.`Product Name`, 'Discounted': (%.%.OrderID = 'order103') ? %.Price / 2 : %.Price }
+TEST_F(parent_operatorTest, parent_case_21) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 21));
+}
+
+// Account.Order.Product.( $parent := %; %.OrderID )
+TEST_F(parent_operatorTest, parent_case_22) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 22));
+}
+
+// Account.Order.Product.( $parent := %; $parent.OrderID )
+TEST_F(parent_operatorTest, parent_case_23) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 23));
+}
+
+// library.loans@$L.books@$B[$L.isbn=$B.isbn].{ 'book': $B.title, 'parent': $keys(%) }
+TEST_F(parent_operatorTest, parent_case_24) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 24));
+}
+
+// library.loans@$L.books@$B[$L.isbn=$B.isbn].customers[id=$L.customer].{ 'book': $B.title, 'customer': name, 'parent': $keys(%) }
+TEST_F(parent_operatorTest, parent_case_25) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 25));
+}
+
+// library.loans@$L.books@$B[$L.isbn=$B.isbn].customers[id=$L.customer].{ 'book': $B.title, 'customer': name, 'parent': $keys(%.%) }
+TEST_F(parent_operatorTest, parent_case_26) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 26));
+}
+
+// library.loans@$L.books@$B[$L.isbn=$B.isbn].customers@$C[$C.id=$L.customer].{ 'book': $B.title, 'customer': $C.name, 'grandparent': $keys(%.%) }
+TEST_F(parent_operatorTest, parent_case_27) {
+    EXPECT_NO_THROW(runSubCase("jsonata/test/test-suite/groups/parent-operator/parent.json", 27));
 }
 
diff --git a/test/gen/parenthesesTest.cpp b/test/gen/parenthesesTest.cpp
index 23dc991..68b7408 100644
--- a/test/gen/parenthesesTest.cpp
+++ b/test/gen/parenthesesTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class parenthesesTest : public JsonataTest {
 };
 
-// 
+// foo.(blah).baz.fud
 TEST_F(parenthesesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case000.json"));
 }
 
-// 
+// foo.(blah.baz).fud
 TEST_F(parenthesesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case001.json"));
 }
 
-// 
+// (foo.blah.baz).fud
 TEST_F(parenthesesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case002.json"));
 }
 
-// 
+// foo.blah.(baz.fud)
 TEST_F(parenthesesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case003.json"));
 }
 
-// 
+// (foo.blah.baz.fud)
 TEST_F(parenthesesTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case004.json"));
 }
 
-// 
+// (foo).(blah).baz.(fud)
 TEST_F(parenthesesTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case005.json"));
 }
 
-// 
+// (foo.(blah).baz.fud)
 TEST_F(parenthesesTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case006.json"));
 }
 
-// 
+// (4 + 2) / 2
 TEST_F(parenthesesTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/parentheses/case007.json"));
 }
diff --git a/test/gen/partial_applicationTest.cpp b/test/gen/partial_applicationTest.cpp
index 6fbcac6..b22f6c3 100644
--- a/test/gen/partial_applicationTest.cpp
+++ b/test/gen/partial_applicationTest.cpp
@@ -6,27 +6,27 @@ using namespace jsonata;
 class partial_applicationTest : public JsonataTest {
 };
 
-// 
+// (  $add := function($x, $y){$x+$y};  $add2 := $add(?, 2);  $add2(3))
 TEST_F(partial_applicationTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case000.json"));
 }
 
-// 
+// (  $add := function($x, $y){$x+$y};  $add2 := $add(2, ?);  $add2(4))
 TEST_F(partial_applicationTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case001.json"));
 }
 
-// 
+// (  $firstn := $substring(?, 0, ?);  $first5 := $firstn(?, 5);  $first5(\"Hello World\"))
 TEST_F(partial_applicationTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case002.json"));
 }
 
-// 
+// substring(?, 0, ?)
 TEST_F(partial_applicationTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case003.json"));
 }
 
-// 
+// unknown(?)
 TEST_F(partial_applicationTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/partial-application/case004.json"));
 }
diff --git a/test/gen/performanceTest.cpp b/test/gen/performanceTest.cpp
index c5aa4c0..dea919a 100644
--- a/test/gen/performanceTest.cpp
+++ b/test/gen/performanceTest.cpp
@@ -6,12 +6,12 @@ using namespace jsonata;
 class performanceTest : public JsonataTest {
 };
 
-// 
+// {\"items\": items.{\"foo\": \"bar\",\"count\": $count($$.items[text!=\"\" and text!=\"foo\"].row)}}
 TEST_F(performanceTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/performance/case000.json"));
 }
 
-// 
+// {\"items\": items#$i.{\"foo\": \"bar\",\"label\": $$.items[$i].label & \" \" & $$.items[text!=\"\" and text!=\"test\"][$i].text}}
 TEST_F(performanceTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/performance/case001.json"));
 }
diff --git a/test/gen/predicatesTest.cpp b/test/gen/predicatesTest.cpp
index c0cf074..e7044b3 100644
--- a/test/gen/predicatesTest.cpp
+++ b/test/gen/predicatesTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class predicatesTest : public JsonataTest {
 };
 
-// 
+// nothing[x=6][y=3].number
 TEST_F(predicatesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case000.json"));
 }
 
-// 
+// clues[x=6][y=3].number
 TEST_F(predicatesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case001.json"));
 }
 
-// 
+// $[x=6][y=3].number
 TEST_F(predicatesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case002.json"));
 }
 
-// 
+// Account.Order.Product[$lowercase(Description.Colour) = \"purple\"][0].Price
 TEST_F(predicatesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/predicates/case003.json"));
 }
diff --git a/test/gen/quoted_selectorsTest.cpp b/test/gen/quoted_selectorsTest.cpp
index fcf774d..63e29ea 100644
--- a/test/gen/quoted_selectorsTest.cpp
+++ b/test/gen/quoted_selectorsTest.cpp
@@ -6,42 +6,42 @@ using namespace jsonata;
 class quoted_selectorsTest : public JsonataTest {
 };
 
-// 
+// foo.\"blah\"
 TEST_F(quoted_selectorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case000.json"));
 }
 
-// 
+// foo.\"blah\".baz.'fud'
 TEST_F(quoted_selectorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case001.json"));
 }
 
-// 
+// \"foo\".\"blah\".\"baz\".\"fud\"
 TEST_F(quoted_selectorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case002.json"));
 }
 
-// 
+// foo.\"blah.baz\"
 TEST_F(quoted_selectorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case003.json"));
 }
 
-// 
+// foo.`blah`
 TEST_F(quoted_selectorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case004.json"));
 }
 
-// 
+// foo.`blah`.baz.'fud'
 TEST_F(quoted_selectorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case005.json"));
 }
 
-// 
+// `foo`.`blah`.`baz`.`fud`
 TEST_F(quoted_selectorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case006.json"));
 }
 
-// 
+// foo.`blah.baz`
 TEST_F(quoted_selectorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/quoted-selectors/case007.json"));
 }
diff --git a/test/gen/range_operatorTest.cpp b/test/gen/range_operatorTest.cpp
index 106e494..139eee4 100644
--- a/test/gen/range_operatorTest.cpp
+++ b/test/gen/range_operatorTest.cpp
@@ -6,127 +6,127 @@ using namespace jsonata;
 class range_operatorTest : public JsonataTest {
 };
 
-// 
+// [0..9]
 TEST_F(range_operatorTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case000.json"));
 }
 
-// 
+// [0..9][$ % 2 = 0]
 TEST_F(range_operatorTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case001.json"));
 }
 
-// 
+// [0, 4..9, 20, 22]
 TEST_F(range_operatorTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case002.json"));
 }
 
-// 
+// [5..2]
 TEST_F(range_operatorTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case003.json"));
 }
 
-// 
+// [5..2, 2..5]
 TEST_F(range_operatorTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case004.json"));
 }
 
-// 
+// [-2..2]
 TEST_F(range_operatorTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case005.json"));
 }
 
-// 
+// [-2..2].($*$)
 TEST_F(range_operatorTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case006.json"));
 }
 
-// 
+// [-2..blah]
 TEST_F(range_operatorTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case007.json"));
 }
 
-// 
+// [blah..5, 3, -2..blah]
 TEST_F(range_operatorTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case008.json"));
 }
 
-// 
+// [1.1 .. 5]
 TEST_F(range_operatorTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case009.json"));
 }
 
-// 
+// [1 .. 5.5]
 TEST_F(range_operatorTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case010.json"));
 }
 
-// 
+// [10..1.5]
 TEST_F(range_operatorTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case011.json"));
 }
 
-// 
+// [true..false]
 TEST_F(range_operatorTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case012.json"));
 }
 
-// 
+// ['dogs'..'cats']
 TEST_F(range_operatorTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case013.json"));
 }
 
-// 
+// [1..'']
 TEST_F(range_operatorTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case014.json"));
 }
 
-// 
+// [1..[]]
 TEST_F(range_operatorTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case015.json"));
 }
 
-// 
+// [1..{}]
 TEST_F(range_operatorTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case016.json"));
 }
 
-// 
+// [1..false]
 TEST_F(range_operatorTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case017.json"));
 }
 
-// 
+// [2..true]
 TEST_F(range_operatorTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case018.json"));
 }
 
-// 
+// [$x..true]
 TEST_F(range_operatorTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case019.json"));
 }
 
-// 
+// [false..$x]
 TEST_F(range_operatorTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case020.json"));
 }
 
-// 
+// [1..10000000] ~> $count()
 TEST_F(range_operatorTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case021.json"));
 }
 
-// 
+// [0..10000000] ~> $count()
 TEST_F(range_operatorTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case022.json"));
 }
 
-// 
+// [1..10000001] ~> $count()
 TEST_F(range_operatorTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case023.json"));
 }
 
-// 
+// [100..10000099] ~> $count()
 TEST_F(range_operatorTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/range-operator/case024.json"));
 }
diff --git a/test/gen/regexTest.cpp b/test/gen/regexTest.cpp
index 051bff8..2892bfb 100644
--- a/test/gen/regexTest.cpp
+++ b/test/gen/regexTest.cpp
@@ -6,197 +6,197 @@ using namespace jsonata;
 class regexTest : public JsonataTest {
 };
 
-// 
+// $split(\"ababbxabbcc\",/b+/)
 TEST_F(regexTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case000.json"));
 }
 
-// 
+// $split(\"ababbxabbcc\",/b+/, 2)
 TEST_F(regexTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case001.json"));
 }
 
-// 
+// $split(\"ababbxabbcc\",/d+/)
 TEST_F(regexTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case002.json"));
 }
 
-// 
+// $contains(\"ababbxabbcc\",/ab+/)
 TEST_F(regexTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case003.json"));
 }
 
-// 
+// $contains(\"ababbxabbcc\",/ax+/)
 TEST_F(regexTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case004.json"));
 }
 
-// 
+// Account.Order.Product[$contains($.\"Product Name\", /hat/)].ProductID
 TEST_F(regexTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case005.json"));
 }
 
-// 
+// Account.Order.Product[$contains($.\"Product Name\", /hat/i)].ProductID
 TEST_F(regexTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case006.json"));
 }
 
-// 
+// $replace(\"ababbxabbcc\",/b+/, \"yy\")
 TEST_F(regexTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case007.json"));
 }
 
-// 
+// $replace(\"ababbxabbcc\",/b+/, \"yy\", 2)
 TEST_F(regexTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case008.json"));
 }
 
-// 
+// $replace(\"ababbxabbcc\",/b+/, \"yy\", 0)
 TEST_F(regexTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case009.json"));
 }
 
-// 
+// $replace(\"ababbxabbcc\",/d+/, \"yy\")
 TEST_F(regexTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case010.json"));
 }
 
-// 
+// $replace(\"John Smith\", /(\\w+)\\s(\\w+)/, \"$2, $1\")
 TEST_F(regexTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case011.json"));
 }
 
-// 
+// $replace(\"265USD\", /([0-9]+)USD/, \"$$$1\")
 TEST_F(regexTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case012.json"));
 }
 
-// 
+// $replace(\"265USD\", /([0-9]+)USD/, \"$w\")
 TEST_F(regexTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case013.json"));
 }
 
-// 
+// $replace(\"265USD\", /([0-9]+)USD/, \"$0 -> $$$1\")
 TEST_F(regexTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case014.json"));
 }
 
-// 
+// $replace(\"265USD\", /([0-9]+)USD/, \"$0$1$2\")
 TEST_F(regexTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case015.json"));
 }
 
-// 
+// $replace(\"abcd\", /(ab)|(a)/, \"[1=$1][2=$2]\")
 TEST_F(regexTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case016.json"));
 }
 
-// 
+// $replace(\"abracadabra\", /bra/, \"*\")
 TEST_F(regexTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case017.json"));
 }
 
-// 
+// $replace(\"abracadabra\", /a.*a/, \"*\")
 TEST_F(regexTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case018.json"));
 }
 
-// 
+// $replace(\"abracadabra\", /a.*?a/, \"*\")
 TEST_F(regexTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case019.json"));
 }
 
-// 
+// $replace(\"abracadabra\", /a/, \"\")
 TEST_F(regexTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case020.json"));
 }
 
-// 
+// $replace(\"abracadabra\", /a(.)/, \"a$1$1\")
 TEST_F(regexTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case021.json"));
 }
 
-// 
+// $replace(\"abracadabra\", /.*?/, \"$1\")
 TEST_F(regexTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case022.json"));
 }
 
-// 
+// $replace(\"AAAA\", /A+/, \"b\")
 TEST_F(regexTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case023.json"));
 }
 
-// 
+// $replace(\"AAAA\", /A+?/, \"b\")
 TEST_F(regexTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case024.json"));
 }
 
-// 
+// $replace(\"darted\", /^(.*?)d(.*)$/, \"$1c$2\")
 TEST_F(regexTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case025.json"));
 }
 
-// 
+// $replace(\"abcdefghijklmno\", /(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)/, \"$8$5$12$12$18$123\")
 TEST_F(regexTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case026.json"));
 }
 
-// 
+// $replace(\"abcdefghijklmno\", /xyz/, \"$8$5$12$12$18$123\")
 TEST_F(regexTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case027.json"));
 }
 
-// 
+// $replace(\"abcdefghijklmno\", /ijk/, \"$8$5$12$12$18$123\")
 TEST_F(regexTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case028.json"));
 }
 
-// 
+// $replace(\"abcdefghijklmno\", /(ijk)/, \"$8$5$12$12$18$123\")
 TEST_F(regexTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case029.json"));
 }
 
-// 
+// $replace(\"abcdefghijklmno\", /ijk/, \"$x\")
 TEST_F(regexTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case030.json"));
 }
 
-// 
+// $replace(\"abcdefghijklmno\", /(ijk)/, \"$x$\")
 TEST_F(regexTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case031.json"));
 }
 
-// 
+// Account.Order.Product.$replace($.\"Product Name\", /hat/i, function($match) { \"foo\" })
 TEST_F(regexTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case032.json"));
 }
 
-// 
+// Account.Order.Product.$replace($.\"Product Name\", /(h)(at)/i, function($match) { $uppercase($match.match) })
 TEST_F(regexTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case033.json"));
 }
 
-// 
+// $replace(\"temperature = 68F today\", /(-?\\d+(?:\\.\\d*)?)F\\b/, function($m) { ($number($m.groups[0]) - 32) * 5/9 & \"C\" })
 TEST_F(regexTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case034.json"));
 }
 
-// 
+// Account.Order.Product.$replace($.\"Product Name\", /hat/i, function($match) { true })
 TEST_F(regexTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case035.json"));
 }
 
-// 
+// Account.Order.Product.$replace($.\"Product Name\", /hat/i, function($match) { 42 })
 TEST_F(regexTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case036.json"));
 }
 
-// 
+// $map($, $match(?, /^(\\w*\\s\\w*)/)).match
 TEST_F(regexTest, case037) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case037.json"));
 }
 
-// 
+// $map($, function($i){ $match($i, /^(\\w*\\s\\w*)/) }).match
 TEST_F(regexTest, case038) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/regex/case038.json"));
 }
diff --git a/test/gen/simple_array_selectorsTest.cpp b/test/gen/simple_array_selectorsTest.cpp
index 0dd6c6b..4969536 100644
--- a/test/gen/simple_array_selectorsTest.cpp
+++ b/test/gen/simple_array_selectorsTest.cpp
@@ -6,117 +6,117 @@ using namespace jsonata;
 class simple_array_selectorsTest : public JsonataTest {
 };
 
-// 
+// nest0.nest1[0]
 TEST_F(simple_array_selectorsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case000.json"));
 }
 
-// 
+// foo.blah[0].baz.fud
 TEST_F(simple_array_selectorsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case001.json"));
 }
 
-// 
+// foo.blah[1].baz.fud
 TEST_F(simple_array_selectorsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case002.json"));
 }
 
-// 
+// foo.blah[-1].bazz
 TEST_F(simple_array_selectorsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case003.json"));
 }
 
-// 
+// (foo.blah)[1].baz.fud
 TEST_F(simple_array_selectorsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case004.json"));
 }
 
-// 
+// foo.blah.baz.fud[0]
 TEST_F(simple_array_selectorsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case005.json"));
 }
 
-// 
+// foo.blah.baz.fud[-1]
 TEST_F(simple_array_selectorsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case006.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[0]
 TEST_F(simple_array_selectorsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case007.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[1]
 TEST_F(simple_array_selectorsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case008.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[5 * 0.2]
 TEST_F(simple_array_selectorsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case009.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[-1]
 TEST_F(simple_array_selectorsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case010.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[-2]
 TEST_F(simple_array_selectorsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case011.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[2-4]
 TEST_F(simple_array_selectorsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case012.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[-(4-2)]
 TEST_F(simple_array_selectorsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case013.json"));
 }
 
-// 
+// (foo.blah.baz.fud)[$$.foo.bar / 30]
 TEST_F(simple_array_selectorsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case014.json"));
 }
 
-// 
+// foo.blah[0].baz
 TEST_F(simple_array_selectorsTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case015.json"));
 }
 
-// 
+// foo.blah.baz[0]
 TEST_F(simple_array_selectorsTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case016.json"));
 }
 
-// 
+// (foo.blah.baz)[0]
 TEST_F(simple_array_selectorsTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case017.json"));
 }
 
-// 
+// $[0]
 TEST_F(simple_array_selectorsTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case018.json"));
 }
 
-// 
+// $[1]
 TEST_F(simple_array_selectorsTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case019.json"));
 }
 
-// 
+// $[-1]
 TEST_F(simple_array_selectorsTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case020.json"));
 }
 
-// 
+// $[1][0]
 TEST_F(simple_array_selectorsTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case021.json"));
 }
 
-// 
+// $[1.1][0.9]
 TEST_F(simple_array_selectorsTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/simple-array-selectors/case022.json"));
 }
diff --git a/test/gen/sortingTest.cpp b/test/gen/sortingTest.cpp
index d80bc3f..9c607c6 100644
--- a/test/gen/sortingTest.cpp
+++ b/test/gen/sortingTest.cpp
@@ -6,107 +6,107 @@ using namespace jsonata;
 class sortingTest : public JsonataTest {
 };
 
-// 
+// Account.Order.Product.Price^($)
 TEST_F(sortingTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case000.json"));
 }
 
-// 
+// Account.Order.Product.Price^(<$)
 TEST_F(sortingTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case001.json"));
 }
 
-// 
+// Account.Order.Product.Price^(>$)
 TEST_F(sortingTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case002.json"));
 }
 
-// 
+// Account.Order.Product^(Price).Description.Colour
 TEST_F(sortingTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case003.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case004.json"));
 }
 
-// 
+// Account.Order.Product^(Price * Quantity).Description.Colour
 TEST_F(sortingTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case005.json"));
 }
 
-// 
+// Account.Order.Product^(Quantity, Description.Colour).Description.Colour
 TEST_F(sortingTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case006.json"));
 }
 
-// 
+// Account.Order.Product^(Quantity, >Description.Colour).Description.Colour
 TEST_F(sortingTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case007.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case008.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case009.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case010.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case011.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case012.json"));
 }
 
-// 
+// Account.Order.Product^(Price).SKU
 TEST_F(sortingTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case013.json"));
 }
 
-// 
+// $^(age).name
 TEST_F(sortingTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case014.json"));
 }
 
-// 
+// ($^(age)).name
 TEST_F(sortingTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case015.json"));
 }
 
-// 
+// $^(age)[0].name
 TEST_F(sortingTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case016.json"));
 }
 
-// 
+// ($^(age))[0].name
 TEST_F(sortingTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case017.json"));
 }
 
-// 
+// ($^(age)[0]).name
 TEST_F(sortingTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case018.json"));
 }
 
-// 
+// $[0]^(age)
 TEST_F(sortingTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case019.json"));
 }
 
-// 
+// Account.Order#$o.Product^(ProductID).{ 'Product': `Product Name`, 'Order Index': $o }
 TEST_F(sortingTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/sorting/case020.json"));
 }
diff --git a/test/gen/string_concatTest.cpp b/test/gen/string_concatTest.cpp
index ce6bec0..af903ff 100644
--- a/test/gen/string_concatTest.cpp
+++ b/test/gen/string_concatTest.cpp
@@ -6,62 +6,62 @@ using namespace jsonata;
 class string_concatTest : public JsonataTest {
 };
 
-// 
+// \"foo\" & \"bar\"
 TEST_F(string_concatTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case000.json"));
 }
 
-// 
+// \"foo\"&\"bar\"
 TEST_F(string_concatTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case001.json"));
 }
 
-// 
+// foo.blah[0].baz.fud &foo.blah[1].baz.fud
 TEST_F(string_concatTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case002.json"));
 }
 
-// 
+// foo.(blah[0].baz.fud & blah[1].baz.fud)
 TEST_F(string_concatTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case003.json"));
 }
 
-// 
+// foo.(blah[0].baz.fud & none)
 TEST_F(string_concatTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case004.json"));
 }
 
-// 
+// foo.(none.here & blah[1].baz.fud)
 TEST_F(string_concatTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case005.json"));
 }
 
-// 
+// [1,2]&[3,4]
 TEST_F(string_concatTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case006.json"));
 }
 
-// 
+// [1,2]&3
 TEST_F(string_concatTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case007.json"));
 }
 
-// 
+// 1&2
 TEST_F(string_concatTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case008.json"));
 }
 
-// 
+// 1&[2]
 TEST_F(string_concatTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case009.json"));
 }
 
-// 
+// \"hello\"&5
 TEST_F(string_concatTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case010.json"));
 }
 
-// 
+// \"Prices: \" & Account.Order.Product.Price
 TEST_F(string_concatTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/string-concat/case011.json"));
 }
diff --git a/test/gen/tail_recursionTest.cpp b/test/gen/tail_recursionTest.cpp
index 67bb5da..b4c669c 100644
--- a/test/gen/tail_recursionTest.cpp
+++ b/test/gen/tail_recursionTest.cpp
@@ -6,52 +6,52 @@ using namespace jsonata;
 class tail_recursionTest : public JsonataTest {
 };
 
-// 
+//             (              $f := function($n){()};              $f(1)            ) 
 TEST_F(tail_recursionTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case000.json"));
 }
 
-// 
+// (  $factorial := function($n){$n = 0 ? 1 : $n * $factorial($n - 1)};  $factorial(99))             
 TEST_F(tail_recursionTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case001.json"));
 }
 
-// 
+// (  $factorial := function($n){$n = 0 ? 1 : $n * $factorial($n - 1)};  $factorial(100))             
 TEST_F(tail_recursionTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case002.json"));
 }
 
-// 
+// (  $factorial := function($n){(    $iter := function($n, $acc) {      $n = 0 ? $acc : $iter($n - 1, $n * $acc)    };    $iter($n, 1)  )};  $factorial(5)) 
 TEST_F(tail_recursionTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case003.json"));
 }
 
-// 
+// (  $factorial := function($n){(    $iter := function($n, $acc) {      $n = 0 ? $acc : $iter($n - 1, $n * $acc)    };    $iter($n, 1)  )};  $factorial(150)) 
 TEST_F(tail_recursionTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case004.json"));
 }
 
-// 
+// (  $inf := function($n){$n+$inf($n-1)};  $inf(5))
 TEST_F(tail_recursionTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case005.json"));
 }
 
-// 
+// (  $inf := function(){$inf()};  $inf())
 TEST_F(tail_recursionTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case006.json"));
 }
 
-// 
+//         (          $even := function($n) { $n = 0 ? true : $odd($n-1) };           $odd := function($n) { $n = 0 ? false : $even($n-1) };           $odd(6555)         )
 TEST_F(tail_recursionTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case007.json"));
 }
 
-// 
+// ($f := function($s, $x)<an:s> { $x > 0 ? $f([$s, $s], $x-1) : $s};  $f('a', 2)  )
 TEST_F(tail_recursionTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case008.json"));
 }
 
-// 
+// ($f := function($s, $x)<sn:s> { $x > 0 ? $f([$s, $s], $x-1) : $s};  $f('a', 2)  )
 TEST_F(tail_recursionTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/tail-recursion/case009.json"));
 }
diff --git a/test/gen/token_conversionTest.cpp b/test/gen/token_conversionTest.cpp
index c6f874d..89c9187 100644
--- a/test/gen/token_conversionTest.cpp
+++ b/test/gen/token_conversionTest.cpp
@@ -6,22 +6,22 @@ using namespace jsonata;
 class token_conversionTest : public JsonataTest {
 };
 
-// 
+// $.'7a'
 TEST_F(token_conversionTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case000.json"));
 }
 
-// 
+// $.'7'
 TEST_F(token_conversionTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case001.json"));
 }
 
-// 
+// $.7a
 TEST_F(token_conversionTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case002.json"));
 }
 
-// 
+// $.7
 TEST_F(token_conversionTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/token-conversion/case003.json"));
 }
diff --git a/test/gen/transformTest.cpp b/test/gen/transformTest.cpp
index 982ab28..c753ec4 100644
--- a/test/gen/transformTest.cpp
+++ b/test/gen/transformTest.cpp
@@ -6,522 +6,522 @@ using namespace jsonata;
 class transformTest : public JsonataTest {
 };
 
-// 
+// {'Order': Account.Order.{  'ID': OrderID,  'Product': Product.{    'SKU': ProductID,    'Details': {      'Weight': Description.Weight,      'Dimensions': Description.(Width & ' x ' & Height & ' x ' & Depth)    }  },  'Total Price': $sum(Product.(Price * Quantity))}}
 TEST_F(transformTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case000.json"));
 }
 
-// 
+//          (           $tempReadings := $count(state.tempReadings) = 5 ?               [state.tempReadings[[1..4]], event.t] :               [state.tempReadings, event.t];                    {             \"tempReadings\": $tempReadings,             \"sumTemperatures\": $sum($tempReadings),             \"avgTemperature\": $average($tempReadings) ~> $round(2),             \"maxTemperature\": $max($tempReadings),             \"minTemperature\": $min($tempReadings)           }         )
 TEST_F(transformTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case001.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case002.json"));
 }
 
-// 
+// foo
 TEST_F(transformTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case003.json"));
 }
 
-// 
+// baz
 TEST_F(transformTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case004.json"));
 }
 
-// 
+// Foo
 TEST_F(transformTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case005.json"));
 }
 
-// 
+// food
 TEST_F(transformTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case006.json"));
 }
 
-// 
+// maz.rar
 TEST_F(transformTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case007.json"));
 }
 
-// 
+// jee.par.waa
 TEST_F(transformTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case008.json"));
 }
 
-// 
+// foo
 TEST_F(transformTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case009.json"));
 }
 
-// 
+// foo.bar
 TEST_F(transformTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case010.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case011.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case012.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case013.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case014.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case015) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case015.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case016) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case016.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case017) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case017.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case018) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case018.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case019) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case019.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case020) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case020.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case021) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case021.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case022) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case022.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case023) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case023.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case024) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case024.json"));
 }
 
-// 
+// bar
 TEST_F(transformTest, case025) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case025.json"));
 }
 
-// 
+// $
 TEST_F(transformTest, case026) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case026.json"));
 }
 
-// 
+// $lowercase(Salutation)
 TEST_F(transformTest, case027) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case027.json"));
 }
 
-// 
+// $lowercase(敷)
 TEST_F(transformTest, case028) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case028.json"));
 }
 
-// 
+// $lowercase(Español)
 TEST_F(transformTest, case029) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case029.json"));
 }
 
-// 
+// $lowercase($.\"NI.Number\")
 TEST_F(transformTest, case030) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case030.json"));
 }
 
-// 
+// $lowercase(\"COMPENSATION IS : \" & Employment.\"Executive.Compensation\")
 TEST_F(transformTest, case031) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case031.json"));
 }
 
-// 
+// \"Hello\"
 TEST_F(transformTest, case032) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case032.json"));
 }
 
-// 
+// $uppercase(Salutation)
 TEST_F(transformTest, case033) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case033.json"));
 }
 
-// 
+// $uppercase(\"Hello World\")
 TEST_F(transformTest, case034) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case034.json"));
 }
 
-// 
+// $uppercase(\"鯵噂ソ竹\")
 TEST_F(transformTest, case035) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case035.json"));
 }
 
-// 
+// Employment.Name & \" is happy\"
 TEST_F(transformTest, case036) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case036.json"));
 }
 
-// 
+// Employment.Name & \" is pleased to employ \" & Salutation & \" \" & Surname
 TEST_F(transformTest, case037) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case037.json"));
 }
 
-// 
+// $uppercase(\"Hello \" & Salutation & \" \" & Surname)
 TEST_F(transformTest, case038) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case038.json"));
 }
 
-// 
+// $uppercase(Salutation & \" \" & Surname & \" - has \" & Cars & \" registered cars\")
 TEST_F(transformTest, case039) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case039.json"));
 }
 
-// 
+// $uppercase(Employment.ContractType)
 TEST_F(transformTest, case040) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case040.json"));
 }
 
-// 
+// $substringBefore(\"Hola\", \"l\")
 TEST_F(transformTest, case041) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case041.json"));
 }
 
-// 
+// $substringBefore(\"Hola\", 'l')
 TEST_F(transformTest, case042) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case042.json"));
 }
 
-// 
+// $substringBefore(\"Hola\", \"Q\")
 TEST_F(transformTest, case043) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case043.json"));
 }
 
-// 
+// $substringBefore(\"Hola\", \"\")
 TEST_F(transformTest, case044) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case044.json"));
 }
 
-// 
+// $substringBefore(\"鯵噂ソ竹\", \"ソ\")
 TEST_F(transformTest, case045) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case045.json"));
 }
 
-// 
+// $substringAfter(\"Coca\" & \"Cola\", \"ca\")
 TEST_F(transformTest, case046) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case046.json"));
 }
 
-// 
+// $substringAfter(Salutation & \" \" & MiddleName &\" \" & Surname, MiddleName)
 TEST_F(transformTest, case047) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case047.json"));
 }
 
-// 
+// $substringAfter(Salutation & \" \" & Employment.Role, Salutation)
 TEST_F(transformTest, case048) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case048.json"));
 }
 
-// 
+// $substringAfter(\"Hola\", 'l')
 TEST_F(transformTest, case049) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case049.json"));
 }
 
-// 
+// $substringAfter(\"Hola\", \"Q\")
 TEST_F(transformTest, case050) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case050.json"));
 }
 
-// 
+// $lowercase(Employment.Role) & \" (\" & Employment.Role & \")\"
 TEST_F(transformTest, case051) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case051.json"));
 }
 
-// 
+// Employment.Years & \" years of employment\"
 TEST_F(transformTest, case052) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case052.json"));
 }
 
-// 
+// $uppercase(Salutation & \" \" & Surname & \" - has \" & Employment.Years & \" years of employment\")
 TEST_F(transformTest, case053) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case053.json"));
 }
 
-// 
+// $substring(Employment.Role, 7,4)
 TEST_F(transformTest, case054) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case054.json"));
 }
 
-// 
+// $substring(Employment.Role, -4,4)
 TEST_F(transformTest, case055) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case055.json"));
 }
 
-// 
+// $substring(\"Hello World\",Cars,5)
 TEST_F(transformTest, case056) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case056.json"));
 }
 
-// 
+// $lowercase(\"Missing close brackets\"
 TEST_F(transformTest, case057) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case057.json"));
 }
 
-// 
+// $unknown(Salutation)
 TEST_F(transformTest, case058) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case058.json"));
 }
 
-// 
+// $decrypt(Salutation)
 TEST_F(transformTest, case059) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case059.json"));
 }
 
-// 
+// Employment.authentication(Salutation)
 TEST_F(transformTest, case060) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case060.json"));
 }
 
-// 
+// $uppercase(Invalid)
 TEST_F(transformTest, case061) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case061.json"));
 }
 
-// 
+// $uppercase(Employment.Invalid)
 TEST_F(transformTest, case062) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case062.json"));
 }
 
-// 
+// $lowercase(\"Coca\", \"Cola\")
 TEST_F(transformTest, case063) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case063.json"));
 }
 
-// 
+// $lowercase(Salary)
 TEST_F(transformTest, case064) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case064.json"));
 }
 
-// 
+// $lowercase(20)
 TEST_F(transformTest, case065) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case065.json"));
 }
 
-// 
+// $lowercase(20.55)
 TEST_F(transformTest, case066) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case066.json"));
 }
 
-// 
+// $lowercase(Employment)
 TEST_F(transformTest, case067) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case067.json"));
 }
 
-// 
+// $lowercase(Qualifications)
 TEST_F(transformTest, case068) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case068.json"));
 }
 
-// 
+// $uppercase(\"Coca\", \"Cola\")
 TEST_F(transformTest, case069) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case069.json"));
 }
 
-// 
+// $uppercase(Salary)
 TEST_F(transformTest, case070) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case070.json"));
 }
 
-// 
+// $uppercase(28)
 TEST_F(transformTest, case071) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case071.json"));
 }
 
-// 
+// $uppercase(20.55)
 TEST_F(transformTest, case072) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case072.json"));
 }
 
-// 
+// $uppercase(Cars)
 TEST_F(transformTest, case073) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case073.json"));
 }
 
-// 
+// $uppercase(Employment)
 TEST_F(transformTest, case074) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case074.json"));
 }
 
-// 
+// $uppercase(Qualifications)
 TEST_F(transformTest, case075) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case075.json"));
 }
 
-// 
+// $substringBefore(\"Coca\" & \"ca\")
 TEST_F(transformTest, case076) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case076.json"));
 }
 
-// 
+// $substringBefore(Salary,\"xx\")
 TEST_F(transformTest, case077) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case077.json"));
 }
 
-// 
+// $substringBefore(22,\"xx\")
 TEST_F(transformTest, case078) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case078.json"));
 }
 
-// 
+// $substringBefore(22.55,\"xx\")
 TEST_F(transformTest, case079) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case079.json"));
 }
 
-// 
+// $substringBefore(\"22\",2)
 TEST_F(transformTest, case080) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case080.json"));
 }
 
-// 
+// $substringBefore(\"22.55\",5)
 TEST_F(transformTest, case081) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case081.json"));
 }
 
-// 
+// $substringBefore(Employment,\"xx\")
 TEST_F(transformTest, case082) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case082.json"));
 }
 
-// 
+// $substringBefore(Qualifications,\"xx\")
 TEST_F(transformTest, case083) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case083.json"));
 }
 
-// 
+// $substringAfter(\"Coca\" & \"ca\")
 TEST_F(transformTest, case084) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case084.json"));
 }
 
-// 
+// $substringAfter(Salary,\"xx\")
 TEST_F(transformTest, case085) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case085.json"));
 }
 
-// 
+// $substringAfter(22,\"xx\")
 TEST_F(transformTest, case086) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case086.json"));
 }
 
-// 
+// $substringAfter(22.55,\"xx\")
 TEST_F(transformTest, case087) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case087.json"));
 }
 
-// 
+// $substringAfter(\"22\",2)
 TEST_F(transformTest, case088) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case088.json"));
 }
 
-// 
+// $substringAfter(\"22.55\",5)
 TEST_F(transformTest, case089) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case089.json"));
 }
 
-// 
+// $substringAfter(Employment,\"xx\")
 TEST_F(transformTest, case090) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case090.json"));
 }
 
-// 
+// $substringAfter(Qualifications,\"xx\")
 TEST_F(transformTest, case091) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case091.json"));
 }
 
-// 
+// $substring(\"Coca\" & \"ca\", 2, 4, 5)
 TEST_F(transformTest, case092) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case092.json"));
 }
 
-// 
+// $substring(\"Coca\", \"Mr\", 4)
 TEST_F(transformTest, case093) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case093.json"));
 }
 
-// 
+// $substring(\"Coca\", 3, \"Whoops\")
 TEST_F(transformTest, case094) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case094.json"));
 }
 
-// 
+// $substring(Salary,2,4)
 TEST_F(transformTest, case095) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case095.json"));
 }
 
-// 
+// $substring(\"Hello\",\"World\",5)
 TEST_F(transformTest, case096) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case096.json"));
 }
 
-// 
+// $substring(\"Hello\",5,\"World\")
 TEST_F(transformTest, case097) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case097.json"));
 }
 
-// 
+// $substring(\"Hello World\",5.5,5)
 TEST_F(transformTest, case098) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case098.json"));
 }
 
-// 
+// $substring(Employment,\"xx\")
 TEST_F(transformTest, case099) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case099.json"));
 }
 
-// 
+// $substring(Qualifications,6,5)
 TEST_F(transformTest, case100) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case100.json"));
 }
 
-// 
+// detail.contents
 TEST_F(transformTest, case101) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case101.json"));
 }
 
-// 
+// detail.meta
 TEST_F(transformTest, case102) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case102.json"));
 }
 
-// 
+// detail.meta
 TEST_F(transformTest, case103) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transform/case103.json"));
 }
diff --git a/test/gen/transformsTest.cpp b/test/gen/transformsTest.cpp
index 7197399..fcbef0a 100644
--- a/test/gen/transformsTest.cpp
+++ b/test/gen/transformsTest.cpp
@@ -6,77 +6,77 @@ using namespace jsonata;
 class transformsTest : public JsonataTest {
 };
 
-// 
+// $ ~> |Account.Order.Product|{\"Total\":Price*Quantity},[\"Description\", \"SKU\"]|
 TEST_F(transformsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case000.json"));
 }
 
-// 
+// Account.Order ~> |Product|{\"Total\":Price*Quantity},[\"Description\", \"SKU\"]|
 TEST_F(transformsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case001.json"));
 }
 
-// 
+// $ ~> |Account.Order.Product|{\"Total\":Price*Quantity, \"Price\": Price * 1.2}|
 TEST_F(transformsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case002.json"));
 }
 
-// 
+// $ ~> |Account.Order.Product|{},\"Description\"|
 TEST_F(transformsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case003.json"));
 }
 
-// 
+// $ ~> |Account.Order.Product|nomatch,\"Description\"|
 TEST_F(transformsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case004.json"));
 }
 
-// 
+// $ ~> |(Account.Order.Product)[0]|{\"Description\":\"blah\"}|
 TEST_F(transformsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case005.json"));
 }
 
-// 
+// $ ~> |foo.bar|{\"Description\":\"blah\"}|
 TEST_F(transformsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case006.json"));
 }
 
-// 
+// Account ~> |Order|{\"Product\":\"blah\"},nomatch|
 TEST_F(transformsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case007.json"));
 }
 
-// 
+// foo ~> |foo.bar|{\"Description\":\"blah\"}|
 TEST_F(transformsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case008.json"));
 }
 
-// 
+// Account ~> |Order|5|
 TEST_F(transformsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case009.json"));
 }
 
-// 
+// Account ~> |Order|{},5|
 TEST_F(transformsTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case010.json"));
 }
 
-// 
+// Account ~> |Order|{\"Product\":\"blah\"},nomatch|
 TEST_F(transformsTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case011.json"));
 }
 
-// 
+// {} ~> |$|['one', 'two', 'three']|
 TEST_F(transformsTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case012.json"));
 }
 
-// 
+// $ ~> | ** ['hi'] | {'hello': hi}, ['hi'] |
 TEST_F(transformsTest, case013) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case013.json"));
 }
 
-// 
+// $ ~> | ** [hi] | {'hello': hi}, ['hi'] |
 TEST_F(transformsTest, case014) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/transforms/case014.json"));
 }
diff --git a/test/gen/variablesTest.cpp b/test/gen/variablesTest.cpp
index a0f07f4..3ceff4f 100644
--- a/test/gen/variablesTest.cpp
+++ b/test/gen/variablesTest.cpp
@@ -6,67 +6,67 @@ using namespace jsonata;
 class variablesTest : public JsonataTest {
 };
 
-// 
+// $price.foo.bar
 TEST_F(variablesTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case000.json"));
 }
 
-// 
+// $price.foo.bar
 TEST_F(variablesTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case001.json"));
 }
 
-// 
+// $var[1]
 TEST_F(variablesTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case002.json"));
 }
 
-// 
+// $.foo.bar
 TEST_F(variablesTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case003.json"));
 }
 
-// 
+// $a := 5
 TEST_F(variablesTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case004.json"));
 }
 
-// 
+// $a := $b := 5
 TEST_F(variablesTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case005.json"));
 }
 
-// 
+// ($a := $b := 5; $a)
 TEST_F(variablesTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case006.json"));
 }
 
-// 
+// ($a := $b := 5; $b)
 TEST_F(variablesTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case007.json"));
 }
 
-// 
+// ( $a := 5; $a := $a + 2; $a )
 TEST_F(variablesTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case008.json"));
 }
 
-// 
+// [1,2,3].$v
 TEST_F(variablesTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case009.json"));
 }
 
-// 
+// ( $foo := \"defined\"; ( $foo := nothing ); $foo )
 TEST_F(variablesTest, case010) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case010.json"));
 }
 
-// 
+// ( $foo := \"defined\"; ( $foo := nothing; $foo ) )
 TEST_F(variablesTest, case011) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case011.json"));
 }
 
-// 
+// ($a := [1,2]; $a[1]:=3; $a)
 TEST_F(variablesTest, case012) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/variables/case012.json"));
 }
diff --git a/test/gen/wildcardsTest.cpp b/test/gen/wildcardsTest.cpp
index 5e485ca..5dfeb9c 100644
--- a/test/gen/wildcardsTest.cpp
+++ b/test/gen/wildcardsTest.cpp
@@ -6,52 +6,52 @@ using namespace jsonata;
 class wildcardsTest : public JsonataTest {
 };
 
-// 
+// foo.*
 TEST_F(wildcardsTest, case000) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case000.json"));
 }
 
-// 
+// foo.*.baz
 TEST_F(wildcardsTest, case001) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case001.json"));
 }
 
-// 
+// foo.*.bazz
 TEST_F(wildcardsTest, case002) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case002.json"));
 }
 
-// 
+// foo.*.baz.*
 TEST_F(wildcardsTest, case003) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case003.json"));
 }
 
-// 
+// foo.*.baz.*
 TEST_F(wildcardsTest, case004) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case004.json"));
 }
 
-// 
+// foo.*.baz.*
 TEST_F(wildcardsTest, case005) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case005.json"));
 }
 
-// 
+// *[type=\"home\"]
 TEST_F(wildcardsTest, case006) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case006.json"));
 }
 
-// 
+// Account[$$.Account.\"Account Name\" = \"Firefly\"].*[OrderID=\"order104\"].Product.Price
 TEST_F(wildcardsTest, case007) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case007.json"));
 }
 
-// 
+// Account[$$.Account.`Account Name` = \"Firefly\"].*[OrderID=\"order104\"].Product.Price
 TEST_F(wildcardsTest, case008) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case008.json"));
 }
 
-// 
+// *
 TEST_F(wildcardsTest, case009) {
     EXPECT_NO_THROW(runCase("jsonata/test/test-suite/groups/wildcards/case009.json"));
 }

From 3aa10317c4ac40a675e3c6034cf762ece28c001b Mon Sep 17 00:00:00 2001
From: wim delvaux <wim.delvaux@adaptiveplanet.com>
Date: Sun, 17 May 2026 03:30:45 +0200
Subject: [PATCH 5/7] working version of new jsonata that supports any backend

---
 CMakeLists.txt                      |  14 +++-
 include/jsonata/backend.h           | 122 +++++++++++++++++++---------
 include/jsonata/common_backend.h    |  20 +++++
 include/jsonata/nlohmann_backend.h  |  43 ++++++----
 include/jsonata/qtjson_backend.h    |  53 ++++--------
 include/jsonata/qtvariant_backend.h |  53 ++++--------
 src/jsonata/Jsonata.cpp             |   7 ++
 test/JsonataTest.cpp                |   2 +-
 8 files changed, 178 insertions(+), 136 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1347fd7..08655f0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,7 +33,7 @@ endif()
 find_package(Qt6 QUIET COMPONENTS Core)
 if(Qt6_FOUND)
     list( APPEND JSONATA_ENABLED_BACKENDS QJsonValue QVariant )
-    set( JSONATA_QT_ENABLED true )
+   set( JSONATA_QT_ENABLED true )
 else()
     warning( "Cannot find Qt >=6.10." )
 endif()
@@ -158,6 +158,12 @@ if(JSONATA_BUILD_TESTS)
         JSONATA_TEST_BACKEND=${FIRST_BACKEND}
     )
 
+    if(WIN32)
+        set_target_properties(qgenerate PROPERTIES
+            WIN32_EXECUTABLE FALSE
+        )
+    endif()
+
     foreach( BE IN LISTS JSONATA_ENABLED_BACKENDS )
         # 1. Strip the extension to create a clean executable name
         string(REPLACE "::" "_" CLEAN_BE ${BE})
@@ -180,6 +186,12 @@ if(JSONATA_BUILD_TESTS)
             gtest
             Threads::Threads
         )
+        if(WIN32)
+            set_target_properties(${EXE_NAME} PROPERTIES
+                WIN32_EXECUTABLE FALSE
+            )
+        endif()
+
     endforeach()
 
 
diff --git a/include/jsonata/backend.h b/include/jsonata/backend.h
index 11a37dc..14be011 100644
--- a/include/jsonata/backend.h
+++ b/include/jsonata/backend.h
@@ -145,6 +145,15 @@ namespace jsonata
     template<typename T>
     struct backend;
 
+    template <typename T>
+    struct isBackend : std::false_type {};
+
+    template <typename T>
+    struct isBackend<backend<T>> : std::true_type {};
+
+    template <typename T>
+    inline constexpr bool isBackend_v = isBackend<T>::value;
+
     // test to see of type T is of the form backend<X>
     template<typename T>
     struct extractBackendType
@@ -217,8 +226,19 @@ namespace jsonata
                 val.emplace(json_bridge<BaseT>::create(std::forward<U>(value)));
             }
 
-            operator T &() { return *val; }
-            operator const T &() const { return *val; }
+            operator T &() {
+                if( ! val ) {
+                    val.emplace();
+                }
+                return *val;
+            }
+
+            operator const T &() const {
+                if( ! val ) {
+                    val.emplace();
+                }
+                return *val;
+            }
 
             // to unwrap explicitely
             template<typename Self>
@@ -249,7 +269,7 @@ namespace jsonata
             bool isEmpty() const
                 requires isReadCompatible<BaseT>
             {
-                return val && json_bridge<BaseT>::isEmpty(*val);
+                return ! val || json_bridge<BaseT>::isEmpty(*val);
             }
 
             bool isObject() const
@@ -412,33 +432,73 @@ namespace jsonata
             bool getPropertyValueOfType(const std::string &propertyName, PropT &&propertyValue) const
                 requires isReadCompatible<BaseT>
             {
+
+                using rawPropT = std::decay_t<PropT>;
+
                 if (!val) {
                     return false;
                 }
-                // 1. Detect if we are dealing with a TaggedProperty
-                if constexpr (isTaggedProperty_v<std::decay_t<PropT>>) {
-                    // 2. Extract the backend<T> object of the property and the Tag
-                    using Tag = typename std::decay_t<PropT>::tagType;
 
-                    // make sure if value in TaggedProperty std::optional, that it is initialized
-                    auto *dataPtr = ensureHasValue(propertyValue.value);
-
-                    if (!dataPtr->val) {
-                        // allocate val
-                        dataPtr->val = std::move(json_bridge<BaseT>::create());
+                // Detect if we are dealing with a TaggedProperty (TaggedProperty is always converted to a backend(BaseT)
+                if constexpr (isTaggedProperty_v<rawPropT>) {
+                    // Extract the backend<T> object of the property and the Tag
+                    using Tag = typename rawPropT::tagType;
+                    // return type requested by the property
+                    using objType = typename std::decay_t<decltype( propertyValue.value )>;
+
+                    // local copy of returned value (if any value is returned)
+                    BaseT Buffer;
+
+                    // Repackage buffer to pass tag to the bridge
+                    auto repackaged = TaggedProperty<BaseT, Tag>{Buffer};
+
+                    if( json_bridge<BaseT>::getPropertyValueOfType(*val,
+                                                                   propertyName,
+                                                                   repackaged) ) {
+                        // data returned in repackage
+                        if constexpr (isOptional_v<objType>) {
+                            propertyValue.value.emplace( wrap( std::forward<BaseT>( Buffer )) );
+                        } else {
+                            propertyValue.value.val.emplace(Buffer);
+                        }
+                        return true;
+                    } // else no value
+                    // 2. NEW SECTION: Handling backend<BaseT> or std::optional<backend<BaseT>>
+                }  else if constexpr (isBackend_v<unwrapType_t<rawPropT>>) {
+                    using objType = rawPropT;
+
+                    BaseT Buffer;
+                    // We fetch the raw BaseT (json) first
+                    if (json_bridge<BaseT>::getPropertyValueOfType(*val, propertyName, Buffer)) {
+                        if constexpr (isOptional_v<objType>) {
+                            // Construct the backend wrapper inside the optional
+                            propertyValue.emplace();
+                            // transfer the baseT
+                            propertyValue->val.emplace( std::move(Buffer) );
+                        } else {
+                            // Direct assignment (invokes backend constructor/assignment)
+                            propertyValue.val.emplace( std::move(Buffer) );
+                        }
+                        return true;
                     }
-
-                    // Repackage pointing to the T inside the backend's val pointer
-                    auto repackaged = TaggedProperty<BaseT, Tag>{*(dataPtr->val)};
-
-                    return json_bridge<BaseT>::getPropertyValueOfType(*val,
-                                                                      propertyName,
-                                                                      repackaged);
                 } else {
-                    auto *dataPtr = ensureHasValue(propertyValue);
-                    // Standard case for simple types
-                    return json_bridge<BaseT>::getPropertyValueOfType(*val, propertyName, *dataPtr);
+                    using objType = typename std::decay_t<decltype( propertyValue )>;
+                    // get base type
+                    using baseType = unwrapType_t< std::remove_cvref_t<decltype( propertyValue )> >;
+
+                    baseType Buffer;
+
+                    if( json_bridge<BaseT>::getPropertyValueOfType(*val, propertyName, Buffer) ) {
+                        // data returned in repackage
+                        if constexpr (isOptional_v<objType>) {
+                            propertyValue.emplace( std::forward<baseType>( Buffer ) );
+                        } else {
+                            propertyValue = std::move(Buffer);
+                        }
+                        return true;
+                    }
                 }
+                return false;
             }
 
             void push_back(auto value)
@@ -491,21 +551,7 @@ namespace jsonata
             }
 
         private:
-            std::optional<BaseT> val;
-
-            template<typename AT>
-            static auto *ensureHasValue(AT &obj)
-            {
-                // If it's an optional, make sure it has a value
-                if constexpr (isOptional_v<AT>) {
-                    if (!obj.has_value()) {
-                        obj.emplace(); // Construct the data  inside the optional
-                    }
-                    return &(*obj);
-                } else {
-                    return &obj; // It's already a raw backend
-                }
-            }
+            mutable std::optional<BaseT> val;
 
             // Helper to wrap the result of doAt
             static auto wrap(auto &&result)
diff --git a/include/jsonata/common_backend.h b/include/jsonata/common_backend.h
index 726c65d..061409a 100644
--- a/include/jsonata/common_backend.h
+++ b/include/jsonata/common_backend.h
@@ -66,4 +66,24 @@ struct isOptional<std::optional<U>> : std::true_type {};
 template<typename T>
 inline constexpr bool isOptional_v = isOptional<std::decay_t<T>>::value;
 
+//
+// given a type T of either std::optional<X> or X, extract X
+//
+
+// 1. The "Default" case: If it's not an optional, just return the type itself.
+template <typename T>
+struct unwrapType {
+        using type = T;
+};
+
+// 2. The "Special" case: If it IS an optional, extract the inner value_type.
+template <typename T>
+struct unwrapType<std::optional<T>> {
+        using type = T;
+};
+
+// Helper alias to keep your code clean
+template <typename T>
+using unwrapType_t = typename unwrapType<T>::type;
+
 
diff --git a/include/jsonata/nlohmann_backend.h b/include/jsonata/nlohmann_backend.h
index dd5c780..d55ed78 100644
--- a/include/jsonata/nlohmann_backend.h
+++ b/include/jsonata/nlohmann_backend.h
@@ -36,7 +36,7 @@ struct json_bridge_impl<T,void>
             if constexpr (std::is_same_v<V, std::nullptr_t>) {
                 return BaseT();
             } else if constexpr (std::is_constructible_v<T, V>) {
-                return BaseT(value);
+                return value;
             } else {
                 static_assert(false, "Unsupported type for nlohmann creation");
             }
@@ -162,7 +162,14 @@ struct json_bridge_impl<T,void>
             auto convertor = [&](auto E, auto &Prop) {
                 using EType = std::decay_t<decltype(E)>; // This is the type of E
 
-                if constexpr (std::is_base_of_v<std::string, propertyType>) {
+                if constexpr ( isTaggedProperty_v<propertyType> ) {
+                    // special conversion -> Array
+                    if (E.is_array()) {
+                        propertyValue.value = E;
+                        return true;
+                    }
+                    return false;
+                } else if constexpr (std::is_base_of_v<std::string, propertyType>) {
                     // property must be string
                     if (E.is_string()) {
                         Prop = E.template get<std::string>();
@@ -188,21 +195,21 @@ struct json_bridge_impl<T,void>
             return (overrideIt != root.end()) ? convertor((*overrideIt), propertyValue) : false;
         }
 
-        static bool getPropertyValueOfType(const BaseT &root,
-                                           const std::string &propertyName,
-                                           TaggedProperty<T,AsArray> propertyValue)
-        {
-            auto convertor = [&](auto E, TaggedProperty<T,AsArray> Prop) {
-                using EType = std::decay_t<decltype(E)>; // This is the type of E
-                if (E.is_array()) {
-                    Prop.value = E;
-                    return true;
-                }
-                return false;
-            };
-
-            auto overrideIt = root.find(propertyName);
-            return (overrideIt != root.end()) ? convertor((*overrideIt), propertyValue) : false;;
-        }
+        // static bool getPropertyValueOfType(const BaseT &root,
+        //                                    const std::string &propertyName,
+        //                                    TaggedProperty<T,AsArray> propertyValue)
+        // {
+        //     auto convertor = [&](auto E, TaggedProperty<T,AsArray> Prop) {
+        //         using EType = std::decay_t<decltype(E)>; // This is the type of E
+        //         if (E.is_array()) {
+        //             Prop.value = E;
+        //             return true;
+        //         }
+        //         return false;
+        //     };
+
+        //     auto overrideIt = root.find(propertyName);
+        //     return (overrideIt != root.end()) ? convertor((*overrideIt), propertyValue) : false;;
+        // }
 };
 }
\ No newline at end of file
diff --git a/include/jsonata/qtjson_backend.h b/include/jsonata/qtjson_backend.h
index c9ad99a..9441a23 100644
--- a/include/jsonata/qtjson_backend.h
+++ b/include/jsonata/qtjson_backend.h
@@ -46,7 +46,7 @@ struct json_bridge_impl<QJsonValue,void>
             else if constexpr (std::is_floating_point_v<V>) {
                 return QJsonValue(static_cast<double>(value));
             } else if constexpr (std::is_constructible_v<QJsonValue, V>) {
-                return QJsonValue(value);
+                return value;
             } else {
                 static_assert(false, "Unsupported type for QJsonValue creation");
             }
@@ -244,67 +244,42 @@ struct json_bridge_impl<QJsonValue,void>
 
         static std::string dump(const QJsonValue &v)
         {
-            return QString::fromUtf8(QJsonValue(v).toJson()).toStdString();
+            return QString::fromUtf8(QJsonValue(v).toJson(QJsonValue::JsonFormat::Compact)).toStdString();
         }
 
         static QJsonValue parse(const std::string &s)
         {
-            auto decodeUtfChars = [](const std::string &stdStr) -> QString {
-                QString str = QString::fromStdString(stdStr);
-
-                // Regex to find \u followed by 4 hex digits
+            auto unescape = [](QString & input ) {
+                // Match \u followed by 4 hex digits
                 static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
+                QRegularExpressionMatchIterator i = re.globalMatch(input);
 
-                QRegularExpressionMatchIterator i = re.globalMatch(str);
                 int offset = 0;
-
                 while (i.hasNext()) {
                     QRegularExpressionMatch match = i.next();
-
-                    // Get the 4 hex digits (e.g., "D800")
                     bool ok;
                     ushort code = match.captured(1).toUShort(&ok, 16);
 
                     if (ok) {
-                        // Convert hex to a single UTF-16 character (even if it's a lone surrogate)
                         QString replacement = QChar(code);
-
-                        // Replace the "\uD800" text with the actual character
-                        str.replace(match.capturedStart() + offset,
-                                    match.capturedLength(),
-                                    replacement);
-
-                        // Adjust offset because we replaced 6 chars ("\uD800") with 1 char
+                        input.replace(match.capturedStart() + offset, match.capturedLength(), replacement);
+                        // Adjust offset because the string length changed
                         offset += (replacement.length() - match.capturedLength());
                     }
                 }
-                return str;
             };
 
-            auto isValidUtf = [](const QString &str) -> bool {
-                for (int i = 0; i < str.length(); ++i) {
-                    if (str[i].isHighSurrogate()) {
-                        // Must be followed by a low surrogate
-                        if (i + 1 >= str.length() || !str[i + 1].isLowSurrogate()) {
-                            return false; // Error: Unpaired high surrogate
-                        }
-                        i++; // Skip the low surrogate as we've validated the pair
-                    } else if (str[i].isLowSurrogate()) {
-                        // If we hit a low surrogate here, it means it wasn't
-                        // preceded by a high surrogate (which would have triggered the 'if' above)
-                        return false; // Error: Orphaned low surrogate
-                    }
-                }
-                return true;
-            };
+            QString str = QString::fromStdString( s );
+            unescape( str );
 
-            QJsonParseError Err;
-            QString S = decodeUtfChars(s);
-            if (!isValidUtf(S)) {
+            QUtf8StringView sv( str.toUtf8().data() );
+
+            if( ! sv.isValidUtf8() ) {
                 throw jsonata::JException("D3141", 0);
             }
 
-            auto r = QJsonValue::fromJson(s.data(), &Err);
+            QJsonParseError Err;
+            auto r = QJsonValue::fromJson(str.toUtf8(), &Err);
             if (Err.error != QJsonParseError::NoError) {
                 throw jsonata::JException("D3141", Err.offset, Err.errorString().data());
             }
diff --git a/include/jsonata/qtvariant_backend.h b/include/jsonata/qtvariant_backend.h
index 534e89a..97b7e8e 100644
--- a/include/jsonata/qtvariant_backend.h
+++ b/include/jsonata/qtvariant_backend.h
@@ -45,7 +45,7 @@ namespace jsonata
                 else if constexpr (std::is_floating_point_v<V>) {
                     return QVariant(static_cast<double>(value));
                 } else if constexpr (std::is_constructible_v<QVariant, V>) {
-                    return QVariant(value);
+                    return value;
                 } else {
                     static_assert(false, "Unsupported type for QVariant creation");
                 }
@@ -276,67 +276,42 @@ namespace jsonata
 
             static std::string dump(const QVariant &v)
             {
-                return QString::fromUtf8(QJsonValue::fromVariant(v).toJson()).toStdString();
+                return QString::fromUtf8(QJsonValue::fromVariant(v).toJson(QJsonValue::JsonFormat::Compact)).toStdString();
             }
 
             static QVariant parse(const std::string &s)
             {
-                auto decodeUtfChars = [](const std::string &stdStr) -> QString {
-                    QString str = QString::fromStdString(stdStr);
-
-                    // Regex to find \u followed by 4 hex digits
+                auto unescape = [](QString & input ) {
+                    // Match \u followed by 4 hex digits
                     static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
+                    QRegularExpressionMatchIterator i = re.globalMatch(input);
 
-                    QRegularExpressionMatchIterator i = re.globalMatch(str);
                     int offset = 0;
-
                     while (i.hasNext()) {
                         QRegularExpressionMatch match = i.next();
-
-                        // Get the 4 hex digits (e.g., "D800")
                         bool ok;
                         ushort code = match.captured(1).toUShort(&ok, 16);
 
                         if (ok) {
-                            // Convert hex to a single UTF-16 character (even if it's a lone surrogate)
                             QString replacement = QChar(code);
-
-                            // Replace the "\uD800" text with the actual character
-                            str.replace(match.capturedStart() + offset,
-                                        match.capturedLength(),
-                                        replacement);
-
-                            // Adjust offset because we replaced 6 chars ("\uD800") with 1 char
+                            input.replace(match.capturedStart() + offset, match.capturedLength(), replacement);
+                            // Adjust offset because the string length changed
                             offset += (replacement.length() - match.capturedLength());
                         }
                     }
-                    return str;
                 };
 
-                auto isValidUtf = [](const QString &str) -> bool {
-                    for (int i = 0; i < str.length(); ++i) {
-                        if (str[i].isHighSurrogate()) {
-                            // Must be followed by a low surrogate
-                            if (i + 1 >= str.length() || !str[i + 1].isLowSurrogate()) {
-                                return false; // Error: Unpaired high surrogate
-                            }
-                            i++; // Skip the low surrogate as we've validated the pair
-                        } else if (str[i].isLowSurrogate()) {
-                            // If we hit a low surrogate here, it means it wasn't
-                            // preceded by a high surrogate (which would have triggered the 'if' above)
-                            return false; // Error: Orphaned low surrogate
-                        }
-                    }
-                    return true;
-                };
+                QString str = QString::fromStdString( s );
+                unescape( str );
 
-                QJsonParseError Err;
-                QString S = decodeUtfChars(s);
-                if (!isValidUtf(S)) {
+                QUtf8StringView sv( str.toUtf8().data() );
+
+                if( ! sv.isValidUtf8() ) {
                     throw jsonata::JException("D3141", 0);
                 }
 
-                auto r = QJsonValue::fromJson(s.data(), &Err);
+                QJsonParseError Err;
+                auto r = QJsonValue::fromJson(str.toUtf8(), &Err);
                 if (Err.error != QJsonParseError::NoError) {
                     throw jsonata::JException("D3141", Err.offset, Err.errorString().data());
                 }
diff --git a/src/jsonata/Jsonata.cpp b/src/jsonata/Jsonata.cpp
index 06784a9..055174b 100644
--- a/src/jsonata/Jsonata.cpp
+++ b/src/jsonata/Jsonata.cpp
@@ -228,6 +228,9 @@ std::any Jsonata::_evaluate(std::shared_ptr<Parser::Symbol> expr,
         result = std::any{};
     }
 
+    std::cout << "RRRRRRRRRRR" << Jsonata::fromAny<QVariant>(result).dump() << std::endl;
+
+
     // Apply predicates if present - matches Java lines 210-213
     if (!expr->predicate.empty()) {
         for (const auto& pred : expr->predicate) {
@@ -603,7 +606,9 @@ std::any Jsonata::evaluateFunctionWithContext(
 
     // Then add the regular arguments
     for (const auto& arg : expr->arguments) {
+        // std::cout << "XXXXXXXXXXXXX" << Jsonata::fromAny<QVariant>(arg).dump() << std::endl;
         auto argValue = evaluate(arg, input, environment);
+        // std::cout << "VVVVVVVVVVVVVVV" << Jsonata::fromAny<QVariant>(arg).dump() << std::endl;
         evaluatedArgs.push_back(argValue);
     }
 
@@ -2497,6 +2502,8 @@ std::any Jsonata::evaluate(const std::any anyInput,
         // Clear TLS after evaluation to avoid dangling references
         tls_input_.reset();
         tls_environment_.reset();
+        std::cout << "RRR1" << Jsonata::fromAny<QVariant>(result).dump() << std::endl;
+        std::cout << "RRR2" << Jsonata::fromAny<QVariant>(Utils::convertNulls(result)).dump() << std::endl;
         return Utils::convertNulls(result);
     } catch (const std::exception& err) {
         // TODO: populateMessage(err);
diff --git a/test/JsonataTest.cpp b/test/JsonataTest.cpp
index af7784b..8f267b3 100644
--- a/test/JsonataTest.cpp
+++ b/test/JsonataTest.cpp
@@ -475,7 +475,7 @@ namespace jsonata
 
                 overrideObj.getPropertyValueOfType(
                     "alternateResult",
-                    Array(to.alternateResult)
+                    to.alternateResult
                     );
 
                 overrideObj.getPropertyValueOfType(

From 62f3ee803f87592ffe84bf0c6104e124414ec0de Mon Sep 17 00:00:00 2001
From: wim delvaux <wim.delvaux@adaptiveplanet.com>
Date: Mon, 18 May 2026 14:41:26 +0200
Subject: [PATCH 6/7] d

---
 include/jsonata/Jsonata.h | 2 +-
 src/jsonata/Jsonata.cpp   | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/include/jsonata/Jsonata.h b/include/jsonata/Jsonata.h
index 794dee4..262a5e0 100644
--- a/include/jsonata/Jsonata.h
+++ b/include/jsonata/Jsonata.h
@@ -489,7 +489,7 @@ namespace jsonata
             }
 
             template<typename T>
-                requires jsonata::isReadCompatible<T>
+                requires jsonata::isWriteCompatible<T>
             static jsonata::backend<T> fromAny(const std::any &value)
             {
                 if (!value.has_value())
diff --git a/src/jsonata/Jsonata.cpp b/src/jsonata/Jsonata.cpp
index 055174b..47e001e 100644
--- a/src/jsonata/Jsonata.cpp
+++ b/src/jsonata/Jsonata.cpp
@@ -228,8 +228,7 @@ std::any Jsonata::_evaluate(std::shared_ptr<Parser::Symbol> expr,
         result = std::any{};
     }
 
-    std::cout << "RRRRRRRRRRR" << Jsonata::fromAny<QVariant>(result).dump() << std::endl;
-
+    // std::cout << "RRRRRRRRRRR" << Jsonata::fromAny<QVariant>(result).dump() << std::endl;
 
     // Apply predicates if present - matches Java lines 210-213
     if (!expr->predicate.empty()) {

From a4ad6e4856c8714cbebe0830f063febaf542d52d Mon Sep 17 00:00:00 2001
From: wim delvaux <wim.delvaux@adaptiveplanet.com>
Date: Wed, 20 May 2026 14:00:48 +0200
Subject: [PATCH 7/7] seems to work for all supported json formats

---
 CMakeLists.txt                      |   3 +-
 include/jsonata/Functions.h         |   9 +-
 include/jsonata/Jsonata.h           |  26 +-
 include/jsonata/backend.h           |   2 +
 include/jsonata/nlohmann_backend.h  |   2 +
 include/jsonata/ordered_map.h       | 370 ++++++++++++++++++++++++++++
 include/jsonata/qtjson_backend.h    | 111 +++++++--
 include/jsonata/qtvariant_backend.h | 111 +++++++--
 src/jsonata/Functions.cpp           |  63 ++---
 src/jsonata/Jsonata.cpp             | 271 +++++---------------
 src/jsonata/Utils.cpp               |   5 +-
 src/jsonata/utils/Signature.cpp     |   2 +-
 test/JsonataTest.cpp                |   5 +-
 13 files changed, 672 insertions(+), 308 deletions(-)
 create mode 100644 include/jsonata/ordered_map.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 08655f0..9ea9a90 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -151,7 +151,8 @@ if(JSONATA_BUILD_TESTS)
 
     # Create test generator executable
     add_executable(qgenerate test/Generate.cpp
-        include/jsonata/backend.h)
+        include/jsonata/backend.h
+        include/jsonata/ordered_map.h)
     target_link_libraries(qgenerate qjsonata)
     list(GET JSONATA_ENABLED_BACKENDS 0 FIRST_BACKEND)
     target_compile_definitions(qgenerate PRIVATE
diff --git a/include/jsonata/Functions.h b/include/jsonata/Functions.h
index 62d0743..3778e69 100644
--- a/include/jsonata/Functions.h
+++ b/include/jsonata/Functions.h
@@ -27,6 +27,7 @@
 #include <vector>
 
 #include "Utils.h"
+#include "ordered_map.h"
 
 namespace jsonata {
 
@@ -132,7 +133,7 @@ class Functions {
                                           const std::string& char_ = " ");
     static std::optional<std::string> formatNumber(
         double value, const std::string& picture,
-        const std::unordered_map<std::string, std::any>& options = {});
+        const jsonata::ordered_map<std::string, std::any>& options = {});
     static std::any shuffle(const Utils::JList& args);
     static std::any lookup(const std::any& input, const std::string& key);
     static void error(const std::string& message);
@@ -194,7 +195,7 @@ class Functions {
             : implementation(impl), signature(sig) {}
     };
 
-    static std::unordered_map<std::string, FunctionEntry>
+    static jsonata::ordered_map<std::string, FunctionEntry>
     getFunctionRegistry();
     static std::any applyFunction(const std::string& name,
                                   const Utils::JList& args);
@@ -232,7 +233,7 @@ class Functions {
     static std::string safeReplaceAllFn(const std::string& str,
                                         const std::regex& pattern,
                                         const std::any& func);
-    static std::unordered_map<std::string, std::any> toJsonataMatch(
+    static jsonata::ordered_map<std::string, std::any> toJsonataMatch(
         const std::smatch& match);
     static std::string encodeURI(const std::string& uri);
     static std::string leftPad(const std::string& str, int64_t size,
@@ -256,7 +257,7 @@ class Functions {
     };
 
     static FormatSymbols processOptionsArg(
-        const std::unordered_map<std::string, std::any>& options);
+        const jsonata::ordered_map<std::string, std::any>& options);
     static std::string getFormattingCharacter(const std::string& value,
                                               const std::string& propertyName,
                                               bool isChar);
diff --git a/include/jsonata/Jsonata.h b/include/jsonata/Jsonata.h
index 262a5e0..c2fcf67 100644
--- a/include/jsonata/Jsonata.h
+++ b/include/jsonata/Jsonata.h
@@ -33,6 +33,7 @@
 #include <string>
 #include <vector>
 
+#include "Jsonata/ordered_map.h"
 #include "jsonata/Parser.h"
 #include "Jsonata/backend.h"
 
@@ -60,7 +61,7 @@ namespace jsonata
     {
         private:
             std::shared_ptr<Frame> parent_;
-            std::unordered_map<std::string, std::any> bindings_;
+            jsonata::ordered_map<std::string, std::any> bindings_;
             std::chrono::time_point<std::chrono::steady_clock> timestamp_;
             int64_t timeout_;
             int64_t recursionDepth_;
@@ -91,7 +92,7 @@ namespace jsonata
             std::shared_ptr<Frame> getParent() const { return parent_; }
 
             // Bindings access
-            const std::unordered_map<std::string, std::any> &getBindings() const
+            const jsonata::ordered_map<std::string, std::any> &getBindings() const
             {
                 return bindings_;
             }
@@ -185,21 +186,6 @@ namespace jsonata
                 return evaluate(T(), bindings);
             }
 
-            // Main evaluation methods (ordered JSON variants)
-            // jsonata::ordered_json evaluate(const jsonata::ordered_json &input);
-            // jsonata::ordered_json evaluate(const jsonata::ordered_json &input,
-            //                                         std::shared_ptr<Frame> bindings);
-            // jsonata::ordered_json evaluate(std::nullptr_t);
-            // jsonata::ordered_json evaluate(std::nullptr_t, std::shared_ptr<Frame> bindings);
-
-            // // Main evaluation methods (unordered jsonata::json variants)
-            // jsonata::json evaluate(const jsonata::json &input);
-            // jsonata::json evaluate(const jsonata::json &input,
-            //                                 std::shared_ptr<Frame> bindings);
-            // jsonata::json evaluateUnordered(std::nullptr_t);
-            // jsonata::json evaluateUnordered(std::nullptr_t,
-            //                                          std::shared_ptr<Frame> bindings);
-
             std::any evaluate(std::shared_ptr<Parser::Symbol> expr,
                               const std::any &input,
                               std::shared_ptr<Frame> environment);
@@ -481,7 +467,7 @@ namespace jsonata
                     return out;
                 }
                 if (j.isObject()) {
-                    std::unordered_map<std::string, std::any> m;
+                    jsonata::ordered_map<std::string, std::any> m;
                     jsonata::copy(j, m, [](const T &el) { return toAny(el); });
                     return m;
                 }
@@ -544,10 +530,10 @@ namespace jsonata
                     jsonata::copy(vec, arr, [](const std::any &a) { return fromAny<T>(a); });
                     return arr;
                 }
-                if (type == typeid(std::unordered_map<std::string, std::any>)) {
+                if (type == typeid(jsonata::ordered_map<std::string, std::any>)) {
                     auto obj = jsonata::backend<T>::object();
                     const auto &map = std::
-                        any_cast<const std::unordered_map<std::string, std::any> &>(
+                        any_cast<const jsonata::ordered_map<std::string, std::any> &>(
                             value);
                     jsonata::copy(map, obj, [](const std::any &a) { return fromAny<T>(a); });
                     return obj;
diff --git a/include/jsonata/backend.h b/include/jsonata/backend.h
index 14be011..3daa920 100644
--- a/include/jsonata/backend.h
+++ b/include/jsonata/backend.h
@@ -28,6 +28,7 @@ namespace jsonata
 
     template<typename T>
     concept isBasicallyReadCompatible = requires(const T &ConstObj) {
+        typename json_bridge<T>::sortedPartner;
         json_bridge<T>::forAll(ConstObj, [](const std::string &, auto &) {});
         json_bridge<T>::array();
         json_bridge<T>::object();
@@ -197,6 +198,7 @@ namespace jsonata
     {
             // Use the base type for bridge lookups
             using BaseT = std::remove_cvref_t<T>;
+            using sortedPartner = backend<typename json_bridge<T>::sortedPartner>;
 
             backend() {}
             backend(std::nullptr_t) {}
diff --git a/include/jsonata/nlohmann_backend.h b/include/jsonata/nlohmann_backend.h
index d55ed78..2731d68 100644
--- a/include/jsonata/nlohmann_backend.h
+++ b/include/jsonata/nlohmann_backend.h
@@ -29,6 +29,8 @@ struct json_bridge_impl<T,void>
 {
         using BaseT = std::remove_cvref_t<T>;
         using is_json_bridge_type = void; // Tag to satisfy the concept
+        // all nlohmann have json a sorted version
+        using sortedPartner = nlohmann::json;
 
         static BaseT create(auto&& value) {
             using V = std::decay_t<decltype(value)>;
diff --git a/include/jsonata/ordered_map.h b/include/jsonata/ordered_map.h
new file mode 100644
index 0000000..e58b5cb
--- /dev/null
+++ b/include/jsonata/ordered_map.h
@@ -0,0 +1,370 @@
+// From nlohmann/json adapted for jsonata
+// Refactored to Modern C++23
+
+#pragma once
+
+#include <functional>       // equal_to, less
+#include <initializer_list> // initializer_list
+#include <iterator>         // input_iterator_tag, distance, next, prev
+#include <memory>           // allocator
+#include <type_traits>      // remove_cvref_t, is_same_v, is_convertible_v
+#include <utility>          // pair, move, forward
+#include <vector>           // vector
+#include "JException.h"
+
+namespace jsonata {
+
+    // C++20/23 Concept checking if Compare functor can compare types A and B interchangeably
+    template<typename Compare, typename A, typename B>
+    concept ComparableWith = requires(Compare comp, A&& a, B&& b) {
+        { comp(std::forward<A>(a), std::forward<B>(b)) };
+        { comp(std::forward<B>(b), std::forward<A>(a)) };
+    };
+
+    // Simplified C++23 trait evaluating if a generic type can be safely used as a lookup key
+    template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef,
+             bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator>
+    struct is_usable_as_key_type {
+            using KeyType = std::remove_cvref_t<KeyTypeCVRef>;
+
+            // Mocking nlohmann's internally expected detection traits
+            // (If using nlohmann framework directly, adjust detect_is_transparent checks as needed)
+            static constexpr bool is_transparent = requires { typename Comparator::is_transparent; };
+
+            static constexpr bool value =
+                ComparableWith<Comparator, ObjectKeyType, KeyTypeCVRef> &&
+                !(ExcludeObjectKeyType && std::is_same_v<KeyType, ObjectKeyType>) &&
+                (!RequireTransparentComparator || is_transparent);
+    };
+
+    /// ordered_map: a minimal map-like container that preserves insertion order
+    template <class Key, class T, class IgnoredLess = std::less<Key>,
+             class Allocator = std::allocator<std::pair<const Key, T>>>
+    struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+    {
+            using key_type = Key;
+            using mapped_type = T;
+            using Container = std::vector<std::pair<const Key, T>, Allocator>;
+            using iterator = typename Container::iterator;
+            using const_iterator = typename Container::const_iterator;
+            using size_type = typename Container::size_type;
+            using value_type = typename Container::value_type;
+            using key_compare = std::equal_to<Key>;
+
+            // Default constructors
+            ordered_map() noexcept(noexcept(Container())) : Container{} {}
+            explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
+
+            template <class It>
+            ordered_map(It first, It last, const Allocator& alloc = Allocator())
+                : Container{first, last, alloc} {}
+
+            ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator())
+                : Container{init, alloc} {}
+
+            ordered_map(const ordered_map&) = default;
+            ordered_map(ordered_map&&) noexcept(std::is_nothrow_move_constructible_v<Container>) = default;
+            ~ordered_map() = default;
+
+            ordered_map& operator=(const ordered_map& other)
+            {
+                if (this != &other)
+                {
+                    ordered_map tmp(other);
+                    Container::operator=(std::move(static_cast<Container&>(tmp)));
+                }
+                return *this;
+            }
+
+            ordered_map& operator=(ordered_map&& other) noexcept(std::is_nothrow_move_assignable_v<Container>)
+            {
+                Container::operator=(std::move(static_cast<Container&>(other)));
+                return *this;
+            }
+
+            // Standard Emplace
+            std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return {it, false};
+                    }
+                }
+                Container::emplace_back(key, std::forward<T>(t));
+                return {std::prev(this->end()), true};
+            }
+
+            // C++23 Heterogeneous Emplace using a 'requires' clause constraint
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            std::pair<iterator, bool> emplace(KeyType&& key, T&& t)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return {it, false};
+                    }
+                }
+                Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+                return {std::prev(this->end()), true};
+            }
+
+            // Element Access Operators
+            T& operator[](const key_type& key)
+            {
+                return emplace(key, T{}).first->second;
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            T& operator[](KeyType&& key)
+            {
+                return emplace(std::forward<KeyType>(key), T{}).first->second;
+            }
+
+            const T& operator[](const key_type& key) const
+            {
+                return at(key);
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            const T& operator[](KeyType&& key) const
+            {
+                return at(std::forward<KeyType>(key));
+            }
+
+            // At Methods
+            T& at(const key_type& key)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it->second;
+                    }
+                }
+                throw JException("key not found");
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            T& at(KeyType&& key)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it->second;
+                    }
+                }
+                throw JException("key not found");
+            }
+
+            const T& at(const key_type& key) const
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it->second;
+                    }
+                }
+                throw JException("key not found");
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            const T& at(KeyType&& key) const
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it->second;
+                    }
+                }
+                throw JException("key not found");
+            }
+
+            // Erase Operations
+            size_type erase(const key_type& key)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        for (auto next = it; ++next != this->end(); ++it)
+                        {
+                            it->~value_type();
+                            new (&*it) value_type{std::move(*next)};
+                        }
+                        Container::pop_back();
+                        return 1;
+                    }
+                }
+                return 0;
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            size_type erase(KeyType&& key)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        for (auto next = it; ++next != this->end(); ++it)
+                        {
+                            it->~value_type();
+                            new (&*it) value_type{std::move(*next)};
+                        }
+                        Container::pop_back();
+                        return 1;
+                    }
+                }
+                return 0;
+            }
+
+            iterator erase(iterator pos)
+            {
+                return erase(pos, std::next(pos));
+            }
+
+            iterator erase(iterator first, iterator last)
+            {
+                if (first == last)
+                {
+                    return first;
+                }
+
+                const auto elements_affected = std::distance(first, last);
+                const auto offset = std::distance(Container::begin(), first);
+
+                for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+                {
+                    it->~value_type();
+                    new (&*it) value_type{std::move(*std::next(it, elements_affected))};
+                }
+
+                Container::resize(this->size() - static_cast<size_type>(elements_affected));
+                return Container::begin() + offset;
+            }
+
+            // Count and Find Lookup Operations
+            size_type count(const key_type& key) const
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return 1;
+                    }
+                }
+                return 0;
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            size_type count(KeyType&& key) const
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return 1;
+                    }
+                }
+                return 0;
+            }
+
+            iterator find(const key_type& key)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it;
+                    }
+                }
+                return Container::end();
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            iterator find(KeyType&& key)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it;
+                    }
+                }
+                return Container::end();
+            }
+
+            const_iterator find(const key_type& key) const
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it;
+                    }
+                }
+                return Container::end();
+            }
+
+            template<class KeyType>
+                requires (is_usable_as_key_type<key_compare, key_type, KeyType>::value)
+            const_iterator find(KeyType&& key) const
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, key))
+                    {
+                        return it;
+                    }
+                }
+                return Container::end();
+            }
+
+            // Insert Operations
+            std::pair<iterator, bool> insert(value_type&& value)
+            {
+                return emplace(value.first, std::move(value.second));
+            }
+
+            std::pair<iterator, bool> insert(const value_type& value)
+            {
+                for (auto it = this->begin(); it != this->end(); ++it)
+                {
+                    if (m_compare(it->first, value.first))
+                    {
+                        return {it, false};
+                    }
+                }
+                Container::push_back(value);
+                return {--this->end(), true};
+            }
+
+            // C++20/23 Concept constrained range input insertion instead of require_input_iter traits
+            template<typename InputIt>
+                requires std::is_convertible_v<typename std::iterator_traits<InputIt>::iterator_category, std::input_iterator_tag>
+            void insert(InputIt first, InputIt last)
+            {
+                for (auto it = first; it != last; ++it)
+                {
+                    insert(*it);
+                }
+            }
+
+        private:
+            key_compare m_compare = key_compare();
+    };
+
+} // namespace jsonata
\ No newline at end of file
diff --git a/include/jsonata/qtjson_backend.h b/include/jsonata/qtjson_backend.h
index 9441a23..c7f360e 100644
--- a/include/jsonata/qtjson_backend.h
+++ b/include/jsonata/qtjson_backend.h
@@ -24,6 +24,7 @@ template<>
 struct json_bridge_impl<QJsonValue,void>
 {
         using is_json_bridge_type = void; // Tag to satisfy the concept
+        using sortedPartner = QJsonValue;
 
         static QJsonValue create(auto &&value)
         {
@@ -249,33 +250,101 @@ struct json_bridge_impl<QJsonValue,void>
 
         static QJsonValue parse(const std::string &s)
         {
-            auto unescape = [](QString & input ) {
-                // Match \u followed by 4 hex digits
-                static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
-                QRegularExpressionMatchIterator i = re.globalMatch(input);
-
-                int offset = 0;
-                while (i.hasNext()) {
-                    QRegularExpressionMatch match = i.next();
-                    bool ok;
-                    ushort code = match.captured(1).toUShort(&ok, 16);
+            auto convert = []( const QString & input, QString & ok ) -> QString {
 
-                    if (ok) {
-                        QString replacement = QChar(code);
-                        input.replace(match.capturedStart() + offset, match.capturedLength(), replacement);
-                        // Adjust offset because the string length changed
-                        offset += (replacement.length() - match.capturedLength());
+                auto utf = []( const QStringView & V, qsizetype off, QString & errorCode ) {
+                    bool ok;
+                    ushort code = V.sliced( off, 4 ).toUShort(&ok, 16);
+                    if( ok ) {
+                        return QChar(code);
+                    }
+                    errorCode = "S0104"; // invalid \\u sequence
+                    return QChar();
+                };
+
+                auto validUtfSequence = [utf]( const QStringView & v,
+                                              qsizetype len, qsizetype off, const QString & match, QString & errorCode ) -> qsizetype {
+                    off += match.length();
+                    QChar f = utf( v, off, errorCode );
+                    off += 4;
+                    if( ! errorCode.isEmpty() ) {
+                        return off;
+                    }
+                    if( f.isSurrogate( ) ) {
+                        if( (off + (4+match.length())) >= len || v.sliced( off, match.length() ) != match ) {
+                            errorCode = "S3141"; // invalid utf character sequence
+                            return off;
+                        }
+                        off += match.length();
+                        QChar s = utf( v, off, errorCode );
+                        off += 4;
+                        if( ! errorCode.isEmpty() ) {
+                            return off;
+                        }
+                        if( ! f.isHighSurrogate() || ! s.isLowSurrogate() ) {
+                            errorCode = "S3141"; // invalid utf character sequence
+                            return off;
+                        }
                     }
+                    return off;
+                };
+
+                QString errorCode;
+                QString out;
+                bool dQuoted = false;
+                qsizetype i = 0;
+                QStringView v(input);
+
+                while( i < input.length() ) {
+                    if( input[i] == '\\' ) {
+
+                        if( i+1< input.length() && v.sliced( i, 2 ) == "\\\"" ) {
+                            dQuoted = ! dQuoted;
+                            out += '"';
+                            i += 2;
+                            continue;
+                        }
+
+                        if( dQuoted ) {
+                            if( i+6< input.length() &&  v.sliced( i, 3 ) == "\\\\u" ) {
+                                i = validUtfSequence( v, input.length(), i, "\\\\u", errorCode );
+                                if( ! errorCode.isEmpty() ) {
+                                    break;
+                                }
+                            }
+
+                            if( i+1< input.length() && v.sliced( i, 2 ) == "\\\\" ) {
+                                out += '\\';
+                                i += 2;
+                                continue;
+                            }
+                        } else {
+                            if( i+5< input.length() && v.sliced( i, 2 ) == "\\u" ) {
+                                // start of utf16 char
+                                i = validUtfSequence( v, input.length(), i, "\\u", ok );
+                                if( ! errorCode.isEmpty() ) {
+                                    break;
+                                }
+                            }
+                        }
+
+                        // remove \ will insert next char
+                        i ++;
+                        continue;
+                    }
+
+                    out += input[i];
+                    i ++;
                 }
+                return out;
             };
 
+            QString errorCode;
             QString str = QString::fromStdString( s );
-            unescape( str );
-
-            QUtf8StringView sv( str.toUtf8().data() );
-
-            if( ! sv.isValidUtf8() ) {
-                throw jsonata::JException("D3141", 0);
+            QString convertedStr = convert( str, errorCode );
+            if( ! errorCode.isEmpty() ) {
+                // It's a lone surrogate! (Like your \uD800 test case)
+                throw jsonata::JException( errorCode.toStdString(), 0);
             }
 
             QJsonParseError Err;
diff --git a/include/jsonata/qtvariant_backend.h b/include/jsonata/qtvariant_backend.h
index 97b7e8e..cb1be2f 100644
--- a/include/jsonata/qtvariant_backend.h
+++ b/include/jsonata/qtvariant_backend.h
@@ -23,6 +23,7 @@ namespace jsonata
     struct json_bridge_impl<QVariant,void>
     {
             using is_json_bridge_type = void; // Tag to satisfy the concept
+            using sortedPartner = QVariant;
 
             static QVariant create(auto &&value)
             {
@@ -281,33 +282,101 @@ namespace jsonata
 
             static QVariant parse(const std::string &s)
             {
-                auto unescape = [](QString & input ) {
-                    // Match \u followed by 4 hex digits
-                    static QRegularExpression re("\\\\u([0-9a-fA-F]{4})");
-                    QRegularExpressionMatchIterator i = re.globalMatch(input);
-
-                    int offset = 0;
-                    while (i.hasNext()) {
-                        QRegularExpressionMatch match = i.next();
-                        bool ok;
-                        ushort code = match.captured(1).toUShort(&ok, 16);
+                auto convert = []( const QString & input, QString & ok ) -> QString {
 
-                        if (ok) {
-                            QString replacement = QChar(code);
-                            input.replace(match.capturedStart() + offset, match.capturedLength(), replacement);
-                            // Adjust offset because the string length changed
-                            offset += (replacement.length() - match.capturedLength());
+                    auto utf = []( const QStringView & V, qsizetype off, QString & errorCode ) {
+                        bool ok;
+                        ushort code = V.sliced( off, 4 ).toUShort(&ok, 16);
+                        if( ok ) {
+                            return QChar(code);
+                        }
+                        errorCode = "S0104"; // invalid \\u sequence
+                        return QChar();
+                    };
+
+                    auto validUtfSequence = [utf]( const QStringView & v,
+                                                  qsizetype len, qsizetype off, const QString & match, QString & errorCode ) -> qsizetype {
+                        off += match.length();
+                        QChar f = utf( v, off, errorCode );
+                        off += 4;
+                        if( ! errorCode.isEmpty() ) {
+                            return off;
+                        }
+                        if( f.isSurrogate( ) ) {
+                            if( (off + (4+match.length())) >= len || v.sliced( off, match.length() ) != match ) {
+                                errorCode = "S3141"; // invalid utf character sequence
+                                return off;
+                            }
+                            off += match.length();
+                            QChar s = utf( v, off, errorCode );
+                            off += 4;
+                            if( ! errorCode.isEmpty() ) {
+                                return off;
+                            }
+                            if( ! f.isHighSurrogate() || ! s.isLowSurrogate() ) {
+                                errorCode = "S3141"; // invalid utf character sequence
+                                return off;
+                            }
                         }
+                        return off;
+                    };
+
+                    QString errorCode;
+                    QString out;
+                    bool dQuoted = false;
+                    qsizetype i = 0;
+                    QStringView v(input);
+
+                    while( i < input.length() ) {
+                        if( input[i] == '\\' ) {
+
+                            if( i+1< input.length() && v.sliced( i, 2 ) == "\\\"" ) {
+                                dQuoted = ! dQuoted;
+                                out += '"';
+                                i += 2;
+                                continue;
+                            }
+
+                            if( dQuoted ) {
+                                if( i+6< input.length() &&  v.sliced( i, 3 ) == "\\\\u" ) {
+                                    i = validUtfSequence( v, input.length(), i, "\\\\u", errorCode );
+                                    if( ! errorCode.isEmpty() ) {
+                                        break;
+                                    }
+                                }
+
+                                if( i+1< input.length() && v.sliced( i, 2 ) == "\\\\" ) {
+                                    out += '\\';
+                                    i += 2;
+                                    continue;
+                                }
+                            } else {
+                                if( i+5< input.length() && v.sliced( i, 2 ) == "\\u" ) {
+                                    // start of utf16 char
+                                    i = validUtfSequence( v, input.length(), i, "\\u", ok );
+                                    if( ! errorCode.isEmpty() ) {
+                                        break;
+                                    }
+                                }
+                            }
+
+                            // remove \ will insert next char
+                            i ++;
+                            continue;
+                        }
+
+                        out += input[i];
+                        i ++;
                     }
+                    return out;
                 };
 
+                QString errorCode;
                 QString str = QString::fromStdString( s );
-                unescape( str );
-
-                QUtf8StringView sv( str.toUtf8().data() );
-
-                if( ! sv.isValidUtf8() ) {
-                    throw jsonata::JException("D3141", 0);
+                QString convertedStr = convert( str, errorCode );
+                if( ! errorCode.isEmpty() ) {
+                    // It's a lone surrogate! (Like your \uD800 test case)
+                    throw jsonata::JException( errorCode.toStdString(), 0);
                 }
 
                 QJsonParseError Err;
diff --git a/src/jsonata/Functions.cpp b/src/jsonata/Functions.cpp
index d9f24f6..90cfca1 100644
--- a/src/jsonata/Functions.cpp
+++ b/src/jsonata/Functions.cpp
@@ -24,6 +24,7 @@
 #include <jsonata/utils/Constants.h>
 #include <jsonata/utils/DateTimeUtils.h>
 #include <jsonata/utils/Signature.h>
+#include <jsonata/ordered_map.h>
 #include <utf8.h>
 
 #include <algorithm>
@@ -464,12 +465,12 @@ static bool isDeepEqualForDistinct(const std::any& lhs, const std::any& rhs) {
 
         // Compare direct map objects
         if (lhs.type() ==
-            typeid(std::unordered_map<std::string, std::any>)) {
+            typeid(jsonata::ordered_map<std::string, std::any>)) {
             const auto& leftMap =
-                std::any_cast<std::unordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                     lhs);
             const auto& rightMap =
-                std::any_cast<std::unordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                     rhs);
 
             if (leftMap.size() != rightMap.size()) {
@@ -846,9 +847,9 @@ bool Functions::isLambda(const std::any& value) {
 
 // Deprecated: type-check helpers moved to Utils
 
-std::unordered_map<std::string, Functions::FunctionEntry>
+jsonata::ordered_map<std::string, Functions::FunctionEntry>
 Functions::getFunctionRegistry() {
-    static std::unordered_map<std::string, FunctionEntry>
+    static jsonata::ordered_map<std::string, FunctionEntry>
         registryWithSignatures = {
             // Aggregation functions
             {"sum", FunctionEntry(
@@ -1259,11 +1260,11 @@ Functions::getFunctionRegistry() {
                          (args.size() >= 2 && isString(args[1]))
                              ? std::any_cast<std::string>(args[1])
                              : "";
-                     std::unordered_map<std::string, std::any> options;
+                     jsonata::ordered_map<std::string, std::any> options;
                      if (args.size() >= 3) {
                          try {
                              options = std::any_cast<
-                                 std::unordered_map<std::string, std::any>>(
+                                 jsonata::ordered_map<std::string, std::any>>(
                                  args[2]);
                          } catch (const std::bad_any_cast&) {
                              // Ignore invalid options
@@ -1794,9 +1795,9 @@ std::optional<bool> Functions::toBoolean(const std::any& arg) {
             result = std::any_cast<bool>(arg);
             // Check for map/object
         } else if (arg.type() ==
-                   typeid(std::unordered_map<std::string, std::any>)) {
+                   typeid(jsonata::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const std::unordered_map<std::string, std::any>&>(arg);
+                const jsonata::ordered_map<std::string, std::any>&>(arg);
             result = !map.empty();
         }
         // Functions are falsy
@@ -2187,7 +2188,7 @@ std::any Functions::merge(const Utils::JList& args) {
     }
 
     try {
-        std::unordered_map<std::string, std::any> result;
+        jsonata::ordered_map<std::string, std::any> result;
 
         // Convert to vector if needed
         Utils::JList inputArray;
@@ -2204,9 +2205,9 @@ std::any Functions::merge(const Utils::JList& args) {
                 try {
                     // Handle direct map
                     if (item.type() ==
-                        typeid(std::unordered_map<std::string, std::any>)) {
+                        typeid(jsonata::ordered_map<std::string, std::any>)) {
                         const auto& map =
-                            std::any_cast<const std::unordered_map<
+                            std::any_cast<const jsonata::ordered_map<
                                 std::string, std::any>&>(item);
                         for (const auto& entry : map) {
                             result[entry.first] = entry.second;
@@ -2312,11 +2313,11 @@ std::any Functions::spread(const Utils::JList& args) {
             // Handle object - create an array with one object per key-value
             // pair
         } else if (arg.type() ==
-                   typeid(std::unordered_map<std::string, std::any>)) {
+                   typeid(jsonata::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const std::unordered_map<std::string, std::any>&>(arg);
+                const jsonata::ordered_map<std::string, std::any>&>(arg);
             for (const auto& entry : map) {
-                std::unordered_map<std::string, std::any> obj;
+                jsonata::ordered_map<std::string, std::any> obj;
                 obj[entry.first] = entry.second;
                 result.push_back(obj);
             }
@@ -2347,13 +2348,13 @@ std::any Functions::sift(const Utils::JList& args) {
     }
 
     try {
-        std::unordered_map<std::string, std::any> result;
+        jsonata::ordered_map<std::string, std::any> result;
 
         // Handle direct map
         if (objectArg.type() ==
-            typeid(std::unordered_map<std::string, std::any>)) {
+            typeid(jsonata::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const std::unordered_map<std::string, std::any>&>(objectArg);
+                const jsonata::ordered_map<std::string, std::any>&>(objectArg);
             for (const auto& entry : map) {
                 // Prepare arguments for the predicate function
                 auto funcArgs = hofFuncArgs(predicateArg, entry.second,
@@ -2422,9 +2423,9 @@ void Functions::stringifyInternal(std::ostringstream& os, const std::any& arg,
             if (prettify && !vec.empty()) os << indent;
             os << "]";
         } else if (arg.type() ==
-                   typeid(std::unordered_map<std::string, std::any>)) {
+                   typeid(jsonata::ordered_map<std::string, std::any>)) {
             auto map =
-                std::any_cast<std::unordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                     arg);
             os << "{";
             if (prettify && !map.empty()) os << "\n";
@@ -3005,10 +3006,10 @@ Utils::JList Functions::keys(const std::any& arg) {
                 result.push_back(key);
             }
         } else if (arg.type() ==
-                   typeid(std::unordered_map<std::string, std::any>)) {
+                   typeid(jsonata::ordered_map<std::string, std::any>)) {
             // Java: if (arg instanceof Map) - return keySet
             const auto& map = std::any_cast<
-                const std::unordered_map<std::string, std::any>&>(arg);
+                const jsonata::ordered_map<std::string, std::any>&>(arg);
             for (const auto& [key, value] : map) {
                 result.push_back(key);
             }
@@ -3038,9 +3039,9 @@ std::any Functions::each(const std::any& obj, const std::any& func) {
 
         // Handle direct map<string, any>
         if (obj.type() ==
-            typeid(std::unordered_map<std::string, std::any>)) {
+            typeid(jsonata::ordered_map<std::string, std::any>)) {
             const auto& map = std::any_cast<
-                const std::unordered_map<std::string, std::any>&>(obj);
+                const jsonata::ordered_map<std::string, std::any>&>(obj);
             // Java: for (var key : obj.keySet())
             for (const auto& entry : map) {
                 const std::string& key = entry.first;
@@ -3613,7 +3614,7 @@ std::string Functions::formatScientificNotation(double value,
 
 std::optional<std::string> Functions::formatNumber(
     double value, const std::string& picture,
-    const std::unordered_map<std::string, std::any>& options) {
+    const jsonata::ordered_map<std::string, std::any>& options) {
     if (std::isnan(value) || std::isinf(value)) {
         return std::nullopt;
     }
@@ -4156,11 +4157,11 @@ std::any Functions::lookup(const std::any& input, const std::string& key) {
 
             return result.empty() ? std::any{} : std::any(result);
         } else if (input.type() ==
-                   typeid(std::unordered_map<std::string, std::any>)) {
+                   typeid(jsonata::ordered_map<std::string, std::any>)) {
             // Java: if (input instanceof Map) - get key and handle null
             // detection
             const auto& map = std::any_cast<
-                const std::unordered_map<std::string, std::any>&>(input);
+                const jsonata::ordered_map<std::string, std::any>&>(input);
             auto it = map.find(key);
             if (it != map.end()) {
                 auto result = it->second;
@@ -5058,7 +5059,7 @@ Utils::JList Functions::evaluateMatcher(const std::regex& pattern,
 
     for (; iter != end; ++iter) {
         const std::smatch& smatch = *iter;
-        std::unordered_map<std::string, std::any> match;
+        jsonata::ordered_map<std::string, std::any> match;
         match["match"] = smatch.str();
         match["index"] = static_cast<int64_t>(smatch.position());
 
@@ -5459,9 +5460,9 @@ std::string Functions::safeReplaceAllFn(const std::string& str,
     return finalResult;
 }
 
-std::unordered_map<std::string, std::any> Functions::toJsonataMatch(
+jsonata::ordered_map<std::string, std::any> Functions::toJsonataMatch(
     const std::smatch& match) {
-    std::unordered_map<std::string, std::any> result;
+    jsonata::ordered_map<std::string, std::any> result;
 
     result["match"] = match.str();
 
@@ -5565,7 +5566,7 @@ std::string Functions::rightPad(const std::string& str, int64_t size,
 // formatNumber options processing helper functions
 
 Functions::FormatSymbols Functions::processOptionsArg(
-    const std::unordered_map<std::string, std::any>& options) {
+    const jsonata::ordered_map<std::string, std::any>& options) {
     FormatSymbols symbols;  // Use default values
 
     if (options.empty()) {
diff --git a/src/jsonata/Jsonata.cpp b/src/jsonata/Jsonata.cpp
index 47e001e..ce33b2c 100644
--- a/src/jsonata/Jsonata.cpp
+++ b/src/jsonata/Jsonata.cpp
@@ -17,6 +17,7 @@
  * limitations under the License.
  */
 #include "jsonata/Jsonata.h"
+#include "jsonata/ordered_map.h"
 
 #include <algorithm>
 #include <cmath>
@@ -751,9 +752,9 @@ std::any Jsonata::evaluateWildcard(std::shared_ptr<Parser::Symbol> expr,
     try {
         // Handle map/object input
         if (_input.type() ==
-            typeid(std::unordered_map<std::string, std::any>)) {
+            typeid(jsonata::ordered_map<std::string, std::any>)) {
             auto map =
-                std::any_cast<std::unordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                     _input);
             for (const auto& [key, value] : map) {
                 // Java reference line 713: if((value instanceof List))
@@ -871,7 +872,7 @@ std::any Jsonata::evaluatePath(std::shared_ptr<Parser::Symbol> expr,
             if (tupleBindings.has_value()) {
                 for (const auto& tupleAny : *tupleBindings) {
                     auto tuple = std::any_cast<
-                        std::unordered_map<std::string, std::any>>(tupleAny);
+                        jsonata::ordered_map<std::string, std::any>>(tupleAny);
                     auto it = tuple.find("@");
                     if (it != tuple.end()) {
                         result.push_back(it->second);
@@ -1155,14 +1156,14 @@ bool Jsonata::deepEquals(const std::any& lhs, const std::any& rhs) {
     // Handle object comparison - Java uses Map.equals() which compares all
     // key-value pairs
     if (lhsConverted.type() ==
-            typeid(std::unordered_map<std::string, std::any>) &&
+            typeid(jsonata::ordered_map<std::string, std::any>) &&
         rhsConverted.type() ==
-            typeid(std::unordered_map<std::string, std::any>)) {
+            typeid(jsonata::ordered_map<std::string, std::any>)) {
         const auto& leftMap =
-            std::any_cast<const std::unordered_map<std::string, std::any>&>(
+            std::any_cast<const jsonata::ordered_map<std::string, std::any>&>(
                 lhsConverted);
         const auto& rightMap =
-            std::any_cast<const std::unordered_map<std::string, std::any>&>(
+            std::any_cast<const jsonata::ordered_map<std::string, std::any>&>(
                 rhsConverted);
 
         if (leftMap.size() != rightMap.size()) {
@@ -1360,7 +1361,7 @@ void Jsonata::recurseDescendants(const std::any& input,
         // in the codebase
         try {
             auto map =
-                std::any_cast<std::unordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                     input);
             for (const auto& [key, value] : map) {
                 recurseDescendants(value, results);
@@ -1552,9 +1553,9 @@ std::any Jsonata::evaluateSort(std::shared_ptr<Parser::Symbol> expr,
                 // Extract context from tuple map
                 try {
                     if (a.type() ==
-                        typeid(std::unordered_map<std::string, std::any>)) {
+                        typeid(jsonata::ordered_map<std::string, std::any>)) {
                         auto tupleMap = std::any_cast<
-                            std::unordered_map<std::string, std::any>>(a);
+                            jsonata::ordered_map<std::string, std::any>>(a);
                         auto it = tupleMap.find("@");
                         if (it != tupleMap.end()) {
                             contextA = it->second;
@@ -1577,9 +1578,9 @@ std::any Jsonata::evaluateSort(std::shared_ptr<Parser::Symbol> expr,
             if (isTupleSort) {
                 try {
                     if (b.type() ==
-                        typeid(std::unordered_map<std::string, std::any>)) {
+                        typeid(jsonata::ordered_map<std::string, std::any>)) {
                         auto tupleMap = std::any_cast<
-                            std::unordered_map<std::string, std::any>>(b);
+                            jsonata::ordered_map<std::string, std::any>>(b);
                         auto it = tupleMap.find("@");
                         if (it != tupleMap.end()) {
                             contextB = it->second;
@@ -1785,16 +1786,16 @@ std::any Jsonata::evaluateTransform(std::shared_ptr<Parser::Symbol> expr,
                 if (update.has_value()) {
                     if (update.type() ==
                             typeid(
-                                std::unordered_map<std::string, std::any>) &&
+                                jsonata::ordered_map<std::string, std::any>) &&
                         match.type() ==
                             typeid(
-                                std::unordered_map<std::string, std::any>)) {
+                                jsonata::ordered_map<std::string, std::any>)) {
                         // Java lines 1457-1459: merge the update
                         auto& matchMap = std::any_cast<
-                            std::unordered_map<std::string, std::any>&>(
+                            jsonata::ordered_map<std::string, std::any>&>(
                             match);
                         const auto& updateMap =
-                            std::any_cast<const std::unordered_map<
+                            std::any_cast<const jsonata::ordered_map<
                                 std::string, std::any>&>(update);
 
                         for (const auto& [prop, value] : updateMap) {
@@ -1925,9 +1926,9 @@ std::any Jsonata::evaluateFilter(std::shared_ptr<Parser::Symbol> predicate,
             }
             if (isTupleStream &&
                 item.type() ==
-                    typeid(std::unordered_map<std::string, std::any>)) {
+                    typeid(jsonata::ordered_map<std::string, std::any>)) {
                 auto tupleMap =
-                    std::any_cast<std::unordered_map<std::string, std::any>>(
+                    std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                         item);
                 auto it = tupleMap.find("@");
                 if (it != tupleMap.end()) {
@@ -2033,7 +2034,7 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //         return out;
 //     }
 //     if (j.isObject()) {
-//         std::unordered_map<std::string, std::any> m;
+//         jsonata::ordered_map<std::string, std::any> m;
 //         jsonata::copy( j, m, [](const jsonata::ordered_json&el){
 //             return toAny(el);
 //         });
@@ -2099,10 +2100,10 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //         });
 //         return arr;
 //     }
-//     if (type == typeid(std::unordered_map<std::string, std::any>)) {
+//     if (type == typeid(jsonata::ordered_map<std::string, std::any>)) {
 //         jsonata::ordered_json obj = jsonata::ordered_json::object();
 //         const auto& map =
-//             std::any_cast<const std::unordered_map<std::string, std::any>&>(
+//             std::any_cast<const jsonata::ordered_map<std::string, std::any>&>(
 //                 value);
 //         jsonata::copy( map, obj, []( const std::any & a ) {
 //             return fromAny(a);
@@ -2148,7 +2149,7 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //         return out;
 //     }
 //     if (j.isObject()) {
-//         std::unordered_map<std::string, std::any> m;
+//         jsonata::ordered_map<std::string, std::any> m;
 //         jsonata::copy( j, m, []( const jsonata::json & el ) {
 //             return jsonToAny(el);
 //         });
@@ -2213,10 +2214,10 @@ std::any Jsonata::evaluateBlock(std::shared_ptr<Parser::Symbol> expr,
 //         });
 //         return arr;
 //     }
-//     if (type == typeid(std::unordered_map<std::string, std::any>)) {
+//     if (type == typeid(jsonata::ordered_map<std::string, std::any>)) {
 //         jsonata::json obj = jsonata::json::object();
 //         const auto& map =
-//             std::any_cast<const std::unordered_map<std::string, std::any>&>(
+//             std::any_cast<const jsonata::ordered_map<std::string, std::any>&>(
 //                 value);
 //         jsonata::copy( map, obj, []( const std::any & a ) {
 //             return anyToJson(a);
@@ -2322,7 +2323,7 @@ std::shared_ptr<Frame> Jsonata::createFrameFromTuple(
     // Java reference lines 324-329: createFrameFromTuple implementation
     auto frame = createFrame(environment);
     auto tuple =
-        std::any_cast<std::unordered_map<std::string, std::any>>(tupleAny);
+        std::any_cast<jsonata::ordered_map<std::string, std::any>>(tupleAny);
     for (const auto& [key, value] : tuple) {
         frame->bind(key, value);
     }
@@ -2341,15 +2342,15 @@ std::any Jsonata::reduceTupleStream(const std::any& tupleStream) {
         return std::any{};
     }
 
-    std::unordered_map<std::string, std::any> result;
+    jsonata::ordered_map<std::string, std::any> result;
     // Java line 1144: result.putAll(tupleStream.get(0));
     result =
-        std::any_cast<std::unordered_map<std::string, std::any>>(tuples[0]);
+        std::any_cast<jsonata::ordered_map<std::string, std::any>>(tuples[0]);
 
     // Java lines 1147-1158: merge remaining tuples
     for (size_t i = 1; i < tuples.size(); i++) {
         const auto& el =
-            std::any_cast<std::unordered_map<std::string, std::any>>(
+            std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                 tuples[i]);
         for (const auto& [prop, value] : el) {
             // Java line 1154: result.put(prop,
@@ -2501,8 +2502,8 @@ std::any Jsonata::evaluate(const std::any anyInput,
         // Clear TLS after evaluation to avoid dangling references
         tls_input_.reset();
         tls_environment_.reset();
-        std::cout << "RRR1" << Jsonata::fromAny<QVariant>(result).dump() << std::endl;
-        std::cout << "RRR2" << Jsonata::fromAny<QVariant>(Utils::convertNulls(result)).dump() << std::endl;
+        // std::cout << "RRR1" << Jsonata::fromAny<QVariant>(result).dump() << std::endl;
+        // std::cout << "RRR2" << Jsonata::fromAny<QVariant>(Utils::convertNulls(result)).dump() << std::endl;
         return Utils::convertNulls(result);
     } catch (const std::exception& err) {
         // TODO: populateMessage(err);
@@ -2510,146 +2511,6 @@ std::any Jsonata::evaluate(const std::any anyInput,
     }
 }
 
-// jsonata::ordered_json Jsonata::evaluate(const jsonata::ordered_json& input) {
-//     return evaluate(input, nullptr);
-// }
-
-// jsonata::ordered_json Jsonata::evaluate(const jsonata::ordered_json& input,
-//                                          std::shared_ptr<Frame> bindings) {
-//     currentInstance_ = this;
-
-//     // Check for syntax errors (equivalent to Java's check for errors != null)
-//     if (!expression_) {
-//         throw JException("S0500", 0);  // Expression compilation failed
-//     }
-
-//     // Convert JSON input to std::any domain for the evaluator
-//     std::any anyInput = toAny(input);
-
-//     // Always evaluate in a fresh child frame of the shared environment,
-//     // then (optionally) copy provided bindings into it. This avoids
-//     // concurrent mutations of the shared environment.
-//     std::shared_ptr<Frame> exec_env = createFrame(environment_);
-//     if (bindings != nullptr) {
-//         for (const auto& [key, value] : bindings->getBindings()) {
-//             exec_env->bind(key, value);
-//         }
-//     }
-
-//     // TODO: capture timestamp for $now() and $millis() functions
-//     // timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
-//     //     std::chrono::system_clock::now().time_since_epoch()).count();
-
-//     // CRITICAL: if the input is a JSON array, wrap it in a singleton sequence
-//     // Java reference lines 2575-2579:
-//     // if((input instanceof List) && !Utils.isSequence(input)) {
-//     //     input = Utils.createSequence(input);
-//     //     ((JList)input).outerWrapper = true;
-//     // }
-//     std::any processedInput = anyInput;
-//     if (anyInput.has_value() && Utils::isArray(anyInput) &&
-//         !Utils::isSequence(anyInput)) {
-//         auto sequence = Utils::createSequence(anyInput);
-//         sequence.outerWrapper = true;
-//         processedInput = sequence;
-//     }
-
-//     // CRITICAL: put the processed input (which may be wrapped) into the
-//     // fresh execution environment as the root object "$"
-//     exec_env->bind("$", processedInput);
-
-//     if (validateInput_) {
-//         Functions::validateInput(processedInput);
-//     }
-
-//     std::any result;
-//     try {
-//         // Set thread-local input/environment for this evaluation
-//         tls_input_ = processedInput;
-//         tls_environment_ = exec_env;
-//         result = evaluate(expression_, processedInput, exec_env);
-//         // Clear TLS after evaluation to avoid dangling references
-//         tls_input_.reset();
-//         tls_environment_.reset();
-//         result = Utils::convertNulls(result);
-//         // Convert result back to jsonata::ordered_json
-//         return fromAny(result);
-//     } catch (const std::exception& err) {
-//         // TODO: populateMessage(err);
-//         throw;
-//     }
-// }
-
-// jsonata::ordered_json Jsonata::evaluate(std::nullptr_t) {
-//     return evaluate(jsonata::ordered_json());
-// }
-
-// jsonata::ordered_json Jsonata::evaluate(std::nullptr_t,
-//                                          std::shared_ptr<Frame> bindings) {
-//     return evaluate(jsonata::ordered_json(), bindings);
-// }
-
-// // Unordered jsonata::json variants
-// jsonata::json Jsonata::evaluate(const jsonata::json& input) {
-//     return evaluate(input, nullptr);
-// }
-
-// jsonata::json Jsonata::evaluate(const jsonata::json& input,
-//                                  std::shared_ptr<Frame> bindings) {
-//     currentInstance_ = this;
-
-//     if (!expression_) {
-//         throw JException("S0500", 0);
-//     }
-
-//     // Convert JSON input to std::any domain for the evaluator
-//     std::any anyInput = jsonToAny(input);
-
-//     std::shared_ptr<Frame> exec_env = createFrame(environment_);
-//     if (bindings != nullptr) {
-//         for (const auto& [key, value] : bindings->getBindings()) {
-//             exec_env->bind(key, value);
-//         }
-//     }
-
-//     std::any processedInput = anyInput;
-//     if (anyInput.has_value() && Utils::isArray(anyInput) &&
-//         !Utils::isSequence(anyInput)) {
-//         auto sequence = Utils::createSequence(anyInput);
-//         sequence.outerWrapper = true;
-//         processedInput = sequence;
-//     }
-
-//     exec_env->bind("$", processedInput);
-
-//     if (validateInput_) {
-//         Functions::validateInput(processedInput);
-//     }
-
-//     std::any result;
-//     try {
-//         tls_input_ = processedInput;
-//         tls_environment_ = exec_env;
-//         result = evaluate(expression_, processedInput, exec_env);
-//         tls_input_.reset();
-//         tls_environment_.reset();
-//         result = Utils::convertNulls(result);
-//         // Convert result to jsonata::json
-//         return anyToJson(result);
-//     } catch (const std::exception& err) {
-//         throw;
-//     }
-// }
-
-// jsonata::json Jsonata::evaluateUnordered(std::nullptr_t) {
-//     return evaluate(jsonata::json());
-// }
-
-// jsonata::json Jsonata::evaluateUnordered(std::nullptr_t,
-//                                           std::shared_ptr<Frame> bindings) {
-//     return evaluate(jsonata::json(), bindings);
-// }
-
 std::any Jsonata::apply(const std::any& proc, const Utils::JList& args,
                         const std::any& input,
                         std::shared_ptr<Frame> environment) {
@@ -2735,7 +2596,7 @@ static std::any regexClosure(std::shared_ptr<RegexState> state) {
     if (state->it == state->end) return std::any{};
     auto match = *state->it;
     ++(state->it);
-    std::unordered_map<std::string, std::any> result;
+    jsonata::ordered_map<std::string, std::any> result;
     result["match"] = std::string(match.str());
     result["start"] = static_cast<long long>(match.position());
     result["end"] = static_cast<long long>(match.position() + match.length());
@@ -2919,9 +2780,9 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                 std::shared_ptr<Frame> environment;
                 if (symbol->value.has_value() &&
                     symbol->value.type() ==
-                        typeid(std::unordered_map<std::string, std::any>)) {
+                        typeid(jsonata::ordered_map<std::string, std::any>)) {
                     auto closureMap = std::any_cast<
-                        std::unordered_map<std::string, std::any>>(
+                        jsonata::ordered_map<std::string, std::any>>(
                         symbol->value);
                     if (closureMap.find("environment") != closureMap.end()) {
                         try {
@@ -2985,16 +2846,16 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             return std::any_cast<bool>(a) ==
                                    std::any_cast<bool>(b);
                         if (a.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>) &&
                             b.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>)) {
                             const auto& ma =
-                                std::any_cast<const std::unordered_map<
+                                std::any_cast<const jsonata::ordered_map<
                                     std::string, std::any>&>(a);
                             const auto& mb =
-                                std::any_cast<const std::unordered_map<
+                                std::any_cast<const jsonata::ordered_map<
                                     std::string, std::any>&>(b);
                             if (ma.size() != mb.size()) return false;
                             for (const auto& [k, va] : ma) {
@@ -3036,19 +2897,19 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
 
                     std::function<bool(
                         std::any&, const std::any&,
-                        const std::unordered_map<std::string, std::any>&)>
+                        const jsonata::ordered_map<std::string, std::any>&)>
                         applyUpdateToFirstMatch =
                             [&](std::any& node, const std::any& target,
-                                const std::unordered_map<
+                                const jsonata::ordered_map<
                                     std::string, std::any>& updateMap) -> bool {
                         if (node.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>) &&
                             target.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>)) {
                             if (deepEqualsAny(node, target)) {
-                                auto& m = std::any_cast<std::unordered_map<
+                                auto& m = std::any_cast<jsonata::ordered_map<
                                     std::string, std::any>&>(node);
                                 for (const auto& [k, v] : updateMap) {
                                     m[k] = v;
@@ -3056,7 +2917,7 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 return true;
                             }
                             auto& m = std::any_cast<
-                                std::unordered_map<std::string, std::any>&>(
+                                jsonata::ordered_map<std::string, std::any>&>(
                                 node);
                             for (auto it = m.begin(); it != m.end(); ++it) {
                                 if (applyUpdateToFirstMatch(it->second, target,
@@ -3095,13 +2956,13 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 const std::vector<std::string>& deletions)
                         -> bool {
                         if (node.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>) &&
                             target.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>)) {
                             if (deepEqualsAny(node, target)) {
-                                auto& m = std::any_cast<std::unordered_map<
+                                auto& m = std::any_cast<jsonata::ordered_map<
                                     std::string, std::any>&>(node);
                                 for (const auto& key : deletions) {
                                     m.erase(key);
@@ -3109,7 +2970,7 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                                 return true;
                             }
                             auto& m = std::any_cast<
-                                std::unordered_map<std::string, std::any>&>(
+                                jsonata::ordered_map<std::string, std::any>&>(
                                 node);
                             for (auto it = m.begin(); it != m.end(); ++it) {
                                 if (applyDeleteToFirstMatch(it->second, target,
@@ -3148,13 +3009,13 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             instance->evaluate(update, match, environment);
                         if (updateValue.has_value()) {
                             if (updateValue.type() !=
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>)) {
                                 throw JException("T2011", update->position,
                                                  updateValue);
                             }
                             const auto& updateMap =
-                                std::any_cast<const std::unordered_map<
+                                std::any_cast<const jsonata::ordered_map<
                                     std::string, std::any>&>(updateValue);
                             // Apply update to the first occurrence of match
                             // within result
@@ -3166,10 +3027,10 @@ std::any Jsonata::applyProcedure(const std::any& _proc,
                             // delete uses a structure that deep-equals the
                             // updated node in 'result'.
                             if (match.type() ==
-                                typeid(std::unordered_map<std::string,
+                                typeid(jsonata::ordered_map<std::string,
                                                              std::any>)) {
                                 auto& matchMap =
-                                    std::any_cast<std::unordered_map<
+                                    std::any_cast<jsonata::ordered_map<
                                         std::string, std::any>&>(match);
                                 for (const auto& [k, v] : updateMap) {
                                     matchMap[k] = v;
@@ -3298,7 +3159,7 @@ std::any Jsonata::evaluateStages(
                             std::string stageValue =
                                 std::any_cast<std::string>(stage->value);
                             auto tuple = std::any_cast<
-                                std::unordered_map<std::string, std::any>>(
+                                jsonata::ordered_map<std::string, std::any>>(
                                 tupleList[ee]);
                             tuple[stageValue] = static_cast<int64_t>(ee);
                             tupleList[ee] = std::any(tuple);
@@ -3311,9 +3172,9 @@ std::any Jsonata::evaluateStages(
                     for (size_t ee = 0; ee < resultList.size(); ee++) {
                         if (resultList[ee].type() ==
                             typeid(
-                                std::unordered_map<std::string, std::any>)) {
+                                jsonata::ordered_map<std::string, std::any>)) {
                             auto tuple = std::any_cast<
-                                std::unordered_map<std::string, std::any>>(
+                                jsonata::ordered_map<std::string, std::any>>(
                                 resultList[ee]);
                             if (stage->value.has_value()) {
                                 std::string stageValue =
@@ -3451,7 +3312,7 @@ std::any Jsonata::evaluateTupleStep(
             if (sorted.has_value() && Utils::isArray(sorted)) {
                 auto sortedVec = Utils::arrayify(sorted);
                 for (size_t i = 0; i < sortedVec.size(); ++i) {
-                    std::unordered_map<std::string, std::any> tuple;
+                    jsonata::ordered_map<std::string, std::any> tuple;
                     tuple["@"] = sortedVec[i];
                     if (expr->index.has_value()) {
                         try {
@@ -3490,7 +3351,7 @@ std::any Jsonata::evaluateTupleStep(
         // Java line 435: create initial tuple bindings (only when tupleBindings
         // is null, not just empty)
         for (const auto& item : input) {
-            std::unordered_map<std::string, std::any> tuple;
+            jsonata::ordered_map<std::string, std::any> tuple;
             tuple["@"] = item;
             bindings.push_back(std::any(tuple));
         }
@@ -3499,7 +3360,7 @@ std::any Jsonata::evaluateTupleStep(
     // Java reference lines 438-472: process each tuple binding
     for (const auto& bindingAny : bindings) {
         auto binding =
-            std::any_cast<std::unordered_map<std::string, std::any>>(
+            std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                 bindingAny);
         // Create frame from tuple - Java line 439
         auto stepEnv = createFrameFromTuple(environment, bindingAny);
@@ -3523,14 +3384,14 @@ std::any Jsonata::evaluateTupleStep(
 
             // Java lines 449-469: create output tuples
             for (size_t i = 0; i < resVec.size(); ++i) {
-                std::unordered_map<std::string, std::any> tuple(
+                jsonata::ordered_map<std::string, std::any> tuple(
                     binding);  // Copy existing bindings
 
                 if (resVec.tupleStream) {
                     // cast resVec[i] to a map and overwrite existing keys
                     // (match Java Map.putAll semantics)
                     auto resTuple = std::any_cast<
-                        std::unordered_map<std::string, std::any>>(
+                        jsonata::ordered_map<std::string, std::any>>(
                         resVec[i]);
                     for (const auto& kv : resTuple) {
                         tuple[kv.first] = kv.second;
@@ -3592,14 +3453,14 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
     if (!expr) return std::any{};
 
     // Port exact Java implementation: Jsonata.java lines 1051-1134
-    std::unordered_map<std::string, std::any> result;
+    jsonata::ordered_map<std::string, std::any> result;
 
     // C++ equivalent of Java's LinkedHashMap<Object,GroupEntry>
     struct GroupEntry {
         std::any data;
         int64_t exprIndex;
     };
-    std::unordered_map<std::string, GroupEntry> groups;
+    jsonata::ordered_map<std::string, GroupEntry> groups;
 
     // Java line 1054: var reduce = (_input instanceof JList) &&
     // ((JList)_input).tupleStream ? true : false; For now, simplify this - the
@@ -3637,7 +3498,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
                 ? createFrameFromTuple(
                       environment,
                       std::any_cast<
-                          std::unordered_map<std::string, std::any>>(item))
+                          jsonata::ordered_map<std::string, std::any>>(item))
                 : environment;
 
         for (size_t pairIndex = 0; pairIndex < expr->lhsObject.size();
@@ -3649,7 +3510,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
             std::any keyContext = item;
             if (reduce) {
                 auto itemMap =
-                    std::any_cast<std::unordered_map<std::string, std::any>>(
+                    std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                         item);
                 auto atIt = itemMap.find("@");
                 keyContext =
@@ -3716,7 +3577,7 @@ std::any Jsonata::evaluateGroupExpression(std::shared_ptr<Parser::Symbol> expr,
         if (reduce) {
             auto tuple = reduceTupleStream(entry.data);
             auto tupleMap =
-                std::any_cast<std::unordered_map<std::string, std::any>>(
+                std::any_cast<jsonata::ordered_map<std::string, std::any>>(
                     tuple);
             auto atIt = tupleMap.find("@");
             context = (atIt != tupleMap.end()) ? atIt->second : std::any{};
@@ -3762,7 +3623,7 @@ std::any Jsonata::evaluateTransformExpression(
     transformer->arguments.push_back(dummyArg);
 
     // Store the closure environment
-    transformer->value = std::unordered_map<std::string, std::any>{
+    transformer->value = jsonata::ordered_map<std::string, std::any>{
         {"input", input}, {"environment", environment}};
 
     return transformer;
diff --git a/src/jsonata/Utils.cpp b/src/jsonata/Utils.cpp
index a3da615..baeb321 100644
--- a/src/jsonata/Utils.cpp
+++ b/src/jsonata/Utils.cpp
@@ -17,6 +17,7 @@
  * limitations under the License.
  */
 #include "jsonata/Utils.h"
+#include "jsonata/ordered_map.h"
 
 #include <cmath>
 #include <limits>
@@ -172,7 +173,7 @@ bool Utils::isArray(const std::any& value) {
 
 bool Utils::isObject(const std::any& value) {
     if (!value.has_value()) return false;
-    return value.type() == typeid(std::unordered_map<std::string, std::any>);
+    return value.type() == typeid(jsonata::ordered_map<std::string, std::any>);
 }
 
 std::optional<std::string> Utils::type(const std::any& value) {
@@ -401,7 +402,7 @@ std::any Utils::convertNulls(const std::any& res) {
 void Utils::convertNullsMap(std::any& res) {
     try {
         auto& map =
-            std::any_cast<std::unordered_map<std::string, std::any>&>(res);
+            std::any_cast<jsonata::ordered_map<std::string, std::any>&>(res);
         for (auto it = map.begin(); it != map.end(); ++it) {
             std::any& valRef = it->second;
             std::any converted = convertValue(valRef);
diff --git a/src/jsonata/utils/Signature.cpp b/src/jsonata/utils/Signature.cpp
index aa5074c..d0ced3c 100644
--- a/src/jsonata/utils/Signature.cpp
+++ b/src/jsonata/utils/Signature.cpp
@@ -130,7 +130,7 @@ bool Signature::isArrayType(const std::any &value) {
 std::string Signature::checkObjectType(const std::any &value) {
     // Try map (object)
     try {
-        auto r = std::any_cast<std::unordered_map<std::string, std::any>>(value);
+        auto r = std::any_cast<jsonata::ordered_map<std::string, std::any>>(value);
         return "o";
     } catch (const std::bad_any_cast &) {
         // Try shared_ptr<map> - check if it's a regex object
diff --git a/test/JsonataTest.cpp b/test/JsonataTest.cpp
index 8f267b3..4084bc7 100644
--- a/test/JsonataTest.cpp
+++ b/test/JsonataTest.cpp
@@ -82,8 +82,9 @@ namespace jsonata
                 // Compare using canonical jsonata::json (unordered object semantics)
                 // jsonata::json exp = jsonata::json::parse(expected.dump());
                 // jsonata::json res = jsonata::json::parse(result.dump());
-                auto exp = jsonata::backend<JSONATA_TEST_BACKEND>::parse(expected.dump());
-                auto res = jsonata::backend<JSONATA_TEST_BACKEND>::parse(result.dump());
+                const
+                auto exp = jsonata::backend<JSONATA_TEST_BACKEND>::sortedPartner::parse(expected.dump());
+                auto res = jsonata::backend<JSONATA_TEST_BACKEND>::sortedPartner::parse(result.dump());
 
                 if (unordered && exp.isArray() && res.isArray()) {
                     // Simple unordered compare via multiset of dumps