diff --git a/.github/workflows/ada.yml b/.github/workflows/ada.yml index 489ae2f..d74aedc 100644 --- a/.github/workflows/ada.yml +++ b/.github/workflows/ada.yml @@ -2,7 +2,6 @@ name: Alire Build on: push: - branches: [ "main" ] pull_request: branches: [ "main" ] @@ -17,6 +16,14 @@ jobs: - name: Set up Alire uses: alire-project/setup-alire@v4 - - - name: Build + + - name: Build library run: alr build + + - name: Build tests + run: alr build + working-directory: tests + + - name: Run tests + run: ./bin/test_runner + working-directory: tests diff --git a/CHANGELOG.md b/CHANGELOG.md index 8b4a1d5..2808708 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,10 @@ All notable changes to this project will be documented in this file. The format ## [Unreleased] +### Changed + +- Instead of a homegrown test suite, we now use AUnit. + ## [0.2.0] - 2025-12-29 ### Changed diff --git a/README.md b/README.md index 4798073..860496e 100644 --- a/README.md +++ b/README.md @@ -197,7 +197,16 @@ Requires Ada 2022 compiler (FSF GNAT 13+). ```bash alr build # Build library -alr exec -- ./bin/test_runner # Run tests (after building tests) +``` + +## Running Tests + +Tests use [AUnit](https://github.com/AdaCore/aunit) and live in a separate crate: + +```bash +cd tests +alr build +./bin/test_runner ``` ## License diff --git a/tests/alire.toml b/tests/alire.toml new file mode 100644 index 0000000..672558b --- /dev/null +++ b/tests/alire.toml @@ -0,0 +1,16 @@ +name = "tinyaml_tests" +description = "Tests for TinyAML library" +version = "0.2.0" + +authors = ["Jochen Lillich"] +maintainers = ["Jochen Lillich "] +maintainers-logins = ["geewiz"] + +[[depends-on]] +aunit = "^26.0.0" + +[[depends-on]] +tinyaml = "*" + +[[pins]] +tinyaml = { path = ".." } diff --git a/tests/alire/alire.lock b/tests/alire/alire.lock new file mode 100644 index 0000000..df9e4d4 --- /dev/null +++ b/tests/alire/alire.lock @@ -0,0 +1,116 @@ +# THIS FILE IS GENERATED. DO NOT EDIT. + +[solution] +[solution.context] +solved = true +[[solution.state]] +crate = "aunit" +fulfilment = "solved" +pinned = false +transitivity = "direct" +versions = "^26.0.0" +[solution.state.release] +authors = [ +"AdaCore", +] +description = "Ada unit test framework" +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +maintainers = [ +"chouteau@adacore.com", +"sagaert@adacore.com", +] +maintainers-logins = [ +"Fabien-Chouteau", +"AldanTanneo", +] +name = "aunit" +project-files = [ +"lib/gnat/aunit.gpr", +] +tags = [ +"unit", +"test", +"unit-test", +] +version = "26.0.0" +[solution.state.release.configuration] +auto_gpr_with = true +disabled = true +generate_ada = true +generate_c = true +generate_gpr = true +output_dir = "config" +[solution.state.release.gpr-externals] +AUNIT_BUILD_MODE = [ +"Devel", +"Install", +] +AUNIT_RUNTIME = [ +"full", +"zfp", +"zfp-cross", +"ravenscar", +"ravenscar-cert", +"cert", +] +[solution.state.release.origin] +hashes = [ +"sha512:b882e96a4b2cbc2d0d3838e14f2c7b6e576d6d7ccf88fe3562b1fbca61a2ebfd4e8b3379dd5c3fb3140949cda69526c8696fe3b7a6c6748fe93f116213276b39", +] +url = "https://github.com/AdaCore/aunit/archive/refs/tags/v26.0.0.zip" +[[solution.state]] +crate = "gnat" +fulfilment = "solved" +pinned = false +transitivity = "indirect" +versions = ">=13" +[solution.state.release] +auto-gpr-with = false +description = "The GNAT Ada compiler - Native" +licenses = "GPL-3.0-or-later AND GPL-3.0-or-later WITH GCC-exception-3.1" +maintainers = [ +"Fabien Chouteau ", +"César Sagaert ", +] +maintainers-logins = [ +"Fabien-Chouteau", +"AldanTanneo", +] +name = "gnat_native" +provides = [ +"gnat=15.2.1", +] +version = "15.2.1" +website = "https://github.com/alire-project/GNAT-FSF-builds" +[solution.state.release.configuration] +auto_gpr_with = true +disabled = true +generate_ada = true +generate_c = true +generate_gpr = true +output_dir = "config" +[solution.state.release.environment] +[solution.state.release.environment.LD_LIBRARY_PATH] +prepend = "${CRATE_ROOT}/lib64" +[solution.state.release.environment.LD_RUN_PATH] +prepend = "${CRATE_ROOT}/lib64" +[solution.state.release.environment.LIBRARY_PATH] +prepend = "${CRATE_ROOT}/lib64" +[solution.state.release.environment.PATH] +prepend = "${CRATE_ROOT}/bin" +[solution.state.release.origin] +binary = true +hashes = [ +"sha256:4640d4b369833947ab1a156753f4db0ecd44b0f14410b5b2bc2a14df496604bb", +] +url = "https://github.com/alire-project/GNAT-FSF-builds/releases/download/gnat-15.2.0-1/gnat-x86_64-linux-15.2.0-1.tar.gz" +[[solution.state]] +crate = "tinyaml" +fulfilment = "linked" +pinned = false +transitivity = "direct" +versions = "*" +[solution.state.link] +lockfiled = true +path = ".." + diff --git a/tests/alire/build_hash_inputs b/tests/alire/build_hash_inputs new file mode 100644 index 0000000..4e40225 --- /dev/null +++ b/tests/alire/build_hash_inputs @@ -0,0 +1,6 @@ +dependency:aunit=26.0.0=78c67a8b011e08e5500962fc633efb7809a9c7391b64fc383bbaebb1096eadc4 +dependency:tinyaml=0.2.0=35dcaab96834c0712229aeea970e24669049cca0f53bab324e197c0225b8e6db +external:LIBRARY_TYPE=default +external:TINYAML_TESTS_LIBRARY_TYPE=default +profile:tinyaml_tests=DEVELOPMENT +switches:tinyaml_tests=-Og,-fdata-sections,-ffunction-sections,-g,-gnatVa,-gnatW8,-gnatw.X,-gnatwa,-gnaty-d,-gnaty3,-gnatyA,-gnatyB,-gnatyI,-gnatyO,-gnatyS,-gnatya,-gnatyb,-gnatyc,-gnatye,-gnatyf,-gnatyh,-gnatyi,-gnatyk,-gnatyl,-gnatym,-gnatyn,-gnatyp,-gnatyr,-gnatyt,-gnatyu,-gnatyx diff --git a/tests/alire/flags/post_fetch_done b/tests/alire/flags/post_fetch_done new file mode 100644 index 0000000..e69de29 diff --git a/tests/alire/settings.toml b/tests/alire/settings.toml new file mode 100644 index 0000000..4059e09 --- /dev/null +++ b/tests/alire/settings.toml @@ -0,0 +1,2 @@ +last_build_profile = "aunit=RELEASE,gnat_native=RELEASE,tinyaml=RELEASE,tinyaml_tests=DEVELOPMENT" + diff --git a/tests/bin/test_runner b/tests/bin/test_runner new file mode 100755 index 0000000..77c7c0e Binary files /dev/null and b/tests/bin/test_runner differ diff --git a/tests/config/tinyaml_tests_config.ads b/tests/config/tinyaml_tests_config.ads new file mode 100644 index 0000000..0ff1f85 --- /dev/null +++ b/tests/config/tinyaml_tests_config.ads @@ -0,0 +1,20 @@ +-- Configuration for tinyaml_tests generated by Alire +pragma Restrictions (No_Elaboration_Code); +pragma Style_Checks (Off); + +package Tinyaml_Tests_Config is + pragma Pure; + + Crate_Version : constant String := "0.2.0"; + Crate_Name : constant String := "tinyaml_tests"; + + Alire_Host_OS : constant String := "linux"; + + Alire_Host_Arch : constant String := "x86_64"; + + Alire_Host_Distro : constant String := "ubuntu"; + + type Build_Profile_Kind is (release, validation, development); + Build_Profile : constant Build_Profile_Kind := development; + +end Tinyaml_Tests_Config; diff --git a/tests/config/tinyaml_tests_config.gpr b/tests/config/tinyaml_tests_config.gpr new file mode 100644 index 0000000..ee5eade --- /dev/null +++ b/tests/config/tinyaml_tests_config.gpr @@ -0,0 +1,52 @@ +-- Configuration for tinyaml_tests generated by Alire +with "aunit.gpr"; +with "tinyaml.gpr"; +abstract project Tinyaml_Tests_Config is + Crate_Version := "0.2.0"; + Crate_Name := "tinyaml_tests"; + + Alire_Host_OS := "linux"; + + Alire_Host_Arch := "x86_64"; + + Alire_Host_Distro := "ubuntu"; + Ada_Compiler_Switches := External_As_List ("ADAFLAGS", " "); + Ada_Compiler_Switches := Ada_Compiler_Switches & + ( + "-Og" -- Optimize for debug + ,"-ffunction-sections" -- Separate ELF section for each function + ,"-fdata-sections" -- Separate ELF section for each variable + ,"-g" -- Generate debug info + ,"-gnatwa" -- Enable all warnings + ,"-gnatw.X" -- Disable warnings for No_Exception_Propagation + ,"-gnatVa" -- All validity checks + ,"-gnaty3" -- Specify indentation level of 3 + ,"-gnatya" -- Check attribute casing + ,"-gnatyA" -- Use of array index numbers in array attributes + ,"-gnatyB" -- Check Boolean operators + ,"-gnatyb" -- Blanks not allowed at statement end + ,"-gnatyc" -- Check comments + ,"-gnaty-d" -- Disable check no DOS line terminators present + ,"-gnatye" -- Check end/exit labels + ,"-gnatyf" -- No form feeds or vertical tabs + ,"-gnatyh" -- No horizontal tabs + ,"-gnatyi" -- Check if-then layout + ,"-gnatyI" -- check mode IN keywords + ,"-gnatyk" -- Check keyword casing + ,"-gnatyl" -- Check layout + ,"-gnatym" -- Check maximum line length + ,"-gnatyn" -- Check casing of entities in Standard + ,"-gnatyO" -- Check that overriding subprograms are explicitly marked as such + ,"-gnatyp" -- Check pragma casing + ,"-gnatyr" -- Check identifier references casing + ,"-gnatyS" -- Check no statements after THEN/ELSE + ,"-gnatyt" -- Check token spacing + ,"-gnatyu" -- Check unnecessary blank lines + ,"-gnatyx" -- Check extra parentheses + ,"-gnatW8" -- UTF-8 encoding for wide characters + ); + + type Build_Profile_Kind is ("release", "validation", "development"); + Build_Profile : Build_Profile_Kind := "development"; + +end Tinyaml_Tests_Config; diff --git a/tests/config/tinyaml_tests_config.h b/tests/config/tinyaml_tests_config.h new file mode 100644 index 0000000..ed6ed84 --- /dev/null +++ b/tests/config/tinyaml_tests_config.h @@ -0,0 +1,20 @@ +/* Configuration for tinyaml_tests generated by Alire */ +#ifndef TINYAML_TESTS_CONFIG_H +#define TINYAML_TESTS_CONFIG_H + +#define CRATE_VERSION "0.2.0" +#define CRATE_NAME "tinyaml_tests" + +#define ALIRE_HOST_OS "linux" + +#define ALIRE_HOST_ARCH "x86_64" + +#define ALIRE_HOST_DISTRO "ubuntu" + +#define BUILD_PROFILE_RELEASE 1 +#define BUILD_PROFILE_VALIDATION 2 +#define BUILD_PROFILE_DEVELOPMENT 3 + +#define BUILD_PROFILE 3 + +#endif diff --git a/tests/obj/b__test_runner.adb b/tests/obj/b__test_runner.adb new file mode 100644 index 0000000..555aad7 --- /dev/null +++ b/tests/obj/b__test_runner.adb @@ -0,0 +1,665 @@ +pragma Warnings (Off); +pragma Ada_95; +pragma Source_File_Name (ada_main, Spec_File_Name => "b__test_runner.ads"); +pragma Source_File_Name (ada_main, Body_File_Name => "b__test_runner.adb"); +pragma Suppress (Overflow_Check); +with Ada.Exceptions; + +package body ada_main is + + E071 : Short_Integer; pragma Import (Ada, E071, "system__os_lib_E"); + E016 : Short_Integer; pragma Import (Ada, E016, "ada__exceptions_E"); + E012 : Short_Integer; pragma Import (Ada, E012, "system__soft_links_E"); + E010 : Short_Integer; pragma Import (Ada, E010, "system__exception_table_E"); + E035 : Short_Integer; pragma Import (Ada, E035, "ada__containers_E"); + E066 : Short_Integer; pragma Import (Ada, E066, "ada__io_exceptions_E"); + E025 : Short_Integer; pragma Import (Ada, E025, "ada__numerics_E"); + E007 : Short_Integer; pragma Import (Ada, E007, "ada__strings_E"); + E053 : Short_Integer; pragma Import (Ada, E053, "ada__strings__maps_E"); + E056 : Short_Integer; pragma Import (Ada, E056, "ada__strings__maps__constants_E"); + E040 : Short_Integer; pragma Import (Ada, E040, "interfaces__c_E"); + E019 : Short_Integer; pragma Import (Ada, E019, "system__exceptions_E"); + E082 : Short_Integer; pragma Import (Ada, E082, "system__object_reader_E"); + E047 : Short_Integer; pragma Import (Ada, E047, "system__dwarf_lines_E"); + E101 : Short_Integer; pragma Import (Ada, E101, "system__soft_links__initialize_E"); + E034 : Short_Integer; pragma Import (Ada, E034, "system__traceback__symbolic_E"); + E241 : Short_Integer; pragma Import (Ada, E241, "ada__assertions_E"); + E105 : Short_Integer; pragma Import (Ada, E105, "ada__strings__utf_encoding_E"); + E113 : Short_Integer; pragma Import (Ada, E113, "ada__tags_E"); + E005 : Short_Integer; pragma Import (Ada, E005, "ada__strings__text_buffers_E"); + E192 : Short_Integer; pragma Import (Ada, E192, "gnat_E"); + E125 : Short_Integer; pragma Import (Ada, E125, "ada__streams_E"); + E146 : Short_Integer; pragma Import (Ada, E146, "system__file_control_block_E"); + E141 : Short_Integer; pragma Import (Ada, E141, "system__finalization_root_E"); + E139 : Short_Integer; pragma Import (Ada, E139, "ada__finalization_E"); + E138 : Short_Integer; pragma Import (Ada, E138, "system__file_io_E"); + E191 : Short_Integer; pragma Import (Ada, E191, "system__storage_pools_E"); + E225 : Short_Integer; pragma Import (Ada, E225, "system__storage_pools__subpools_E"); + E219 : Short_Integer; pragma Import (Ada, E219, "ada__strings__unbounded_E"); + E270 : Short_Integer; pragma Import (Ada, E270, "system__task_info_E"); + E182 : Short_Integer; pragma Import (Ada, E182, "ada__calendar_E"); + E134 : Short_Integer; pragma Import (Ada, E134, "ada__text_io_E"); + E264 : Short_Integer; pragma Import (Ada, E264, "system__task_primitives__operations_E"); + E187 : Short_Integer; pragma Import (Ada, E187, "system__pool_global_E"); + E217 : Short_Integer; pragma Import (Ada, E217, "tinyaml_E"); + E119 : Short_Integer; pragma Import (Ada, E119, "aunit_E"); + E121 : Short_Integer; pragma Import (Ada, E121, "aunit__memory_E"); + E172 : Short_Integer; pragma Import (Ada, E172, "aunit__memory__utils_E"); + E169 : Short_Integer; pragma Import (Ada, E169, "ada_containers__aunit_lists_E"); + E185 : Short_Integer; pragma Import (Ada, E185, "aunit__tests_E"); + E176 : Short_Integer; pragma Import (Ada, E176, "aunit__time_measure_E"); + E174 : Short_Integer; pragma Import (Ada, E174, "aunit__test_results_E"); + E167 : Short_Integer; pragma Import (Ada, E167, "aunit__assertions_E"); + E163 : Short_Integer; pragma Import (Ada, E163, "aunit__test_filters_E"); + E165 : Short_Integer; pragma Import (Ada, E165, "aunit__simple_test_cases_E"); + E123 : Short_Integer; pragma Import (Ada, E123, "aunit__reporter_E"); + E205 : Short_Integer; pragma Import (Ada, E205, "aunit__reporter__text_E"); + E231 : Short_Integer; pragma Import (Ada, E231, "aunit__test_cases_E"); + E213 : Short_Integer; pragma Import (Ada, E213, "aunit__test_suites_E"); + E211 : Short_Integer; pragma Import (Ada, E211, "aunit__run_E"); + E229 : Short_Integer; pragma Import (Ada, E229, "tinyaml__lexer_E"); + E223 : Short_Integer; pragma Import (Ada, E223, "tinyaml__lexer_tests_E"); + E237 : Short_Integer; pragma Import (Ada, E237, "tinyaml__nodes_E"); + E243 : Short_Integer; pragma Import (Ada, E243, "tinyaml__nodes__map_E"); + E245 : Short_Integer; pragma Import (Ada, E245, "tinyaml__nodes__sequence_E"); + E235 : Short_Integer; pragma Import (Ada, E235, "tinyaml__documents_E"); + E254 : Short_Integer; pragma Import (Ada, E254, "tinyaml__nodes__scalar_E"); + E252 : Short_Integer; pragma Import (Ada, E252, "tinyaml__nodes__navigation_E"); + E256 : Short_Integer; pragma Import (Ada, E256, "tinyaml__parser_E"); + E233 : Short_Integer; pragma Import (Ada, E233, "tinyaml__parser_tests_E"); + E282 : Short_Integer; pragma Import (Ada, E282, "tinyaml__schemas_E"); + E285 : Short_Integer; pragma Import (Ada, E285, "tinyaml__schemas__any_E"); + E287 : Short_Integer; pragma Import (Ada, E287, "tinyaml__schemas__bool_E"); + E297 : Short_Integer; pragma Import (Ada, E297, "tinyaml__schemas__constraints_E"); + E299 : Short_Integer; pragma Import (Ada, E299, "tinyaml__schemas__constraints__range_constraint_E"); + E303 : Short_Integer; pragma Import (Ada, E303, "tinyaml__schemas__enum_E"); + E289 : Short_Integer; pragma Import (Ada, E289, "tinyaml__schemas__flt_E"); + E296 : Short_Integer; pragma Import (Ada, E296, "tinyaml__schemas__int_E"); + E305 : Short_Integer; pragma Import (Ada, E305, "tinyaml__schemas__seq_E"); + E284 : Short_Integer; pragma Import (Ada, E284, "tinyaml__schemas__map_E"); + E301 : Short_Integer; pragma Import (Ada, E301, "tinyaml__schemas__str_E"); + E308 : Short_Integer; pragma Import (Ada, E308, "tinyaml__validation_E"); + E280 : Short_Integer; pragma Import (Ada, E280, "tinyaml__validation_tests_E"); + E215 : Short_Integer; pragma Import (Ada, E215, "tinyaml_tests_E"); + + Sec_Default_Sized_Stacks : array (1 .. 1) of aliased System.Secondary_Stack.SS_Stack (System.Parameters.Runtime_Default_Sec_Stack_Size); + + Local_Priority_Specific_Dispatching : constant String := ""; + Local_Interrupt_States : constant String := ""; + + Is_Elaborated : Boolean := False; + + procedure finalize_library is + begin + declare + procedure F1; + pragma Import (Ada, F1, "tinyaml__validation_tests__finalize_body"); + begin + E280 := E280 - 1; + F1; + end; + declare + procedure F2; + pragma Import (Ada, F2, "tinyaml__validation_tests__finalize_spec"); + begin + F2; + end; + E308 := E308 - 1; + declare + procedure F3; + pragma Import (Ada, F3, "tinyaml__validation__finalize_spec"); + begin + F3; + end; + E284 := E284 - 1; + E301 := E301 - 1; + declare + procedure F4; + pragma Import (Ada, F4, "tinyaml__schemas__str__finalize_spec"); + begin + F4; + end; + E282 := E282 - 1; + declare + procedure F5; + pragma Import (Ada, F5, "tinyaml__schemas__map__finalize_spec"); + begin + F5; + end; + E305 := E305 - 1; + declare + procedure F6; + pragma Import (Ada, F6, "tinyaml__schemas__seq__finalize_spec"); + begin + F6; + end; + E296 := E296 - 1; + declare + procedure F7; + pragma Import (Ada, F7, "tinyaml__schemas__int__finalize_spec"); + begin + F7; + end; + E289 := E289 - 1; + declare + procedure F8; + pragma Import (Ada, F8, "tinyaml__schemas__flt__finalize_spec"); + begin + F8; + end; + E303 := E303 - 1; + declare + procedure F9; + pragma Import (Ada, F9, "tinyaml__schemas__enum__finalize_spec"); + begin + F9; + end; + E299 := E299 - 1; + declare + procedure F10; + pragma Import (Ada, F10, "tinyaml__schemas__constraints__range_constraint__finalize_spec"); + begin + F10; + end; + E287 := E287 - 1; + declare + procedure F11; + pragma Import (Ada, F11, "tinyaml__schemas__bool__finalize_spec"); + begin + F11; + end; + declare + procedure F12; + pragma Import (Ada, F12, "tinyaml__schemas__any__finalize_spec"); + begin + E285 := E285 - 1; + F12; + end; + declare + procedure F13; + pragma Import (Ada, F13, "tinyaml__schemas__finalize_spec"); + begin + F13; + end; + declare + procedure F14; + pragma Import (Ada, F14, "tinyaml__parser_tests__finalize_body"); + begin + E233 := E233 - 1; + F14; + end; + declare + procedure F15; + pragma Import (Ada, F15, "tinyaml__parser_tests__finalize_spec"); + begin + F15; + end; + E254 := E254 - 1; + declare + procedure F16; + pragma Import (Ada, F16, "tinyaml__nodes__scalar__finalize_spec"); + begin + F16; + end; + E235 := E235 - 1; + declare + procedure F17; + pragma Import (Ada, F17, "tinyaml__documents__finalize_spec"); + begin + F17; + end; + E237 := E237 - 1; + E245 := E245 - 1; + declare + procedure F18; + pragma Import (Ada, F18, "tinyaml__nodes__sequence__finalize_spec"); + begin + F18; + end; + E243 := E243 - 1; + declare + procedure F19; + pragma Import (Ada, F19, "tinyaml__nodes__map__finalize_spec"); + begin + F19; + end; + declare + procedure F20; + pragma Import (Ada, F20, "tinyaml__nodes__finalize_spec"); + begin + F20; + end; + declare + procedure F21; + pragma Import (Ada, F21, "tinyaml__lexer_tests__finalize_body"); + begin + E223 := E223 - 1; + F21; + end; + declare + procedure F22; + pragma Import (Ada, F22, "tinyaml__lexer_tests__finalize_spec"); + begin + F22; + end; + E213 := E213 - 1; + declare + procedure F23; + pragma Import (Ada, F23, "aunit__test_suites__finalize_spec"); + begin + F23; + end; + E231 := E231 - 1; + declare + procedure F24; + pragma Import (Ada, F24, "aunit__test_cases__finalize_spec"); + begin + F24; + end; + E205 := E205 - 1; + declare + procedure F25; + pragma Import (Ada, F25, "aunit__reporter__text__finalize_spec"); + begin + F25; + end; + E163 := E163 - 1; + E165 := E165 - 1; + declare + procedure F26; + pragma Import (Ada, F26, "aunit__simple_test_cases__finalize_spec"); + begin + F26; + end; + declare + procedure F27; + pragma Import (Ada, F27, "aunit__test_filters__finalize_spec"); + begin + F27; + end; + E167 := E167 - 1; + declare + procedure F28; + pragma Import (Ada, F28, "aunit__assertions__finalize_spec"); + begin + F28; + end; + E174 := E174 - 1; + declare + procedure F29; + pragma Import (Ada, F29, "aunit__test_results__finalize_spec"); + begin + F29; + end; + declare + procedure F30; + pragma Import (Ada, F30, "aunit__tests__finalize_spec"); + begin + E185 := E185 - 1; + F30; + end; + E187 := E187 - 1; + declare + procedure F31; + pragma Import (Ada, F31, "system__pool_global__finalize_spec"); + begin + F31; + end; + E134 := E134 - 1; + declare + procedure F32; + pragma Import (Ada, F32, "ada__text_io__finalize_spec"); + begin + F32; + end; + E219 := E219 - 1; + declare + procedure F33; + pragma Import (Ada, F33, "ada__strings__unbounded__finalize_spec"); + begin + F33; + end; + E225 := E225 - 1; + declare + procedure F34; + pragma Import (Ada, F34, "system__storage_pools__subpools__finalize_spec"); + begin + F34; + end; + declare + procedure F35; + pragma Import (Ada, F35, "system__file_io__finalize_body"); + begin + E138 := E138 - 1; + F35; + end; + declare + procedure Reraise_Library_Exception_If_Any; + pragma Import (Ada, Reraise_Library_Exception_If_Any, "__gnat_reraise_library_exception_if_any"); + begin + Reraise_Library_Exception_If_Any; + end; + end finalize_library; + + procedure adafinal is + procedure s_stalib_adafinal; + pragma Import (Ada, s_stalib_adafinal, "system__standard_library__adafinal"); + + procedure Runtime_Finalize; + pragma Import (C, Runtime_Finalize, "__gnat_runtime_finalize"); + + begin + if not Is_Elaborated then + return; + end if; + Is_Elaborated := False; + Runtime_Finalize; + s_stalib_adafinal; + end adafinal; + + type No_Param_Proc is access procedure; + pragma Favor_Top_Level (No_Param_Proc); + + procedure adainit is + Main_Priority : Integer; + pragma Import (C, Main_Priority, "__gl_main_priority"); + Time_Slice_Value : Integer; + pragma Import (C, Time_Slice_Value, "__gl_time_slice_val"); + WC_Encoding : Character; + pragma Import (C, WC_Encoding, "__gl_wc_encoding"); + Locking_Policy : Character; + pragma Import (C, Locking_Policy, "__gl_locking_policy"); + Queuing_Policy : Character; + pragma Import (C, Queuing_Policy, "__gl_queuing_policy"); + Task_Dispatching_Policy : Character; + pragma Import (C, Task_Dispatching_Policy, "__gl_task_dispatching_policy"); + Priority_Specific_Dispatching : System.Address; + pragma Import (C, Priority_Specific_Dispatching, "__gl_priority_specific_dispatching"); + Num_Specific_Dispatching : Integer; + pragma Import (C, Num_Specific_Dispatching, "__gl_num_specific_dispatching"); + Main_CPU : Integer; + pragma Import (C, Main_CPU, "__gl_main_cpu"); + Interrupt_States : System.Address; + pragma Import (C, Interrupt_States, "__gl_interrupt_states"); + Num_Interrupt_States : Integer; + pragma Import (C, Num_Interrupt_States, "__gl_num_interrupt_states"); + Unreserve_All_Interrupts : Integer; + pragma Import (C, Unreserve_All_Interrupts, "__gl_unreserve_all_interrupts"); + Exception_Tracebacks : Integer; + pragma Import (C, Exception_Tracebacks, "__gl_exception_tracebacks"); + Exception_Tracebacks_Symbolic : Integer; + pragma Import (C, Exception_Tracebacks_Symbolic, "__gl_exception_tracebacks_symbolic"); + Detect_Blocking : Integer; + pragma Import (C, Detect_Blocking, "__gl_detect_blocking"); + Default_Stack_Size : Integer; + pragma Import (C, Default_Stack_Size, "__gl_default_stack_size"); + Default_Secondary_Stack_Size : System.Parameters.Size_Type; + pragma Import (C, Default_Secondary_Stack_Size, "__gnat_default_ss_size"); + Bind_Env_Addr : System.Address; + pragma Import (C, Bind_Env_Addr, "__gl_bind_env_addr"); + Interrupts_Default_To_System : Integer; + pragma Import (C, Interrupts_Default_To_System, "__gl_interrupts_default_to_system"); + + procedure Runtime_Initialize (Install_Handler : Integer); + pragma Import (C, Runtime_Initialize, "__gnat_runtime_initialize"); + + procedure Tasking_Runtime_Initialize; + pragma Import (C, Tasking_Runtime_Initialize, "__gnat_tasking_runtime_initialize"); + + Finalize_Library_Objects : No_Param_Proc; + pragma Import (C, Finalize_Library_Objects, "__gnat_finalize_library_objects"); + Binder_Sec_Stacks_Count : Natural; + pragma Import (Ada, Binder_Sec_Stacks_Count, "__gnat_binder_ss_count"); + Default_Sized_SS_Pool : System.Address; + pragma Import (Ada, Default_Sized_SS_Pool, "__gnat_default_ss_pool"); + + begin + if Is_Elaborated then + return; + end if; + Is_Elaborated := True; + Main_Priority := -1; + Time_Slice_Value := -1; + WC_Encoding := 'b'; + Locking_Policy := ' '; + Queuing_Policy := ' '; + Task_Dispatching_Policy := ' '; + Priority_Specific_Dispatching := + Local_Priority_Specific_Dispatching'Address; + Num_Specific_Dispatching := 0; + Main_CPU := -1; + Interrupt_States := Local_Interrupt_States'Address; + Num_Interrupt_States := 0; + Unreserve_All_Interrupts := 0; + Exception_Tracebacks := 1; + Exception_Tracebacks_Symbolic := 1; + Detect_Blocking := 0; + Default_Stack_Size := -1; + + ada_main'Elab_Body; + Default_Secondary_Stack_Size := System.Parameters.Runtime_Default_Sec_Stack_Size; + Binder_Sec_Stacks_Count := 1; + Default_Sized_SS_Pool := Sec_Default_Sized_Stacks'Address; + + Runtime_Initialize (1); + Tasking_Runtime_Initialize; + + Finalize_Library_Objects := finalize_library'access; + + Ada.Exceptions'Elab_Spec; + System.Soft_Links'Elab_Spec; + System.Exception_Table'Elab_Body; + E010 := E010 + 1; + Ada.Containers'Elab_Spec; + E035 := E035 + 1; + Ada.Io_Exceptions'Elab_Spec; + E066 := E066 + 1; + Ada.Numerics'Elab_Spec; + E025 := E025 + 1; + Ada.Strings'Elab_Spec; + E007 := E007 + 1; + Ada.Strings.Maps'Elab_Spec; + E053 := E053 + 1; + Ada.Strings.Maps.Constants'Elab_Spec; + E056 := E056 + 1; + Interfaces.C'Elab_Spec; + E040 := E040 + 1; + System.Exceptions'Elab_Spec; + E019 := E019 + 1; + System.Object_Reader'Elab_Spec; + E082 := E082 + 1; + System.Dwarf_Lines'Elab_Spec; + E047 := E047 + 1; + System.Os_Lib'Elab_Body; + E071 := E071 + 1; + System.Soft_Links.Initialize'Elab_Body; + E101 := E101 + 1; + E012 := E012 + 1; + System.Traceback.Symbolic'Elab_Body; + E034 := E034 + 1; + E016 := E016 + 1; + Ada.Assertions'Elab_Spec; + E241 := E241 + 1; + Ada.Strings.Utf_Encoding'Elab_Spec; + E105 := E105 + 1; + Ada.Tags'Elab_Spec; + Ada.Tags'Elab_Body; + E113 := E113 + 1; + Ada.Strings.Text_Buffers'Elab_Spec; + E005 := E005 + 1; + Gnat'Elab_Spec; + E192 := E192 + 1; + Ada.Streams'Elab_Spec; + E125 := E125 + 1; + System.File_Control_Block'Elab_Spec; + E146 := E146 + 1; + System.Finalization_Root'Elab_Spec; + E141 := E141 + 1; + Ada.Finalization'Elab_Spec; + E139 := E139 + 1; + System.File_Io'Elab_Body; + E138 := E138 + 1; + System.Storage_Pools'Elab_Spec; + E191 := E191 + 1; + System.Storage_Pools.Subpools'Elab_Spec; + E225 := E225 + 1; + Ada.Strings.Unbounded'Elab_Spec; + E219 := E219 + 1; + System.Task_Info'Elab_Spec; + E270 := E270 + 1; + Ada.Calendar'Elab_Spec; + Ada.Calendar'Elab_Body; + E182 := E182 + 1; + Ada.Text_Io'Elab_Spec; + Ada.Text_Io'Elab_Body; + E134 := E134 + 1; + System.Task_Primitives.Operations'Elab_Body; + E264 := E264 + 1; + System.Pool_Global'Elab_Spec; + E187 := E187 + 1; + Tinyaml'Elab_Spec; + E217 := E217 + 1; + E121 := E121 + 1; + E119 := E119 + 1; + E172 := E172 + 1; + E169 := E169 + 1; + Aunit.Tests'Elab_Spec; + E185 := E185 + 1; + Aunit.Time_Measure'Elab_Spec; + E176 := E176 + 1; + Aunit.Test_Results'Elab_Spec; + E174 := E174 + 1; + Aunit.Assertions'Elab_Spec; + Aunit.Assertions'Elab_Body; + E167 := E167 + 1; + Aunit.Test_Filters'Elab_Spec; + Aunit.Simple_Test_Cases'Elab_Spec; + E165 := E165 + 1; + E163 := E163 + 1; + Aunit.Reporter'Elab_Spec; + E123 := E123 + 1; + Aunit.Reporter.Text'Elab_Spec; + E205 := E205 + 1; + Aunit.Test_Cases'Elab_Spec; + E231 := E231 + 1; + Aunit.Test_Suites'Elab_Spec; + E213 := E213 + 1; + E211 := E211 + 1; + E229 := E229 + 1; + Tinyaml.Lexer_Tests'Elab_Spec; + Tinyaml.Lexer_Tests'Elab_Body; + E223 := E223 + 1; + Tinyaml.Nodes'Elab_Spec; + Tinyaml.Nodes.Map'Elab_Spec; + Tinyaml.Nodes.Map'Elab_Body; + E243 := E243 + 1; + Tinyaml.Nodes.Sequence'Elab_Spec; + Tinyaml.Nodes.Sequence'Elab_Body; + E245 := E245 + 1; + Tinyaml.Nodes'Elab_Body; + E237 := E237 + 1; + Tinyaml.Documents'Elab_Spec; + Tinyaml.Documents'Elab_Body; + E235 := E235 + 1; + Tinyaml.Nodes.Scalar'Elab_Spec; + Tinyaml.Nodes.Scalar'Elab_Body; + E254 := E254 + 1; + E252 := E252 + 1; + E256 := E256 + 1; + Tinyaml.Parser_Tests'Elab_Spec; + Tinyaml.Parser_Tests'Elab_Body; + E233 := E233 + 1; + Tinyaml.Schemas'Elab_Spec; + Tinyaml.Schemas.Any'Elab_Spec; + E285 := E285 + 1; + Tinyaml.Schemas.Bool'Elab_Spec; + Tinyaml.Schemas.Bool'Elab_Body; + E287 := E287 + 1; + Tinyaml.Schemas.Constraints'Elab_Spec; + E297 := E297 + 1; + Tinyaml.Schemas.Constraints.Range_Constraint'Elab_Spec; + Tinyaml.Schemas.Constraints.Range_Constraint'Elab_Body; + E299 := E299 + 1; + Tinyaml.Schemas.Enum'Elab_Spec; + Tinyaml.Schemas.Enum'Elab_Body; + E303 := E303 + 1; + Tinyaml.Schemas.Flt'Elab_Spec; + Tinyaml.Schemas.Flt'Elab_Body; + E289 := E289 + 1; + Tinyaml.Schemas.Int'Elab_Spec; + Tinyaml.Schemas.Int'Elab_Body; + E296 := E296 + 1; + Tinyaml.Schemas.Seq'Elab_Spec; + Tinyaml.Schemas.Seq'Elab_Body; + E305 := E305 + 1; + Tinyaml.Schemas.Map'Elab_Spec; + Tinyaml.Schemas'Elab_Body; + E282 := E282 + 1; + Tinyaml.Schemas.Str'Elab_Spec; + Tinyaml.Schemas.Str'Elab_Body; + E301 := E301 + 1; + Tinyaml.Schemas.Map'Elab_Body; + E284 := E284 + 1; + Tinyaml.Validation'Elab_Spec; + Tinyaml.Validation'Elab_Body; + E308 := E308 + 1; + Tinyaml.Validation_Tests'Elab_Spec; + Tinyaml.Validation_Tests'Elab_Body; + E280 := E280 + 1; + E215 := E215 + 1; + end adainit; + + procedure Ada_Main_Program; + pragma Import (Ada, Ada_Main_Program, "_ada_test_runner"); + + function main + (argc : Integer; + argv : System.Address; + envp : System.Address) + return Integer + is + procedure Initialize (Addr : System.Address); + pragma Import (C, Initialize, "__gnat_initialize"); + + procedure Finalize; + pragma Import (C, Finalize, "__gnat_finalize"); + SEH : aliased array (1 .. 2) of Integer; + + Ensure_Reference : aliased System.Address := Ada_Main_Program_Name'Address; + pragma Volatile (Ensure_Reference); + + begin + if gnat_argc = 0 then + gnat_argc := argc; + gnat_argv := argv; + end if; + gnat_envp := envp; + + Initialize (SEH'Address); + adainit; + Ada_Main_Program; + adafinal; + Finalize; + return (gnat_exit_status); + end; + +-- BEGIN Object file/option list + -- /var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml-lexer_tests.o + -- /var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml-parser_tests.o + -- /var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml-validation_tests.o + -- /var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml_tests.o + -- /var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/test_runner.o + -- -L/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/ + -- -L/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/ + -- -L/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/lib/ + -- -L/var/home/geewiz/.local/share/alire/builds/aunit_26.0.0_b882e96a/78c67a8b011e08e5500962fc633efb7809a9c7391b64fc383bbaebb1096eadc4/lib/aunit/native-full/ + -- -L/var/home/geewiz/.local/share/alire/toolchains/gnat_native_15.2.1_4640d4b3/lib/gcc/x86_64-pc-linux-gnu/15.2.0/adalib/ + -- -static + -- -lgnarl + -- -lgnat + -- -lrt + -- -lpthread + -- -ldl +-- END Object file/option list + +end ada_main; diff --git a/tests/obj/b__test_runner.ads b/tests/obj/b__test_runner.ads new file mode 100644 index 0000000..8f2b263 --- /dev/null +++ b/tests/obj/b__test_runner.ads @@ -0,0 +1,971 @@ +pragma Warnings (Off); +pragma Ada_95; +with System; +with System.Parameters; +with System.Secondary_Stack; +package ada_main is + + gnat_argc : Integer; + gnat_argv : System.Address; + gnat_envp : System.Address; + + pragma Import (C, gnat_argc); + pragma Import (C, gnat_argv); + pragma Import (C, gnat_envp); + + gnat_exit_status : Integer; + pragma Import (C, gnat_exit_status); + + GNAT_Version : constant String := + "GNAT Version: 15.2.0" & ASCII.NUL; + pragma Export (C, GNAT_Version, "__gnat_version"); + + GNAT_Version_Address : constant System.Address := GNAT_Version'Address; + pragma Export (C, GNAT_Version_Address, "__gnat_version_address"); + + Ada_Main_Program_Name : constant String := "_ada_test_runner" & ASCII.NUL; + pragma Export (C, Ada_Main_Program_Name, "__gnat_ada_main_program_name"); + + procedure adainit; + pragma Export (C, adainit, "adainit"); + + procedure adafinal; + pragma Export (C, adafinal, "adafinal"); + + function main + (argc : Integer; + argv : System.Address; + envp : System.Address) + return Integer; + pragma Export (C, main, "main"); + + type Version_32 is mod 2 ** 32; + u00001 : constant Version_32 := 16#f755a64b#; + pragma Export (C, u00001, "test_runnerB"); + u00002 : constant Version_32 := 16#b2cfab41#; + pragma Export (C, u00002, "system__standard_libraryB"); + u00003 : constant Version_32 := 16#0626cc96#; + pragma Export (C, u00003, "system__standard_libraryS"); + u00004 : constant Version_32 := 16#a201b8c5#; + pragma Export (C, u00004, "ada__strings__text_buffersB"); + u00005 : constant Version_32 := 16#a7cfd09b#; + pragma Export (C, u00005, "ada__strings__text_buffersS"); + u00006 : constant Version_32 := 16#76789da1#; + pragma Export (C, u00006, "adaS"); + u00007 : constant Version_32 := 16#e6d4fa36#; + pragma Export (C, u00007, "ada__stringsS"); + u00008 : constant Version_32 := 16#14286b0f#; + pragma Export (C, u00008, "systemS"); + u00009 : constant Version_32 := 16#45e1965e#; + pragma Export (C, u00009, "system__exception_tableB"); + u00010 : constant Version_32 := 16#99031d16#; + pragma Export (C, u00010, "system__exception_tableS"); + u00011 : constant Version_32 := 16#7fa0a598#; + pragma Export (C, u00011, "system__soft_linksB"); + u00012 : constant Version_32 := 16#c7a3de26#; + pragma Export (C, u00012, "system__soft_linksS"); + u00013 : constant Version_32 := 16#d0b087d0#; + pragma Export (C, u00013, "system__secondary_stackB"); + u00014 : constant Version_32 := 16#bae33a03#; + pragma Export (C, u00014, "system__secondary_stackS"); + u00015 : constant Version_32 := 16#57ff5296#; + pragma Export (C, u00015, "ada__exceptionsB"); + u00016 : constant Version_32 := 16#64d9391c#; + pragma Export (C, u00016, "ada__exceptionsS"); + u00017 : constant Version_32 := 16#85bf25f7#; + pragma Export (C, u00017, "ada__exceptions__last_chance_handlerB"); + u00018 : constant Version_32 := 16#a028f72d#; + pragma Export (C, u00018, "ada__exceptions__last_chance_handlerS"); + u00019 : constant Version_32 := 16#268dd43d#; + pragma Export (C, u00019, "system__exceptionsS"); + u00020 : constant Version_32 := 16#c367aa24#; + pragma Export (C, u00020, "system__exceptions__machineB"); + u00021 : constant Version_32 := 16#ec13924a#; + pragma Export (C, u00021, "system__exceptions__machineS"); + u00022 : constant Version_32 := 16#7706238d#; + pragma Export (C, u00022, "system__exceptions_debugB"); + u00023 : constant Version_32 := 16#2426335c#; + pragma Export (C, u00023, "system__exceptions_debugS"); + u00024 : constant Version_32 := 16#36b7284e#; + pragma Export (C, u00024, "system__img_intS"); + u00025 : constant Version_32 := 16#f2c63a02#; + pragma Export (C, u00025, "ada__numericsS"); + u00026 : constant Version_32 := 16#174f5472#; + pragma Export (C, u00026, "ada__numerics__big_numbersS"); + u00027 : constant Version_32 := 16#ee021456#; + pragma Export (C, u00027, "system__unsigned_typesS"); + u00028 : constant Version_32 := 16#d8f6bfe7#; + pragma Export (C, u00028, "system__storage_elementsS"); + u00029 : constant Version_32 := 16#5c7d9c20#; + pragma Export (C, u00029, "system__tracebackB"); + u00030 : constant Version_32 := 16#92b29fb2#; + pragma Export (C, u00030, "system__tracebackS"); + u00031 : constant Version_32 := 16#5f6b6486#; + pragma Export (C, u00031, "system__traceback_entriesB"); + u00032 : constant Version_32 := 16#dc34d483#; + pragma Export (C, u00032, "system__traceback_entriesS"); + u00033 : constant Version_32 := 16#38e5c42b#; + pragma Export (C, u00033, "system__traceback__symbolicB"); + u00034 : constant Version_32 := 16#140ceb78#; + pragma Export (C, u00034, "system__traceback__symbolicS"); + u00035 : constant Version_32 := 16#179d7d28#; + pragma Export (C, u00035, "ada__containersS"); + u00036 : constant Version_32 := 16#701f9d88#; + pragma Export (C, u00036, "ada__exceptions__tracebackB"); + u00037 : constant Version_32 := 16#26ed0985#; + pragma Export (C, u00037, "ada__exceptions__tracebackS"); + u00038 : constant Version_32 := 16#9111f9c1#; + pragma Export (C, u00038, "interfacesS"); + u00039 : constant Version_32 := 16#401f6fd6#; + pragma Export (C, u00039, "interfaces__cB"); + u00040 : constant Version_32 := 16#59e2f8b5#; + pragma Export (C, u00040, "interfaces__cS"); + u00041 : constant Version_32 := 16#a43efea2#; + pragma Export (C, u00041, "system__parametersB"); + u00042 : constant Version_32 := 16#21bf971e#; + pragma Export (C, u00042, "system__parametersS"); + u00043 : constant Version_32 := 16#0978786d#; + pragma Export (C, u00043, "system__bounded_stringsB"); + u00044 : constant Version_32 := 16#63d54a16#; + pragma Export (C, u00044, "system__bounded_stringsS"); + u00045 : constant Version_32 := 16#9f0c0c80#; + pragma Export (C, u00045, "system__crtlS"); + u00046 : constant Version_32 := 16#799f87ee#; + pragma Export (C, u00046, "system__dwarf_linesB"); + u00047 : constant Version_32 := 16#6c65bf08#; + pragma Export (C, u00047, "system__dwarf_linesS"); + u00048 : constant Version_32 := 16#5b4659fa#; + pragma Export (C, u00048, "ada__charactersS"); + u00049 : constant Version_32 := 16#9de61c25#; + pragma Export (C, u00049, "ada__characters__handlingB"); + u00050 : constant Version_32 := 16#729cc5db#; + pragma Export (C, u00050, "ada__characters__handlingS"); + u00051 : constant Version_32 := 16#cde9ea2d#; + pragma Export (C, u00051, "ada__characters__latin_1S"); + u00052 : constant Version_32 := 16#203d5282#; + pragma Export (C, u00052, "ada__strings__mapsB"); + u00053 : constant Version_32 := 16#6feaa257#; + pragma Export (C, u00053, "ada__strings__mapsS"); + u00054 : constant Version_32 := 16#b451a498#; + pragma Export (C, u00054, "system__bit_opsB"); + u00055 : constant Version_32 := 16#d9dbc733#; + pragma Export (C, u00055, "system__bit_opsS"); + u00056 : constant Version_32 := 16#b459efcb#; + pragma Export (C, u00056, "ada__strings__maps__constantsS"); + u00057 : constant Version_32 := 16#f9910acc#; + pragma Export (C, u00057, "system__address_imageB"); + u00058 : constant Version_32 := 16#b5c4f635#; + pragma Export (C, u00058, "system__address_imageS"); + u00059 : constant Version_32 := 16#219681aa#; + pragma Export (C, u00059, "system__img_address_32S"); + u00060 : constant Version_32 := 16#0cb62028#; + pragma Export (C, u00060, "system__img_address_64S"); + u00061 : constant Version_32 := 16#7da15eb1#; + pragma Export (C, u00061, "system__img_unsS"); + u00062 : constant Version_32 := 16#20ec7aa3#; + pragma Export (C, u00062, "system__ioB"); + u00063 : constant Version_32 := 16#8a6a9c40#; + pragma Export (C, u00063, "system__ioS"); + u00064 : constant Version_32 := 16#e15ca368#; + pragma Export (C, u00064, "system__mmapB"); + u00065 : constant Version_32 := 16#99159588#; + pragma Export (C, u00065, "system__mmapS"); + u00066 : constant Version_32 := 16#367911c4#; + pragma Export (C, u00066, "ada__io_exceptionsS"); + u00067 : constant Version_32 := 16#a2858c95#; + pragma Export (C, u00067, "system__mmap__os_interfaceB"); + u00068 : constant Version_32 := 16#48fa74ab#; + pragma Export (C, u00068, "system__mmap__os_interfaceS"); + u00069 : constant Version_32 := 16#f4289573#; + pragma Export (C, u00069, "system__mmap__unixS"); + u00070 : constant Version_32 := 16#c04dcb27#; + pragma Export (C, u00070, "system__os_libB"); + u00071 : constant Version_32 := 16#9143f49f#; + pragma Export (C, u00071, "system__os_libS"); + u00072 : constant Version_32 := 16#94d23d25#; + pragma Export (C, u00072, "system__atomic_operations__test_and_setB"); + u00073 : constant Version_32 := 16#57acee8e#; + pragma Export (C, u00073, "system__atomic_operations__test_and_setS"); + u00074 : constant Version_32 := 16#d34b112a#; + pragma Export (C, u00074, "system__atomic_operationsS"); + u00075 : constant Version_32 := 16#553a519e#; + pragma Export (C, u00075, "system__atomic_primitivesB"); + u00076 : constant Version_32 := 16#1cf8e0ec#; + pragma Export (C, u00076, "system__atomic_primitivesS"); + u00077 : constant Version_32 := 16#b98923bf#; + pragma Export (C, u00077, "system__case_utilB"); + u00078 : constant Version_32 := 16#db3bbc5a#; + pragma Export (C, u00078, "system__case_utilS"); + u00079 : constant Version_32 := 16#256dbbe5#; + pragma Export (C, u00079, "system__stringsB"); + u00080 : constant Version_32 := 16#8faa6b17#; + pragma Export (C, u00080, "system__stringsS"); + u00081 : constant Version_32 := 16#836ccd31#; + pragma Export (C, u00081, "system__object_readerB"); + u00082 : constant Version_32 := 16#18bcfe16#; + pragma Export (C, u00082, "system__object_readerS"); + u00083 : constant Version_32 := 16#75406883#; + pragma Export (C, u00083, "system__val_lliS"); + u00084 : constant Version_32 := 16#838eea00#; + pragma Export (C, u00084, "system__val_lluS"); + u00085 : constant Version_32 := 16#47d9a892#; + pragma Export (C, u00085, "system__sparkS"); + u00086 : constant Version_32 := 16#a571a4dc#; + pragma Export (C, u00086, "system__spark__cut_operationsB"); + u00087 : constant Version_32 := 16#629c0fb7#; + pragma Export (C, u00087, "system__spark__cut_operationsS"); + u00088 : constant Version_32 := 16#365e21c1#; + pragma Export (C, u00088, "system__val_utilB"); + u00089 : constant Version_32 := 16#97ef3a91#; + pragma Export (C, u00089, "system__val_utilS"); + u00090 : constant Version_32 := 16#382ef1e7#; + pragma Export (C, u00090, "system__exception_tracesB"); + u00091 : constant Version_32 := 16#f8b00269#; + pragma Export (C, u00091, "system__exception_tracesS"); + u00092 : constant Version_32 := 16#fd158a37#; + pragma Export (C, u00092, "system__wch_conB"); + u00093 : constant Version_32 := 16#cd2b486c#; + pragma Export (C, u00093, "system__wch_conS"); + u00094 : constant Version_32 := 16#5c289972#; + pragma Export (C, u00094, "system__wch_stwB"); + u00095 : constant Version_32 := 16#e03a646d#; + pragma Export (C, u00095, "system__wch_stwS"); + u00096 : constant Version_32 := 16#7cd63de5#; + pragma Export (C, u00096, "system__wch_cnvB"); + u00097 : constant Version_32 := 16#cbeb821c#; + pragma Export (C, u00097, "system__wch_cnvS"); + u00098 : constant Version_32 := 16#e538de43#; + pragma Export (C, u00098, "system__wch_jisB"); + u00099 : constant Version_32 := 16#7e5ce036#; + pragma Export (C, u00099, "system__wch_jisS"); + u00100 : constant Version_32 := 16#0286ce9f#; + pragma Export (C, u00100, "system__soft_links__initializeB"); + u00101 : constant Version_32 := 16#ac2e8b53#; + pragma Export (C, u00101, "system__soft_links__initializeS"); + u00102 : constant Version_32 := 16#8599b27b#; + pragma Export (C, u00102, "system__stack_checkingB"); + u00103 : constant Version_32 := 16#d3777e19#; + pragma Export (C, u00103, "system__stack_checkingS"); + u00104 : constant Version_32 := 16#8b7604c4#; + pragma Export (C, u00104, "ada__strings__utf_encodingB"); + u00105 : constant Version_32 := 16#c9e86997#; + pragma Export (C, u00105, "ada__strings__utf_encodingS"); + u00106 : constant Version_32 := 16#bb780f45#; + pragma Export (C, u00106, "ada__strings__utf_encoding__stringsB"); + u00107 : constant Version_32 := 16#b85ff4b6#; + pragma Export (C, u00107, "ada__strings__utf_encoding__stringsS"); + u00108 : constant Version_32 := 16#d1d1ed0b#; + pragma Export (C, u00108, "ada__strings__utf_encoding__wide_stringsB"); + u00109 : constant Version_32 := 16#5678478f#; + pragma Export (C, u00109, "ada__strings__utf_encoding__wide_stringsS"); + u00110 : constant Version_32 := 16#c2b98963#; + pragma Export (C, u00110, "ada__strings__utf_encoding__wide_wide_stringsB"); + u00111 : constant Version_32 := 16#d7af3358#; + pragma Export (C, u00111, "ada__strings__utf_encoding__wide_wide_stringsS"); + u00112 : constant Version_32 := 16#683e3bb7#; + pragma Export (C, u00112, "ada__tagsB"); + u00113 : constant Version_32 := 16#4ff764f3#; + pragma Export (C, u00113, "ada__tagsS"); + u00114 : constant Version_32 := 16#3548d972#; + pragma Export (C, u00114, "system__htableB"); + u00115 : constant Version_32 := 16#95f133e4#; + pragma Export (C, u00115, "system__htableS"); + u00116 : constant Version_32 := 16#1f1abe38#; + pragma Export (C, u00116, "system__string_hashB"); + u00117 : constant Version_32 := 16#32b4b39b#; + pragma Export (C, u00117, "system__string_hashS"); + u00118 : constant Version_32 := 16#442efae0#; + pragma Export (C, u00118, "aunitB"); + u00119 : constant Version_32 := 16#76cdf7c6#; + pragma Export (C, u00119, "aunitS"); + u00120 : constant Version_32 := 16#b6c145a2#; + pragma Export (C, u00120, "aunit__memoryB"); + u00121 : constant Version_32 := 16#c2d4cd8f#; + pragma Export (C, u00121, "aunit__memoryS"); + u00122 : constant Version_32 := 16#bd1125e3#; + pragma Export (C, u00122, "aunit__reporterB"); + u00123 : constant Version_32 := 16#7beb347d#; + pragma Export (C, u00123, "aunit__reporterS"); + u00124 : constant Version_32 := 16#b228eb1e#; + pragma Export (C, u00124, "ada__streamsB"); + u00125 : constant Version_32 := 16#613fe11c#; + pragma Export (C, u00125, "ada__streamsS"); + u00126 : constant Version_32 := 16#05222263#; + pragma Export (C, u00126, "system__put_imagesB"); + u00127 : constant Version_32 := 16#08866c10#; + pragma Export (C, u00127, "system__put_imagesS"); + u00128 : constant Version_32 := 16#22b9eb9f#; + pragma Export (C, u00128, "ada__strings__text_buffers__utilsB"); + u00129 : constant Version_32 := 16#89062ac3#; + pragma Export (C, u00129, "ada__strings__text_buffers__utilsS"); + u00130 : constant Version_32 := 16#4f37e837#; + pragma Export (C, u00130, "aunit__ioS"); + u00131 : constant Version_32 := 16#f64b89a4#; + pragma Export (C, u00131, "ada__integer_text_ioB"); + u00132 : constant Version_32 := 16#b4dc53db#; + pragma Export (C, u00132, "ada__integer_text_ioS"); + u00133 : constant Version_32 := 16#27ac21ac#; + pragma Export (C, u00133, "ada__text_ioB"); + u00134 : constant Version_32 := 16#04ab031f#; + pragma Export (C, u00134, "ada__text_ioS"); + u00135 : constant Version_32 := 16#1cacf006#; + pragma Export (C, u00135, "interfaces__c_streamsB"); + u00136 : constant Version_32 := 16#d07279c2#; + pragma Export (C, u00136, "interfaces__c_streamsS"); + u00137 : constant Version_32 := 16#ec2f4d1e#; + pragma Export (C, u00137, "system__file_ioB"); + u00138 : constant Version_32 := 16#72673e49#; + pragma Export (C, u00138, "system__file_ioS"); + u00139 : constant Version_32 := 16#c34b231e#; + pragma Export (C, u00139, "ada__finalizationS"); + u00140 : constant Version_32 := 16#d00f339c#; + pragma Export (C, u00140, "system__finalization_rootB"); + u00141 : constant Version_32 := 16#1e5455db#; + pragma Export (C, u00141, "system__finalization_rootS"); + u00142 : constant Version_32 := 16#ef3c5c6f#; + pragma Export (C, u00142, "system__finalization_primitivesB"); + u00143 : constant Version_32 := 16#927c01c5#; + pragma Export (C, u00143, "system__finalization_primitivesS"); + u00144 : constant Version_32 := 16#e8108c8c#; + pragma Export (C, u00144, "system__os_locksS"); + u00145 : constant Version_32 := 16#fbeae7f4#; + pragma Export (C, u00145, "system__os_constantsS"); + u00146 : constant Version_32 := 16#9e5df665#; + pragma Export (C, u00146, "system__file_control_blockS"); + u00147 : constant Version_32 := 16#5e511f79#; + pragma Export (C, u00147, "ada__text_io__generic_auxB"); + u00148 : constant Version_32 := 16#d2ac8a2d#; + pragma Export (C, u00148, "ada__text_io__generic_auxS"); + u00149 : constant Version_32 := 16#dddfe8f1#; + pragma Export (C, u00149, "system__img_biuS"); + u00150 : constant Version_32 := 16#90812f2f#; + pragma Export (C, u00150, "system__img_llbS"); + u00151 : constant Version_32 := 16#5eeebe35#; + pragma Export (C, u00151, "system__img_lliS"); + u00152 : constant Version_32 := 16#e770da5d#; + pragma Export (C, u00152, "system__img_lllbS"); + u00153 : constant Version_32 := 16#ad86ddd3#; + pragma Export (C, u00153, "system__img_llliS"); + u00154 : constant Version_32 := 16#ed04c351#; + pragma Export (C, u00154, "system__img_lllwS"); + u00155 : constant Version_32 := 16#ccb35a24#; + pragma Export (C, u00155, "system__img_llwS"); + u00156 : constant Version_32 := 16#e20553c3#; + pragma Export (C, u00156, "system__img_wiuS"); + u00157 : constant Version_32 := 16#aa0160a2#; + pragma Export (C, u00157, "system__val_intS"); + u00158 : constant Version_32 := 16#5da6ebca#; + pragma Export (C, u00158, "system__val_unsS"); + u00159 : constant Version_32 := 16#a5fee39b#; + pragma Export (C, u00159, "system__val_llliS"); + u00160 : constant Version_32 := 16#1e4a2c79#; + pragma Export (C, u00160, "system__val_llluS"); + u00161 : constant Version_32 := 16#e99cd447#; + pragma Export (C, u00161, "aunit__optionsS"); + u00162 : constant Version_32 := 16#e9d6512d#; + pragma Export (C, u00162, "aunit__test_filtersB"); + u00163 : constant Version_32 := 16#9a67cba8#; + pragma Export (C, u00163, "aunit__test_filtersS"); + u00164 : constant Version_32 := 16#6e9501f4#; + pragma Export (C, u00164, "aunit__simple_test_casesB"); + u00165 : constant Version_32 := 16#5a323d45#; + pragma Export (C, u00165, "aunit__simple_test_casesS"); + u00166 : constant Version_32 := 16#f1db610e#; + pragma Export (C, u00166, "aunit__assertionsB"); + u00167 : constant Version_32 := 16#f6326ff1#; + pragma Export (C, u00167, "aunit__assertionsS"); + u00168 : constant Version_32 := 16#df831941#; + pragma Export (C, u00168, "ada_containers__aunit_listsB"); + u00169 : constant Version_32 := 16#c8d9569a#; + pragma Export (C, u00169, "ada_containers__aunit_listsS"); + u00170 : constant Version_32 := 16#11329e00#; + pragma Export (C, u00170, "ada_containersS"); + u00171 : constant Version_32 := 16#9b1c7ff2#; + pragma Export (C, u00171, "aunit__memory__utilsB"); + u00172 : constant Version_32 := 16#fb2f6c57#; + pragma Export (C, u00172, "aunit__memory__utilsS"); + u00173 : constant Version_32 := 16#b891ec3b#; + pragma Export (C, u00173, "aunit__test_resultsB"); + u00174 : constant Version_32 := 16#c2a99f30#; + pragma Export (C, u00174, "aunit__test_resultsS"); + u00175 : constant Version_32 := 16#737bafa8#; + pragma Export (C, u00175, "aunit__time_measureB"); + u00176 : constant Version_32 := 16#eb2e5d34#; + pragma Export (C, u00176, "aunit__time_measureS"); + u00177 : constant Version_32 := 16#96a20755#; + pragma Export (C, u00177, "ada__strings__fixedB"); + u00178 : constant Version_32 := 16#11b694ce#; + pragma Export (C, u00178, "ada__strings__fixedS"); + u00179 : constant Version_32 := 16#b40d9bf2#; + pragma Export (C, u00179, "ada__strings__searchB"); + u00180 : constant Version_32 := 16#97fe4a15#; + pragma Export (C, u00180, "ada__strings__searchS"); + u00181 : constant Version_32 := 16#78511131#; + pragma Export (C, u00181, "ada__calendarB"); + u00182 : constant Version_32 := 16#c907a168#; + pragma Export (C, u00182, "ada__calendarS"); + u00183 : constant Version_32 := 16#d172d809#; + pragma Export (C, u00183, "system__os_primitivesB"); + u00184 : constant Version_32 := 16#13d50ef9#; + pragma Export (C, u00184, "system__os_primitivesS"); + u00185 : constant Version_32 := 16#6b6cea8f#; + pragma Export (C, u00185, "aunit__testsS"); + u00186 : constant Version_32 := 16#ae5b86de#; + pragma Export (C, u00186, "system__pool_globalB"); + u00187 : constant Version_32 := 16#a07c1f1e#; + pragma Export (C, u00187, "system__pool_globalS"); + u00188 : constant Version_32 := 16#0ddbd91f#; + pragma Export (C, u00188, "system__memoryB"); + u00189 : constant Version_32 := 16#0cbcf715#; + pragma Export (C, u00189, "system__memoryS"); + u00190 : constant Version_32 := 16#35d6ef80#; + pragma Export (C, u00190, "system__storage_poolsB"); + u00191 : constant Version_32 := 16#8e431254#; + pragma Export (C, u00191, "system__storage_poolsS"); + u00192 : constant Version_32 := 16#b5988c27#; + pragma Export (C, u00192, "gnatS"); + u00193 : constant Version_32 := 16#f299cac9#; + pragma Export (C, u00193, "gnat__source_infoS"); + u00194 : constant Version_32 := 16#931654a0#; + pragma Export (C, u00194, "gnat__tracebackB"); + u00195 : constant Version_32 := 16#c46c6d9b#; + pragma Export (C, u00195, "gnat__tracebackS"); + u00196 : constant Version_32 := 16#2086345e#; + pragma Export (C, u00196, "gnat__traceback__symbolicS"); + u00197 : constant Version_32 := 16#756a1fdd#; + pragma Export (C, u00197, "system__stream_attributesB"); + u00198 : constant Version_32 := 16#a8236f45#; + pragma Export (C, u00198, "system__stream_attributesS"); + u00199 : constant Version_32 := 16#1c617d0b#; + pragma Export (C, u00199, "system__stream_attributes__xdrB"); + u00200 : constant Version_32 := 16#e4218e58#; + pragma Export (C, u00200, "system__stream_attributes__xdrS"); + u00201 : constant Version_32 := 16#d71ab463#; + pragma Export (C, u00201, "system__fat_fltS"); + u00202 : constant Version_32 := 16#f128bd6e#; + pragma Export (C, u00202, "system__fat_lfltS"); + u00203 : constant Version_32 := 16#8bf81384#; + pragma Export (C, u00203, "system__fat_llfS"); + u00204 : constant Version_32 := 16#b61e55fe#; + pragma Export (C, u00204, "aunit__reporter__textB"); + u00205 : constant Version_32 := 16#1676cc84#; + pragma Export (C, u00205, "aunit__reporter__textS"); + u00206 : constant Version_32 := 16#afdc38b2#; + pragma Export (C, u00206, "system__arith_64B"); + u00207 : constant Version_32 := 16#509fabdd#; + pragma Export (C, u00207, "system__arith_64S"); + u00208 : constant Version_32 := 16#b0a247c9#; + pragma Export (C, u00208, "system__exn_intS"); + u00209 : constant Version_32 := 16#d79db92c#; + pragma Export (C, u00209, "system__return_stackS"); + u00210 : constant Version_32 := 16#4d723195#; + pragma Export (C, u00210, "aunit__runB"); + u00211 : constant Version_32 := 16#dc46304b#; + pragma Export (C, u00211, "aunit__runS"); + u00212 : constant Version_32 := 16#276e73f2#; + pragma Export (C, u00212, "aunit__test_suitesB"); + u00213 : constant Version_32 := 16#50924664#; + pragma Export (C, u00213, "aunit__test_suitesS"); + u00214 : constant Version_32 := 16#4007cd01#; + pragma Export (C, u00214, "tinyaml_testsB"); + u00215 : constant Version_32 := 16#64d90a3d#; + pragma Export (C, u00215, "tinyaml_testsS"); + u00216 : constant Version_32 := 16#a947be8f#; + pragma Export (C, u00216, "tinyamlB"); + u00217 : constant Version_32 := 16#c27301f7#; + pragma Export (C, u00217, "tinyamlS"); + u00218 : constant Version_32 := 16#4259a79c#; + pragma Export (C, u00218, "ada__strings__unboundedB"); + u00219 : constant Version_32 := 16#b40332b4#; + pragma Export (C, u00219, "ada__strings__unboundedS"); + u00220 : constant Version_32 := 16#52627794#; + pragma Export (C, u00220, "system__atomic_countersB"); + u00221 : constant Version_32 := 16#c83084cc#; + pragma Export (C, u00221, "system__atomic_countersS"); + u00222 : constant Version_32 := 16#a24f61e2#; + pragma Export (C, u00222, "tinyaml__lexer_testsB"); + u00223 : constant Version_32 := 16#925e1f4f#; + pragma Export (C, u00223, "tinyaml__lexer_testsS"); + u00224 : constant Version_32 := 16#690693e0#; + pragma Export (C, u00224, "system__storage_pools__subpoolsB"); + u00225 : constant Version_32 := 16#23a252fc#; + pragma Export (C, u00225, "system__storage_pools__subpoolsS"); + u00226 : constant Version_32 := 16#3676fd0b#; + pragma Export (C, u00226, "system__storage_pools__subpools__finalizationB"); + u00227 : constant Version_32 := 16#54c94065#; + pragma Export (C, u00227, "system__storage_pools__subpools__finalizationS"); + u00228 : constant Version_32 := 16#c2b4932a#; + pragma Export (C, u00228, "tinyaml__lexerB"); + u00229 : constant Version_32 := 16#3e9bf4a2#; + pragma Export (C, u00229, "tinyaml__lexerS"); + u00230 : constant Version_32 := 16#4c5eed8b#; + pragma Export (C, u00230, "aunit__test_casesB"); + u00231 : constant Version_32 := 16#1aa5f28d#; + pragma Export (C, u00231, "aunit__test_casesS"); + u00232 : constant Version_32 := 16#25bcafd3#; + pragma Export (C, u00232, "tinyaml__parser_testsB"); + u00233 : constant Version_32 := 16#aeae59ab#; + pragma Export (C, u00233, "tinyaml__parser_testsS"); + u00234 : constant Version_32 := 16#32bfbcad#; + pragma Export (C, u00234, "tinyaml__documentsB"); + u00235 : constant Version_32 := 16#5ae76fd2#; + pragma Export (C, u00235, "tinyaml__documentsS"); + u00236 : constant Version_32 := 16#bf83ff50#; + pragma Export (C, u00236, "tinyaml__nodesB"); + u00237 : constant Version_32 := 16#5348d7e9#; + pragma Export (C, u00237, "tinyaml__nodesS"); + u00238 : constant Version_32 := 16#e259c480#; + pragma Export (C, u00238, "system__assertionsB"); + u00239 : constant Version_32 := 16#322b1494#; + pragma Export (C, u00239, "system__assertionsS"); + u00240 : constant Version_32 := 16#8b2c6428#; + pragma Export (C, u00240, "ada__assertionsB"); + u00241 : constant Version_32 := 16#cc3ec2fd#; + pragma Export (C, u00241, "ada__assertionsS"); + u00242 : constant Version_32 := 16#6e3816c9#; + pragma Export (C, u00242, "tinyaml__nodes__mapB"); + u00243 : constant Version_32 := 16#d7a0eae5#; + pragma Export (C, u00243, "tinyaml__nodes__mapS"); + u00244 : constant Version_32 := 16#a83b2700#; + pragma Export (C, u00244, "tinyaml__nodes__sequenceB"); + u00245 : constant Version_32 := 16#61b272df#; + pragma Export (C, u00245, "tinyaml__nodes__sequenceS"); + u00246 : constant Version_32 := 16#c3b32edd#; + pragma Export (C, u00246, "ada__containers__helpersB"); + u00247 : constant Version_32 := 16#444c93c2#; + pragma Export (C, u00247, "ada__containers__helpersS"); + u00248 : constant Version_32 := 16#f4ca97ce#; + pragma Export (C, u00248, "ada__containers__red_black_treesS"); + u00249 : constant Version_32 := 16#b3f7543e#; + pragma Export (C, u00249, "system__strings__stream_opsB"); + u00250 : constant Version_32 := 16#46dadf54#; + pragma Export (C, u00250, "system__strings__stream_opsS"); + u00251 : constant Version_32 := 16#30690ef5#; + pragma Export (C, u00251, "tinyaml__nodes__navigationB"); + u00252 : constant Version_32 := 16#99e271c5#; + pragma Export (C, u00252, "tinyaml__nodes__navigationS"); + u00253 : constant Version_32 := 16#1f91cd5f#; + pragma Export (C, u00253, "tinyaml__nodes__scalarB"); + u00254 : constant Version_32 := 16#152816d9#; + pragma Export (C, u00254, "tinyaml__nodes__scalarS"); + u00255 : constant Version_32 := 16#fd6581dd#; + pragma Export (C, u00255, "tinyaml__parserB"); + u00256 : constant Version_32 := 16#8fe5c36a#; + pragma Export (C, u00256, "tinyaml__parserS"); + u00257 : constant Version_32 := 16#9351de22#; + pragma Export (C, u00257, "system__taskingB"); + u00258 : constant Version_32 := 16#82c55864#; + pragma Export (C, u00258, "system__taskingS"); + u00259 : constant Version_32 := 16#9022318b#; + pragma Export (C, u00259, "system__task_primitivesS"); + u00260 : constant Version_32 := 16#5c897da3#; + pragma Export (C, u00260, "system__os_interfaceB"); + u00261 : constant Version_32 := 16#5bee0e11#; + pragma Export (C, u00261, "system__os_interfaceS"); + u00262 : constant Version_32 := 16#fc760bf8#; + pragma Export (C, u00262, "system__linuxS"); + u00263 : constant Version_32 := 16#cf8f5d61#; + pragma Export (C, u00263, "system__task_primitives__operationsB"); + u00264 : constant Version_32 := 16#ef492e06#; + pragma Export (C, u00264, "system__task_primitives__operationsS"); + u00265 : constant Version_32 := 16#900fbd22#; + pragma Export (C, u00265, "system__interrupt_managementB"); + u00266 : constant Version_32 := 16#de9ae4af#; + pragma Export (C, u00266, "system__interrupt_managementS"); + u00267 : constant Version_32 := 16#73dc29bf#; + pragma Export (C, u00267, "system__multiprocessorsB"); + u00268 : constant Version_32 := 16#2c84f47c#; + pragma Export (C, u00268, "system__multiprocessorsS"); + u00269 : constant Version_32 := 16#4ee862d1#; + pragma Export (C, u00269, "system__task_infoB"); + u00270 : constant Version_32 := 16#cf451a05#; + pragma Export (C, u00270, "system__task_infoS"); + u00271 : constant Version_32 := 16#45653325#; + pragma Export (C, u00271, "system__tasking__debugB"); + u00272 : constant Version_32 := 16#104d3ae8#; + pragma Export (C, u00272, "system__tasking__debugS"); + u00273 : constant Version_32 := 16#ca878138#; + pragma Export (C, u00273, "system__concat_2B"); + u00274 : constant Version_32 := 16#a1d318f8#; + pragma Export (C, u00274, "system__concat_2S"); + u00275 : constant Version_32 := 16#752a67ed#; + pragma Export (C, u00275, "system__concat_3B"); + u00276 : constant Version_32 := 16#9e5272ad#; + pragma Export (C, u00276, "system__concat_3S"); + u00277 : constant Version_32 := 16#3066cab0#; + pragma Export (C, u00277, "system__stack_usageB"); + u00278 : constant Version_32 := 16#4a68f31e#; + pragma Export (C, u00278, "system__stack_usageS"); + u00279 : constant Version_32 := 16#1bb69cc0#; + pragma Export (C, u00279, "tinyaml__validation_testsB"); + u00280 : constant Version_32 := 16#68a97def#; + pragma Export (C, u00280, "tinyaml__validation_testsS"); + u00281 : constant Version_32 := 16#368b1889#; + pragma Export (C, u00281, "tinyaml__schemasB"); + u00282 : constant Version_32 := 16#6238b6cb#; + pragma Export (C, u00282, "tinyaml__schemasS"); + u00283 : constant Version_32 := 16#2ac92e78#; + pragma Export (C, u00283, "tinyaml__schemas__mapB"); + u00284 : constant Version_32 := 16#4dac805e#; + pragma Export (C, u00284, "tinyaml__schemas__mapS"); + u00285 : constant Version_32 := 16#3553bec6#; + pragma Export (C, u00285, "tinyaml__schemas__anyS"); + u00286 : constant Version_32 := 16#1d468b88#; + pragma Export (C, u00286, "tinyaml__schemas__boolB"); + u00287 : constant Version_32 := 16#6f50c939#; + pragma Export (C, u00287, "tinyaml__schemas__boolS"); + u00288 : constant Version_32 := 16#9afc96ca#; + pragma Export (C, u00288, "tinyaml__schemas__fltB"); + u00289 : constant Version_32 := 16#71d8e5e6#; + pragma Export (C, u00289, "tinyaml__schemas__fltS"); + u00290 : constant Version_32 := 16#2611fc39#; + pragma Export (C, u00290, "system__val_lfltS"); + u00291 : constant Version_32 := 16#0f79a52f#; + pragma Export (C, u00291, "system__exn_lfltS"); + u00292 : constant Version_32 := 16#1b28662b#; + pragma Export (C, u00292, "system__float_controlB"); + u00293 : constant Version_32 := 16#f4d42833#; + pragma Export (C, u00293, "system__float_controlS"); + u00294 : constant Version_32 := 16#b82039c7#; + pragma Export (C, u00294, "system__powten_lfltS"); + u00295 : constant Version_32 := 16#ce0c311e#; + pragma Export (C, u00295, "tinyaml__schemas__intB"); + u00296 : constant Version_32 := 16#a721c890#; + pragma Export (C, u00296, "tinyaml__schemas__intS"); + u00297 : constant Version_32 := 16#f7fd9b57#; + pragma Export (C, u00297, "tinyaml__schemas__constraintsS"); + u00298 : constant Version_32 := 16#d8150ade#; + pragma Export (C, u00298, "tinyaml__schemas__constraints__range_constraintB"); + u00299 : constant Version_32 := 16#3a739acc#; + pragma Export (C, u00299, "tinyaml__schemas__constraints__range_constraintS"); + u00300 : constant Version_32 := 16#9f7f51e2#; + pragma Export (C, u00300, "tinyaml__schemas__strB"); + u00301 : constant Version_32 := 16#f37fb44e#; + pragma Export (C, u00301, "tinyaml__schemas__strS"); + u00302 : constant Version_32 := 16#c857814a#; + pragma Export (C, u00302, "tinyaml__schemas__enumB"); + u00303 : constant Version_32 := 16#91899e9c#; + pragma Export (C, u00303, "tinyaml__schemas__enumS"); + u00304 : constant Version_32 := 16#1bca34b5#; + pragma Export (C, u00304, "tinyaml__schemas__seqB"); + u00305 : constant Version_32 := 16#81b642f9#; + pragma Export (C, u00305, "tinyaml__schemas__seqS"); + u00306 : constant Version_32 := 16#ea7b6a3b#; + pragma Export (C, u00306, "tinyaml__schemas__preludeS"); + u00307 : constant Version_32 := 16#6c0934a3#; + pragma Export (C, u00307, "tinyaml__validationB"); + u00308 : constant Version_32 := 16#db4b7fa7#; + pragma Export (C, u00308, "tinyaml__validationS"); + + -- BEGIN ELABORATION ORDER + -- ada%s + -- ada.characters%s + -- ada.characters.latin_1%s + -- interfaces%s + -- system%s + -- system.atomic_operations%s + -- system.float_control%s + -- system.float_control%b + -- system.io%s + -- system.io%b + -- system.parameters%s + -- system.parameters%b + -- system.crtl%s + -- interfaces.c_streams%s + -- interfaces.c_streams%b + -- system.os_primitives%s + -- system.os_primitives%b + -- system.powten_lflt%s + -- system.spark%s + -- system.spark.cut_operations%s + -- system.spark.cut_operations%b + -- system.storage_elements%s + -- system.img_address_32%s + -- system.img_address_64%s + -- system.return_stack%s + -- system.stack_checking%s + -- system.stack_checking%b + -- system.string_hash%s + -- system.string_hash%b + -- system.htable%s + -- system.htable%b + -- system.strings%s + -- system.strings%b + -- system.traceback_entries%s + -- system.traceback_entries%b + -- system.unsigned_types%s + -- system.img_biu%s + -- system.img_llb%s + -- system.img_lllb%s + -- system.img_lllw%s + -- system.img_llw%s + -- system.img_wiu%s + -- system.wch_con%s + -- system.wch_con%b + -- system.wch_jis%s + -- system.wch_jis%b + -- system.wch_cnv%s + -- system.wch_cnv%b + -- system.concat_2%s + -- system.concat_2%b + -- system.concat_3%s + -- system.concat_3%b + -- system.exn_lflt%s + -- system.traceback%s + -- system.traceback%b + -- ada.characters.handling%s + -- system.atomic_operations.test_and_set%s + -- system.case_util%s + -- system.os_lib%s + -- system.secondary_stack%s + -- system.standard_library%s + -- ada.exceptions%s + -- system.exceptions_debug%s + -- system.exceptions_debug%b + -- system.soft_links%s + -- system.val_util%s + -- system.val_util%b + -- system.val_llu%s + -- system.val_lli%s + -- system.wch_stw%s + -- system.wch_stw%b + -- ada.exceptions.last_chance_handler%s + -- ada.exceptions.last_chance_handler%b + -- ada.exceptions.traceback%s + -- ada.exceptions.traceback%b + -- system.address_image%s + -- system.address_image%b + -- system.bit_ops%s + -- system.bit_ops%b + -- system.bounded_strings%s + -- system.bounded_strings%b + -- system.case_util%b + -- system.exception_table%s + -- system.exception_table%b + -- ada.containers%s + -- ada.io_exceptions%s + -- ada.numerics%s + -- ada.numerics.big_numbers%s + -- ada.strings%s + -- ada.strings.maps%s + -- ada.strings.maps%b + -- ada.strings.maps.constants%s + -- interfaces.c%s + -- interfaces.c%b + -- system.atomic_primitives%s + -- system.atomic_primitives%b + -- system.exceptions%s + -- system.exceptions.machine%s + -- system.exceptions.machine%b + -- ada.characters.handling%b + -- system.atomic_operations.test_and_set%b + -- system.exception_traces%s + -- system.exception_traces%b + -- system.img_int%s + -- system.img_uns%s + -- system.memory%s + -- system.memory%b + -- system.mmap%s + -- system.mmap.os_interface%s + -- system.mmap%b + -- system.mmap.unix%s + -- system.mmap.os_interface%b + -- system.object_reader%s + -- system.object_reader%b + -- system.dwarf_lines%s + -- system.dwarf_lines%b + -- system.os_lib%b + -- system.secondary_stack%b + -- system.soft_links.initialize%s + -- system.soft_links.initialize%b + -- system.soft_links%b + -- system.standard_library%b + -- system.traceback.symbolic%s + -- system.traceback.symbolic%b + -- ada.exceptions%b + -- ada.assertions%s + -- ada.assertions%b + -- ada.strings.search%s + -- ada.strings.search%b + -- ada.strings.fixed%s + -- ada.strings.fixed%b + -- ada.strings.utf_encoding%s + -- ada.strings.utf_encoding%b + -- ada.strings.utf_encoding.strings%s + -- ada.strings.utf_encoding.strings%b + -- ada.strings.utf_encoding.wide_strings%s + -- ada.strings.utf_encoding.wide_strings%b + -- ada.strings.utf_encoding.wide_wide_strings%s + -- ada.strings.utf_encoding.wide_wide_strings%b + -- ada.tags%s + -- ada.tags%b + -- ada.strings.text_buffers%s + -- ada.strings.text_buffers%b + -- ada.strings.text_buffers.utils%s + -- ada.strings.text_buffers.utils%b + -- gnat%s + -- gnat.source_info%s + -- system.arith_64%s + -- system.arith_64%b + -- system.atomic_counters%s + -- system.atomic_counters%b + -- system.fat_flt%s + -- system.fat_lflt%s + -- system.fat_llf%s + -- system.linux%s + -- system.multiprocessors%s + -- system.multiprocessors%b + -- system.os_constants%s + -- system.os_locks%s + -- system.finalization_primitives%s + -- system.finalization_primitives%b + -- system.os_interface%s + -- system.os_interface%b + -- system.put_images%s + -- system.put_images%b + -- ada.streams%s + -- ada.streams%b + -- system.file_control_block%s + -- system.finalization_root%s + -- system.finalization_root%b + -- ada.finalization%s + -- ada.containers.helpers%s + -- ada.containers.helpers%b + -- ada.containers.red_black_trees%s + -- system.file_io%s + -- system.file_io%b + -- system.stack_usage%s + -- system.stack_usage%b + -- system.storage_pools%s + -- system.storage_pools%b + -- system.storage_pools.subpools%s + -- system.storage_pools.subpools.finalization%s + -- system.storage_pools.subpools.finalization%b + -- system.storage_pools.subpools%b + -- system.stream_attributes%s + -- system.stream_attributes.xdr%s + -- system.stream_attributes.xdr%b + -- system.stream_attributes%b + -- ada.strings.unbounded%s + -- ada.strings.unbounded%b + -- system.task_info%s + -- system.task_info%b + -- system.task_primitives%s + -- system.interrupt_management%s + -- system.interrupt_management%b + -- system.val_lflt%s + -- system.val_lllu%s + -- system.val_llli%s + -- system.val_uns%s + -- system.val_int%s + -- ada.calendar%s + -- ada.calendar%b + -- ada.text_io%s + -- ada.text_io%b + -- ada.text_io.generic_aux%s + -- ada.text_io.generic_aux%b + -- gnat.traceback%s + -- gnat.traceback%b + -- gnat.traceback.symbolic%s + -- system.assertions%s + -- system.assertions%b + -- system.exn_int%s + -- system.img_lli%s + -- system.tasking%s + -- system.task_primitives.operations%s + -- system.tasking.debug%s + -- system.tasking.debug%b + -- system.task_primitives.operations%b + -- system.tasking%b + -- system.img_llli%s + -- ada.integer_text_io%s + -- ada.integer_text_io%b + -- system.pool_global%s + -- system.pool_global%b + -- system.strings.stream_ops%s + -- system.strings.stream_ops%b + -- ada_containers%s + -- tinyaml%s + -- tinyaml%b + -- aunit%s + -- aunit.memory%s + -- aunit.memory%b + -- aunit%b + -- aunit.io%s + -- aunit.memory.utils%s + -- aunit.memory.utils%b + -- ada_containers.aunit_lists%s + -- ada_containers.aunit_lists%b + -- aunit.tests%s + -- aunit.time_measure%s + -- aunit.time_measure%b + -- aunit.test_results%s + -- aunit.test_results%b + -- aunit.assertions%s + -- aunit.assertions%b + -- aunit.test_filters%s + -- aunit.options%s + -- aunit.simple_test_cases%s + -- aunit.simple_test_cases%b + -- aunit.test_filters%b + -- aunit.reporter%s + -- aunit.reporter%b + -- aunit.reporter.text%s + -- aunit.reporter.text%b + -- aunit.test_cases%s + -- aunit.test_cases%b + -- aunit.test_suites%s + -- aunit.test_suites%b + -- aunit.run%s + -- aunit.run%b + -- tinyaml.lexer%s + -- tinyaml.lexer%b + -- tinyaml.lexer_tests%s + -- tinyaml.lexer_tests%b + -- tinyaml.nodes%s + -- tinyaml.nodes.map%s + -- tinyaml.nodes.map%b + -- tinyaml.nodes.sequence%s + -- tinyaml.nodes.sequence%b + -- tinyaml.nodes%b + -- tinyaml.documents%s + -- tinyaml.documents%b + -- tinyaml.nodes.scalar%s + -- tinyaml.nodes.scalar%b + -- tinyaml.nodes.navigation%s + -- tinyaml.nodes.navigation%b + -- tinyaml.parser%s + -- tinyaml.parser%b + -- tinyaml.parser_tests%s + -- tinyaml.parser_tests%b + -- tinyaml.schemas%s + -- tinyaml.schemas.any%s + -- tinyaml.schemas.bool%s + -- tinyaml.schemas.bool%b + -- tinyaml.schemas.constraints%s + -- tinyaml.schemas.constraints.range_constraint%s + -- tinyaml.schemas.constraints.range_constraint%b + -- tinyaml.schemas.enum%s + -- tinyaml.schemas.enum%b + -- tinyaml.schemas.flt%s + -- tinyaml.schemas.flt%b + -- tinyaml.schemas.int%s + -- tinyaml.schemas.int%b + -- tinyaml.schemas.seq%s + -- tinyaml.schemas.seq%b + -- tinyaml.schemas.map%s + -- tinyaml.schemas%b + -- tinyaml.schemas.str%s + -- tinyaml.schemas.str%b + -- tinyaml.schemas.map%b + -- tinyaml.schemas.prelude%s + -- tinyaml.validation%s + -- tinyaml.validation%b + -- tinyaml.validation_tests%s + -- tinyaml.validation_tests%b + -- tinyaml_tests%s + -- tinyaml_tests%b + -- test_runner%b + -- END ELABORATION ORDER + +end ada_main; diff --git a/tests/obj/b__test_runner.ali b/tests/obj/b__test_runner.ali new file mode 100644 index 0000000..ab8dfa4 --- /dev/null +++ b/tests/obj/b__test_runner.ali @@ -0,0 +1,570 @@ +V "GNAT Lib v15" +A -gnatA +A -gnatA +A -gnatWb +A -gnatiw +A -gnatws +A -g +A -mtune=generic +A -march=x86-64 +P ZX + +RN +RV NO_ACCESS_SUBPROGRAMS +RV NO_STANDARD_STORAGE_POOLS +RV NO_DEFAULT_INITIALIZATION +RV NO_IMPLEMENTATION_ATTRIBUTES +RV NO_IMPLEMENTATION_PRAGMAS +RV NO_IMPLICIT_LOOPS +RV NO_ELABORATION_CODE +RV NO_OBSOLESCENT_FEATURES + +U ada_main%b b__test_runner.adb ccf8b625 OO PK IL +W ada%s ada.ads ada.ali +W ada.exceptions%s a-except.adb a-except.ali +Z system%s system.ads system.ali + +U ada_main%s b__test_runner.ads dfdd86ae EE NE OO PK IL +W system%s system.ads system.ali +W system.parameters%s s-parame.adb s-parame.ali +W system.secondary_stack%s s-secsta.adb s-secsta.ali + +D ada.ads 20250808065140 76789da1 ada%s +D a-except.ads 20250808065140 e7970cd9 ada.exceptions%s +D a-unccon.ads 20250808065140 0e9b276f ada.unchecked_conversion%s +D b__test_runner.ads 20260101222045 a9e06845 ada_main%s +D b__test_runner.adb 20260101222045 828fd2b9 ada_main%b +D system.ads 20250808065140 14286b0f system%s +D s-parame.ads 20250808065140 3597fc11 system.parameters%s +D s-secsta.ads 20250808065140 578279f5 system.secondary_stack%s +D s-stalib.ads 20250808065140 1c9580f6 system.standard_library%s +D s-stoele.ads 20250808065140 ccded4e8 system.storage_elements%s +D s-traent.ads 20250808065140 c81cbf8c system.traceback_entries%s +G a e +G c Z s b [adainit ada_main 29 14 none] +G c Z s b [adafinal ada_main 32 14 none] +G c Z s b [main ada_main 35 13 none] +G c Z b b [Tsec_default_sized_stacksBIP ada_main 85 4 none] +G c Z b b [finalize_library ada_main 92 14 none] +G c Z b b [ada_main_program ada_main 612 14 none] +X 1 ada.ads +18K9*Ada 22e8 5|6r6 +X 2 a-except.ads +44K13*Exceptions 309e19 5|6w10 +X 4 b__test_runner.ads +6K9*ada_main 971l5 971e13 5|8b14 665l5 665t13 +8i4*gnat_argc{integer} 12m22 12r22 5|632r10 633m10 +9m4*gnat_argv{6|67M9} 13m22 13r22 5|634m10 +10m4*gnat_envp{6|67M9} 14m22 14r22 5|636m7 +16i4*gnat_exit_status{integer} 17m22 17r22 5|643r15 +19a4*GNAT_Version{string} 21r22 23r54 +23m4*GNAT_Version_Address{6|67M9} 24r22 +26a4*Ada_Main_Program_Name{string} 27r22 5|628r52 +29U14*adainit 30i22 5|363b14 610l8 610t15 639s7 +32U14*adafinal 33i22 5|344b14 358l8 358t16 641s7 +35V13*main{integer} 36>7 37>7 38>7 40i22 5|615b13 644t7 +36i7 argc{integer} 5|616b7 633r23 +37m7 argv{6|67M9} 5|617b7 634r23 +38m7 envp{6|67M9} 5|618b7 636r20 +42M9*Version_32 43r22 45r22 47r22 49r22 51r22 53r22 55r22 57r22 59r22 61r22 +. 63r22 65r22 67r22 69r22 71r22 73r22 75r22 77r22 79r22 81r22 83r22 85r22 +. 87r22 89r22 91r22 93r22 95r22 97r22 99r22 101r22 103r22 105r22 107r22 109r22 +. 111r22 113r22 115r22 117r22 119r22 121r22 123r22 125r22 127r22 129r22 131r22 +. 133r22 135r22 137r22 139r22 141r22 143r22 145r22 147r22 149r22 151r22 153r22 +. 155r22 157r22 159r22 161r22 163r22 165r22 167r22 169r22 171r22 173r22 175r22 +. 177r22 179r22 181r22 183r22 185r22 187r22 189r22 191r22 193r22 195r22 197r22 +. 199r22 201r22 203r22 205r22 207r22 209r22 211r22 213r22 215r22 217r22 219r22 +. 221r22 223r22 225r22 227r22 229r22 231r22 233r22 235r22 237r22 239r22 241r22 +. 243r22 245r22 247r22 249r22 251r22 253r22 255r22 257r22 259r22 261r22 263r22 +. 265r22 267r22 269r22 271r22 273r22 275r22 277r22 279r22 281r22 283r22 285r22 +. 287r22 289r22 291r22 293r22 295r22 297r22 299r22 301r22 303r22 305r22 307r22 +. 309r22 311r22 313r22 315r22 317r22 319r22 321r22 323r22 325r22 327r22 329r22 +. 331r22 333r22 335r22 337r22 339r22 341r22 343r22 345r22 347r22 349r22 351r22 +. 353r22 355r22 357r22 359r22 361r22 363r22 365r22 367r22 369r22 371r22 373r22 +. 375r22 377r22 379r22 381r22 383r22 385r22 387r22 389r22 391r22 393r22 395r22 +. 397r22 399r22 401r22 403r22 405r22 407r22 409r22 411r22 413r22 415r22 417r22 +. 419r22 421r22 423r22 425r22 427r22 429r22 431r22 433r22 435r22 437r22 439r22 +. 441r22 443r22 445r22 447r22 449r22 451r22 453r22 455r22 457r22 459r22 461r22 +. 463r22 465r22 467r22 469r22 471r22 473r22 475r22 477r22 479r22 481r22 483r22 +. 485r22 487r22 489r22 491r22 493r22 495r22 497r22 499r22 501r22 503r22 505r22 +. 507r22 509r22 511r22 513r22 515r22 517r22 519r22 521r22 523r22 525r22 527r22 +. 529r22 531r22 533r22 535r22 537r22 539r22 541r22 543r22 545r22 547r22 549r22 +. 551r22 553r22 555r22 557r22 559r22 561r22 563r22 565r22 567r22 569r22 571r22 +. 573r22 575r22 577r22 579r22 581r22 583r22 585r22 587r22 589r22 591r22 593r22 +. 595r22 597r22 599r22 601r22 603r22 605r22 607r22 609r22 611r22 613r22 615r22 +. 617r22 619r22 621r22 623r22 625r22 627r22 629r22 631r22 633r22 635r22 637r22 +. 639r22 641r22 643r22 645r22 647r22 649r22 651r22 653r22 655r22 657r22 +43m4*u00001{42M9} 44r22 +45m4*u00002{42M9} 46r22 +47m4*u00003{42M9} 48r22 +49m4*u00004{42M9} 50r22 +51m4*u00005{42M9} 52r22 +53m4*u00006{42M9} 54r22 +55m4*u00007{42M9} 56r22 +57m4*u00008{42M9} 58r22 +59m4*u00009{42M9} 60r22 +61m4*u00010{42M9} 62r22 +63m4*u00011{42M9} 64r22 +65m4*u00012{42M9} 66r22 +67m4*u00013{42M9} 68r22 +69m4*u00014{42M9} 70r22 +71m4*u00015{42M9} 72r22 +73m4*u00016{42M9} 74r22 +75m4*u00017{42M9} 76r22 +77m4*u00018{42M9} 78r22 +79m4*u00019{42M9} 80r22 +81m4*u00020{42M9} 82r22 +83m4*u00021{42M9} 84r22 +85m4*u00022{42M9} 86r22 +87m4*u00023{42M9} 88r22 +89m4*u00024{42M9} 90r22 +91m4*u00025{42M9} 92r22 +93m4*u00026{42M9} 94r22 +95m4*u00027{42M9} 96r22 +97m4*u00028{42M9} 98r22 +99m4*u00029{42M9} 100r22 +101m4*u00030{42M9} 102r22 +103m4*u00031{42M9} 104r22 +105m4*u00032{42M9} 106r22 +107m4*u00033{42M9} 108r22 +109m4*u00034{42M9} 110r22 +111m4*u00035{42M9} 112r22 +113m4*u00036{42M9} 114r22 +115m4*u00037{42M9} 116r22 +117m4*u00038{42M9} 118r22 +119m4*u00039{42M9} 120r22 +121m4*u00040{42M9} 122r22 +123m4*u00041{42M9} 124r22 +125m4*u00042{42M9} 126r22 +127m4*u00043{42M9} 128r22 +129m4*u00044{42M9} 130r22 +131m4*u00045{42M9} 132r22 +133m4*u00046{42M9} 134r22 +135m4*u00047{42M9} 136r22 +137m4*u00048{42M9} 138r22 +139m4*u00049{42M9} 140r22 +141m4*u00050{42M9} 142r22 +143m4*u00051{42M9} 144r22 +145m4*u00052{42M9} 146r22 +147m4*u00053{42M9} 148r22 +149m4*u00054{42M9} 150r22 +151m4*u00055{42M9} 152r22 +153m4*u00056{42M9} 154r22 +155m4*u00057{42M9} 156r22 +157m4*u00058{42M9} 158r22 +159m4*u00059{42M9} 160r22 +161m4*u00060{42M9} 162r22 +163m4*u00061{42M9} 164r22 +165m4*u00062{42M9} 166r22 +167m4*u00063{42M9} 168r22 +169m4*u00064{42M9} 170r22 +171m4*u00065{42M9} 172r22 +173m4*u00066{42M9} 174r22 +175m4*u00067{42M9} 176r22 +177m4*u00068{42M9} 178r22 +179m4*u00069{42M9} 180r22 +181m4*u00070{42M9} 182r22 +183m4*u00071{42M9} 184r22 +185m4*u00072{42M9} 186r22 +187m4*u00073{42M9} 188r22 +189m4*u00074{42M9} 190r22 +191m4*u00075{42M9} 192r22 +193m4*u00076{42M9} 194r22 +195m4*u00077{42M9} 196r22 +197m4*u00078{42M9} 198r22 +199m4*u00079{42M9} 200r22 +201m4*u00080{42M9} 202r22 +203m4*u00081{42M9} 204r22 +205m4*u00082{42M9} 206r22 +207m4*u00083{42M9} 208r22 +209m4*u00084{42M9} 210r22 +211m4*u00085{42M9} 212r22 +213m4*u00086{42M9} 214r22 +215m4*u00087{42M9} 216r22 +217m4*u00088{42M9} 218r22 +219m4*u00089{42M9} 220r22 +221m4*u00090{42M9} 222r22 +223m4*u00091{42M9} 224r22 +225m4*u00092{42M9} 226r22 +227m4*u00093{42M9} 228r22 +229m4*u00094{42M9} 230r22 +231m4*u00095{42M9} 232r22 +233m4*u00096{42M9} 234r22 +235m4*u00097{42M9} 236r22 +237m4*u00098{42M9} 238r22 +239m4*u00099{42M9} 240r22 +241m4*u00100{42M9} 242r22 +243m4*u00101{42M9} 244r22 +245m4*u00102{42M9} 246r22 +247m4*u00103{42M9} 248r22 +249m4*u00104{42M9} 250r22 +251m4*u00105{42M9} 252r22 +253m4*u00106{42M9} 254r22 +255m4*u00107{42M9} 256r22 +257m4*u00108{42M9} 258r22 +259m4*u00109{42M9} 260r22 +261m4*u00110{42M9} 262r22 +263m4*u00111{42M9} 264r22 +265m4*u00112{42M9} 266r22 +267m4*u00113{42M9} 268r22 +269m4*u00114{42M9} 270r22 +271m4*u00115{42M9} 272r22 +273m4*u00116{42M9} 274r22 +275m4*u00117{42M9} 276r22 +277m4*u00118{42M9} 278r22 +279m4*u00119{42M9} 280r22 +281m4*u00120{42M9} 282r22 +283m4*u00121{42M9} 284r22 +285m4*u00122{42M9} 286r22 +287m4*u00123{42M9} 288r22 +289m4*u00124{42M9} 290r22 +291m4*u00125{42M9} 292r22 +293m4*u00126{42M9} 294r22 +295m4*u00127{42M9} 296r22 +297m4*u00128{42M9} 298r22 +299m4*u00129{42M9} 300r22 +301m4*u00130{42M9} 302r22 +303m4*u00131{42M9} 304r22 +305m4*u00132{42M9} 306r22 +307m4*u00133{42M9} 308r22 +309m4*u00134{42M9} 310r22 +311m4*u00135{42M9} 312r22 +313m4*u00136{42M9} 314r22 +315m4*u00137{42M9} 316r22 +317m4*u00138{42M9} 318r22 +319m4*u00139{42M9} 320r22 +321m4*u00140{42M9} 322r22 +323m4*u00141{42M9} 324r22 +325m4*u00142{42M9} 326r22 +327m4*u00143{42M9} 328r22 +329m4*u00144{42M9} 330r22 +331m4*u00145{42M9} 332r22 +333m4*u00146{42M9} 334r22 +335m4*u00147{42M9} 336r22 +337m4*u00148{42M9} 338r22 +339m4*u00149{42M9} 340r22 +341m4*u00150{42M9} 342r22 +343m4*u00151{42M9} 344r22 +345m4*u00152{42M9} 346r22 +347m4*u00153{42M9} 348r22 +349m4*u00154{42M9} 350r22 +351m4*u00155{42M9} 352r22 +353m4*u00156{42M9} 354r22 +355m4*u00157{42M9} 356r22 +357m4*u00158{42M9} 358r22 +359m4*u00159{42M9} 360r22 +361m4*u00160{42M9} 362r22 +363m4*u00161{42M9} 364r22 +365m4*u00162{42M9} 366r22 +367m4*u00163{42M9} 368r22 +369m4*u00164{42M9} 370r22 +371m4*u00165{42M9} 372r22 +373m4*u00166{42M9} 374r22 +375m4*u00167{42M9} 376r22 +377m4*u00168{42M9} 378r22 +379m4*u00169{42M9} 380r22 +381m4*u00170{42M9} 382r22 +383m4*u00171{42M9} 384r22 +385m4*u00172{42M9} 386r22 +387m4*u00173{42M9} 388r22 +389m4*u00174{42M9} 390r22 +391m4*u00175{42M9} 392r22 +393m4*u00176{42M9} 394r22 +395m4*u00177{42M9} 396r22 +397m4*u00178{42M9} 398r22 +399m4*u00179{42M9} 400r22 +401m4*u00180{42M9} 402r22 +403m4*u00181{42M9} 404r22 +405m4*u00182{42M9} 406r22 +407m4*u00183{42M9} 408r22 +409m4*u00184{42M9} 410r22 +411m4*u00185{42M9} 412r22 +413m4*u00186{42M9} 414r22 +415m4*u00187{42M9} 416r22 +417m4*u00188{42M9} 418r22 +419m4*u00189{42M9} 420r22 +421m4*u00190{42M9} 422r22 +423m4*u00191{42M9} 424r22 +425m4*u00192{42M9} 426r22 +427m4*u00193{42M9} 428r22 +429m4*u00194{42M9} 430r22 +431m4*u00195{42M9} 432r22 +433m4*u00196{42M9} 434r22 +435m4*u00197{42M9} 436r22 +437m4*u00198{42M9} 438r22 +439m4*u00199{42M9} 440r22 +441m4*u00200{42M9} 442r22 +443m4*u00201{42M9} 444r22 +445m4*u00202{42M9} 446r22 +447m4*u00203{42M9} 448r22 +449m4*u00204{42M9} 450r22 +451m4*u00205{42M9} 452r22 +453m4*u00206{42M9} 454r22 +455m4*u00207{42M9} 456r22 +457m4*u00208{42M9} 458r22 +459m4*u00209{42M9} 460r22 +461m4*u00210{42M9} 462r22 +463m4*u00211{42M9} 464r22 +465m4*u00212{42M9} 466r22 +467m4*u00213{42M9} 468r22 +469m4*u00214{42M9} 470r22 +471m4*u00215{42M9} 472r22 +473m4*u00216{42M9} 474r22 +475m4*u00217{42M9} 476r22 +477m4*u00218{42M9} 478r22 +479m4*u00219{42M9} 480r22 +481m4*u00220{42M9} 482r22 +483m4*u00221{42M9} 484r22 +485m4*u00222{42M9} 486r22 +487m4*u00223{42M9} 488r22 +489m4*u00224{42M9} 490r22 +491m4*u00225{42M9} 492r22 +493m4*u00226{42M9} 494r22 +495m4*u00227{42M9} 496r22 +497m4*u00228{42M9} 498r22 +499m4*u00229{42M9} 500r22 +501m4*u00230{42M9} 502r22 +503m4*u00231{42M9} 504r22 +505m4*u00232{42M9} 506r22 +507m4*u00233{42M9} 508r22 +509m4*u00234{42M9} 510r22 +511m4*u00235{42M9} 512r22 +513m4*u00236{42M9} 514r22 +515m4*u00237{42M9} 516r22 +517m4*u00238{42M9} 518r22 +519m4*u00239{42M9} 520r22 +521m4*u00240{42M9} 522r22 +523m4*u00241{42M9} 524r22 +525m4*u00242{42M9} 526r22 +527m4*u00243{42M9} 528r22 +529m4*u00244{42M9} 530r22 +531m4*u00245{42M9} 532r22 +533m4*u00246{42M9} 534r22 +535m4*u00247{42M9} 536r22 +537m4*u00248{42M9} 538r22 +539m4*u00249{42M9} 540r22 +541m4*u00250{42M9} 542r22 +543m4*u00251{42M9} 544r22 +545m4*u00252{42M9} 546r22 +547m4*u00253{42M9} 548r22 +549m4*u00254{42M9} 550r22 +551m4*u00255{42M9} 552r22 +553m4*u00256{42M9} 554r22 +555m4*u00257{42M9} 556r22 +557m4*u00258{42M9} 558r22 +559m4*u00259{42M9} 560r22 +561m4*u00260{42M9} 562r22 +563m4*u00261{42M9} 564r22 +565m4*u00262{42M9} 566r22 +567m4*u00263{42M9} 568r22 +569m4*u00264{42M9} 570r22 +571m4*u00265{42M9} 572r22 +573m4*u00266{42M9} 574r22 +575m4*u00267{42M9} 576r22 +577m4*u00268{42M9} 578r22 +579m4*u00269{42M9} 580r22 +581m4*u00270{42M9} 582r22 +583m4*u00271{42M9} 584r22 +585m4*u00272{42M9} 586r22 +587m4*u00273{42M9} 588r22 +589m4*u00274{42M9} 590r22 +591m4*u00275{42M9} 592r22 +593m4*u00276{42M9} 594r22 +595m4*u00277{42M9} 596r22 +597m4*u00278{42M9} 598r22 +599m4*u00279{42M9} 600r22 +601m4*u00280{42M9} 602r22 +603m4*u00281{42M9} 604r22 +605m4*u00282{42M9} 606r22 +607m4*u00283{42M9} 608r22 +609m4*u00284{42M9} 610r22 +611m4*u00285{42M9} 612r22 +613m4*u00286{42M9} 614r22 +615m4*u00287{42M9} 616r22 +617m4*u00288{42M9} 618r22 +619m4*u00289{42M9} 620r22 +621m4*u00290{42M9} 622r22 +623m4*u00291{42M9} 624r22 +625m4*u00292{42M9} 626r22 +627m4*u00293{42M9} 628r22 +629m4*u00294{42M9} 630r22 +631m4*u00295{42M9} 632r22 +633m4*u00296{42M9} 634r22 +635m4*u00297{42M9} 636r22 +637m4*u00298{42M9} 638r22 +639m4*u00299{42M9} 640r22 +641m4*u00300{42M9} 642r22 +643m4*u00301{42M9} 644r22 +645m4*u00302{42M9} 646r22 +647m4*u00303{42M9} 648r22 +649m4*u00304{42M9} 650r22 +651m4*u00305{42M9} 652r22 +653m4*u00306{42M9} 654r22 +655m4*u00307{42M9} 656r22 +657m4*u00308{42M9} 658r22 +X 5 b__test_runner.adb +10i4 E071{short_integer} 10m46 10r46 474m7 474r15 +11i4 E016{short_integer} 11m46 11r46 480m7 480r15 +12i4 E012{short_integer} 12m46 12r46 477m7 477r15 +13i4 E010{short_integer} 13m46 13r46 452m7 452r15 +14i4 E035{short_integer} 14m46 14r46 454m7 454r15 +15i4 E066{short_integer} 15m46 15r46 456m7 456r15 +16i4 E025{short_integer} 16m46 16r46 458m7 458r15 +17i4 E007{short_integer} 17m46 17r46 460m7 460r15 +18i4 E053{short_integer} 18m46 18r46 462m7 462r15 +19i4 E056{short_integer} 19m46 19r46 464m7 464r15 +20i4 E040{short_integer} 20m46 20r46 466m7 466r15 +21i4 E019{short_integer} 21m46 21r46 468m7 468r15 +22i4 E082{short_integer} 22m46 22r46 470m7 470r15 +23i4 E047{short_integer} 23m46 23r46 472m7 472r15 +24i4 E101{short_integer} 24m46 24r46 476m7 476r15 +25i4 E034{short_integer} 25m46 25r46 479m7 479r15 +26i4 E241{short_integer} 26m46 26r46 482m7 482r15 +27i4 E105{short_integer} 27m46 27r46 484m7 484r15 +28i4 E113{short_integer} 28m46 28r46 487m7 487r15 +29i4 E005{short_integer} 29m46 29r46 489m7 489r15 +30i4 E192{short_integer} 30m46 30r46 491m7 491r15 +31i4 E125{short_integer} 31m46 31r46 493m7 493r15 +32i4 E146{short_integer} 32m46 32r46 495m7 495r15 +33i4 E141{short_integer} 33m46 33r46 497m7 497r15 +34i4 E139{short_integer} 34m46 34r46 499m7 499r15 +35i4 E138{short_integer} 35m46 35r46 333m10 333r18 501m7 501r15 +36i4 E191{short_integer} 36m46 36r46 503m7 503r15 +37i4 E225{short_integer} 37m46 37r46 322m7 322r15 505m7 505r15 +38i4 E219{short_integer} 38m46 38r46 315m7 315r15 507m7 507r15 +39i4 E270{short_integer} 39m46 39r46 509m7 509r15 +40i4 E182{short_integer} 40m46 40r46 512m7 512r15 +41i4 E134{short_integer} 41m46 41r46 308m7 308r15 515m7 515r15 +42i4 E264{short_integer} 42m46 42r46 517m7 517r15 +43i4 E187{short_integer} 43m46 43r46 301m7 301r15 519m7 519r15 +44i4 E217{short_integer} 44m46 44r46 521m7 521r15 +45i4 E119{short_integer} 45m46 45r46 523m7 523r15 +46i4 E121{short_integer} 46m46 46r46 522m7 522r15 +47i4 E172{short_integer} 47m46 47r46 524m7 524r15 +48i4 E169{short_integer} 48m46 48r46 525m7 525r15 +49i4 E185{short_integer} 49m46 49r46 298m10 298r18 527m7 527r15 +50i4 E176{short_integer} 50m46 50r46 529m7 529r15 +51i4 E174{short_integer} 51m46 51r46 287m7 287r15 531m7 531r15 +52i4 E167{short_integer} 52m46 52r46 280m7 280r15 534m7 534r15 +53i4 E163{short_integer} 53m46 53r46 266m7 266r15 538m7 538r15 +54i4 E165{short_integer} 54m46 54r46 267m7 267r15 537m7 537r15 +55i4 E123{short_integer} 55m46 55r46 540m7 540r15 +56i4 E205{short_integer} 56m46 56r46 259m7 259r15 542m7 542r15 +57i4 E231{short_integer} 57m46 57r46 252m7 252r15 544m7 544r15 +58i4 E213{short_integer} 58m46 58r46 245m7 245r15 546m7 546r15 +59i4 E211{short_integer} 59m46 59r46 547m7 547r15 +60i4 E229{short_integer} 60m46 60r46 548m7 548r15 +61i4 E223{short_integer} 61m46 61r46 236m10 236r18 551m7 551r15 +62i4 E237{short_integer} 62m46 62r46 211m7 211r15 560m7 560r15 +63i4 E243{short_integer} 63m46 63r46 219m7 219r15 555m7 555r15 +64i4 E245{short_integer} 64m46 64r46 212m7 212r15 558m7 558r15 +65i4 E235{short_integer} 65m46 65r46 204m7 204r15 563m7 563r15 +66i4 E254{short_integer} 66m46 66r46 197m7 197r15 566m7 566r15 +67i4 E252{short_integer} 67m46 67r46 567m7 567r15 +68i4 E256{short_integer} 68m46 68r46 568m7 568r15 +69i4 E233{short_integer} 69m46 69r46 188m10 188r18 571m7 571r15 +70i4 E282{short_integer} 70m46 70r46 122m7 122r15 597m7 597r15 +71i4 E285{short_integer} 71m46 71r46 175m10 175r18 574m7 574r15 +72i4 E287{short_integer} 72m46 72r46 164m7 164r15 577m7 577r15 +73i4 E297{short_integer} 73m46 73r46 579m7 579r15 +74i4 E299{short_integer} 74m46 74r46 157m7 157r15 582m7 582r15 +75i4 E303{short_integer} 75m46 75r46 150m7 150r15 585m7 585r15 +76i4 E289{short_integer} 76m46 76r46 143m7 143r15 588m7 588r15 +77i4 E296{short_integer} 77m46 77r46 136m7 136r15 591m7 591r15 +78i4 E305{short_integer} 78m46 78r46 129m7 129r15 594m7 594r15 +79i4 E284{short_integer} 79m46 79r46 114m7 114r15 602m7 602r15 +80i4 E301{short_integer} 80m46 80r46 115m7 115r15 600m7 600r15 +81i4 E308{short_integer} 81m46 81r46 107m7 107r15 605m7 605r15 +82i4 E280{short_integer} 82m46 82r46 98m10 98r18 608m7 608r15 +83i4 E215{short_integer} 83m46 83r46 609m7 609r15 +85a4 Sec_Default_Sized_Stacks(8|43R9) 442m32 442r32 +87a4 Local_Priority_Specific_Dispatching{string} 428r9 +88a4 Local_Interrupt_States{string} 431r27 +90b4 Is_Elaborated{boolean} 352r14 355m7 417r10 420m7 +92U14 finalize_library 92b14 342l8 342t24 447r35 +95U20*F1 96b30 99s10 +102U20*F2 103b30 105s10 +109U20*F3 110b30 112s10 +117U20*F4 118b30 120s10 +124U20*F5 125b30 127s10 +131U20*F6 132b30 134s10 +138U20*F7 139b30 141s10 +145U20*F8 146b30 148s10 +152U20*F9 153b30 155s10 +159U20*F10 160b30 +. 162s10 +166U20*F11 167b30 169s10 +172U20*F12 173b30 176s10 +179U20*F13 180b30 182s10 +185U20*F14 186b30 189s10 +192U20*F15 193b30 195s10 +199U20*F16 200b30 202s10 +206U20*F17 207b30 209s10 +214U20*F18 215b30 217s10 +221U20*F19 222b30 224s10 +227U20*F20 228b30 230s10 +233U20*F21 234b30 237s10 +240U20*F22 241b30 243s10 +247U20*F23 248b30 250s10 +254U20*F24 255b30 257s10 +261U20*F25 262b30 264s10 +269U20*F26 270b30 272s10 +275U20*F27 276b30 278s10 +282U20*F28 283b30 285s10 +289U20*F29 290b30 292s10 +295U20*F30 296b30 299s10 +303U20*F31 304b30 306s10 +310U20*F32 311b30 313s10 +317U20*F33 318b30 320s10 +324U20*F34 325b30 327s10 +330U20*F35 331b30 334s10 +337U20*Reraise_Library_Exception_If_Any 338b33 +. 340s10 +345U17*s_stalib_adafinal 346b27 357s7 +348U17*Runtime_Finalize 349b25 356s7 +360P9 No_Param_Proc 361r28 409r34 +364i7*Main_Priority{integer} 365m25 365r25 421m7 +366i7*Time_Slice_Value{integer} 367m25 367r25 422m7 +368e7*WC_Encoding{character} 369m25 369r25 423m7 +370e7*Locking_Policy{character} 371m25 371r25 424m7 +372e7*Queuing_Policy{character} 373m25 373r25 425m7 +374e7*Task_Dispatching_Policy{character} 375m25 375r25 426m7 +376m7*Priority_Specific_Dispatching{6|67M9} 377m25 377r25 427m7 +378i7*Num_Specific_Dispatching{integer} 379m25 379r25 429m7 +380i7*Main_CPU{integer} 381m25 381r25 430m7 +382m7*Interrupt_States{6|67M9} 383m25 383r25 431m7 +384i7*Num_Interrupt_States{integer} 385m25 385r25 432m7 +386i7*Unreserve_All_Interrupts{integer} 387m25 387r25 433m7 +388i7*Exception_Tracebacks{integer} 389m25 389r25 434m7 +390i7*Exception_Tracebacks_Symbolic{integer} 391m25 391r25 435m7 +392i7*Detect_Blocking{integer} 393m25 393r25 436m7 +394i7*Default_Stack_Size{integer} 395m25 395r25 437m7 +396i7*Default_Secondary_Stack_Size{7|57I9} 397m25 397r25 440m7 +398m7*Bind_Env_Addr{6|67M9} 399m25 399r25 +400i7*Interrupts_Default_To_System{integer} 401m25 401r25 +403U17*Runtime_Initialize 403>37 404b25 444s7 +403i37 Install_Handler{integer} +406U17*Tasking_Runtime_Initialize 407b25 +. 445s7 +409p7*Finalize_Library_Objects{360P9} 410m25 410r25 447m7 +411i7*Binder_Sec_Stacks_Count{natural} 412m27 412r27 441m7 +413m7*Default_Sized_SS_Pool{6|67M9} 414m27 414r27 442m7 +612U14 Ada_Main_Program 613b24 640s7 +621U17*Initialize 621>29 622b25 638s7 +621m29 Addr{6|67M9} +624U17*Finalize 625b25 642s7 +626a7 SEH(integer) 638m19 638r19 +628m7 Ensure_Reference{6|67M9} 629r24 +X 6 system.ads +37K9*System 4|3w6 4r6 5r6 9r16 10r16 23r36 37r14 38r14 5|85r57 85r90 376r39 +. 382r26 396r38 398r23 413r31 440r39 617r14 618r14 621r36 628r34 6|155e11 +67M9*Address 4|9r23 10r23 23r43 37r21 38r21 5|376r46 382r33 398r30 413r38 +. 617r21 618r21 621r43 628r41 +X 7 s-parame.ads +50K16*Parameters 4|4w13 5|85r97 396r45 440r46 7|189e22 +57I9*Size_Type 5|396r56 +92i4*Runtime_Default_Sec_Stack_Size{57I9} 5|85r108 440r57 +X 8 s-secsta.ads +35K16*Secondary_Stack 4|5w13 5|85r64 8|429e27 +43R9*SS_Stack 5|85r80 8|329e14 + diff --git a/tests/obj/b__test_runner.o b/tests/obj/b__test_runner.o new file mode 100644 index 0000000..a6912e2 Binary files /dev/null and b/tests/obj/b__test_runner.o differ diff --git a/tests/obj/test_runner.adb.stderr b/tests/obj/test_runner.adb.stderr new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/test_runner.adb.stdout b/tests/obj/test_runner.adb.stdout new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/test_runner.ali b/tests/obj/test_runner.ali new file mode 100644 index 0000000..16bd921 --- /dev/null +++ b/tests/obj/test_runner.ali @@ -0,0 +1,112 @@ +V "GNAT Lib v15" +M P W=b +A -gnatA +A -gnat2022 +A -gnata +A -g +A -gnatwa +A -mtune=generic +A -march=x86-64 +P SS ZX + +RN +RV NO_DISPATCH +RV NO_DEFAULT_INITIALIZATION +RV NO_IMPLEMENTATION_PRAGMAS + +U test_runner%b test_runner.adb f755a64b NE OO SU +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +W aunit%s aunit.adb aunit.ali +W aunit.reporter%s aunit-reporter.adb aunit-reporter.ali +W aunit.reporter.text%s aunit-reporter-text.adb aunit-reporter-text.ali +W aunit.run%s aunit-run.adb aunit-run.ali +W tinyaml_tests%s tinyaml_tests.adb tinyaml_tests.ali + +D ada.ads 20250808065140 76789da1 ada%s +D a-calend.ads 20250808065140 bf7f3cc9 ada.calendar%s +D a-except.ads 20250808065140 e7970cd9 ada.exceptions%s +D a-finali.ads 20250808065140 bf4f806b ada.finalization%s +D a-inteio.ads 20250808065140 f64b89a4 ada.integer_text_io%s +D a-ioexce.ads 20250808065140 40018c65 ada.io_exceptions%s +D a-stream.ads 20250808065140 17477cbd ada.streams%s +D a-string.ads 20250808065140 90ac6797 ada.strings%s +D a-sttebu.ads 20250808065140 f1ad67a2 ada.strings.text_buffers%s +D a-stuten.ads 20250808065140 c6ced0ae ada.strings.utf_encoding%s +D a-tags.ads 20250808065140 fbca0ad5 ada.tags%s +D a-textio.ads 20250808065140 34ef47de ada.text_io%s +D a-tiinio.ads 20250808065140 76699c8f ada.text_io.integer_io%s +D a-unccon.ads 20250808065140 0e9b276f ada.unchecked_conversion%s +D ada_containers.ads 20260101213759 11329e00 ada_containers%s +D ada_containers-aunit_lists.ads 20260101213759 d9ebc89a ada_containers.aunit_lists%s +D aunit.ads 20260101213759 76cdf7c6 aunit%s +D aunit-assertions.ads 20260101213759 b7f9ecd6 aunit.assertions%s +D aunit-io.ads 20260101213759 fb5ed18b aunit.io%s +D aunit-options.ads 20260101213759 6e5a02a6 aunit.options%s +D aunit-reporter.ads 20260101213759 2c6ff74a aunit.reporter%s +D aunit-reporter-text.ads 20260101213759 3a193bce aunit.reporter.text%s +D aunit-run.ads 20260101213759 34d20999 aunit.run%s +D aunit-run.adb 20260101213759 c843a398 aunit.run%b +D aunit-simple_test_cases.ads 20260101213759 4111c32f aunit.simple_test_cases%s +D aunit-test_filters.ads 20260101213759 f10b2127 aunit.test_filters%s +D aunit-test_results.ads 20260101213759 b44de7dc aunit.test_results%s +D aunit-test_suites.ads 20260101213759 6821dc24 aunit.test_suites%s +D aunit-tests.ads 20260101213759 1da11d49 aunit.tests%s +D aunit-time_measure.ads 20260101213759 d9c247b0 aunit.time_measure%s +D gnat.ads 20250808065140 b5988c27 gnat%s +D g-souinf.ads 20250808065140 470146ee gnat.source_info%s +D interfac.ads 20250808065140 9111f9c1 interfaces%s +D i-c.ads 20250808065140 e94c966a interfaces.c%s +D i-cstrea.ads 20250808065140 ffd01b9d interfaces.c_streams%s +D system.ads 20250808065140 14286b0f system%s +D s-crtl.ads 20250808065140 beb39b9e system.crtl%s +D s-exctab.ads 20250808065140 91bef6ef system.exception_table%s +D s-ficobl.ads 20250808065140 dc5161d4 system.file_control_block%s +D s-finpri.ads 20250808065140 5970d55a system.finalization_primitives%s +D s-finroo.ads 20250808065140 0a7c3ed4 system.finalization_root%s +D s-oscons.ads 20250827122531 068e1a91 system.os_constants%s +D s-oslock.ads 20250808065140 13fa6b78 system.os_locks%s +D s-parame.ads 20250808065140 3597fc11 system.parameters%s +D s-pooglo.ads 20250808065140 91708d21 system.pool_global%s +D s-putima.ads 20250808065140 17291fe4 system.put_images%s +D s-retsta.ads 20250808065140 0f6b06cb system.return_stack%s +D s-secsta.ads 20250808065140 578279f5 system.secondary_stack%s +D s-soflin.ads 20250808065140 5d88fdea system.soft_links%s +D s-stache.ads 20250808065140 0b81c1fe system.stack_checking%s +D s-stalib.ads 20250808065140 1c9580f6 system.standard_library%s +D s-stoele.ads 20250808065140 ccded4e8 system.storage_elements%s +D s-stopoo.ads 20250808065140 e9fa2dd8 system.storage_pools%s +D s-stratt.ads 20250808065140 516607ae system.stream_attributes%s +D s-traent.ads 20250808065140 c81cbf8c system.traceback_entries%s +D s-unstyp.ads 20250808065140 fa2a7f59 system.unsigned_types%s +D s-wchcon.ads 20250808065140 d9032363 system.wch_con%s +D s-wchstw.ads 20250808065140 2d112c01 system.wch_stw%s +D test_runner.adb 20260101213641 f5664205 test_runner%b +D tinyaml_tests.ads 20260101213037 0cf8d619 tinyaml_tests%s +G a e +G c Z b b [test_runner standard 8 11 none] +G r i none [test_runner standard 8 11 none] [test_runner aunit__run 42 14 none] +G r s text_reporter [test_runner standard 8 11 none] [text_reporterIP aunit__reporter__text 62 9 none] +G r s result [test_runner standard 8 11 none] [resultIP aunit__test_results 140 9 none] +G r c none [test_runner standard 8 11 none] [clear aunit__test_results 133 14 none] +G r c none [test_runner standard 8 11 none] [suite tinyaml_tests 8 13 none] +G r c none [test_runner standard 8 11 none] [run aunit__run 37 14 none] +X 17 aunit.ads +34K9*AUnit 48e10 59|3r6 4r6 9r25 10r15 +X 21 aunit-reporter.ads +36K15*Reporter 58e19 59|3r12 10r21 +X 22 aunit-reporter-text.ads +33K24*Text 66e24 59|3w21 10r30 +35R9*Text_Reporter<21|38R9> 64e14 59|10r35 +X 23 aunit-run.ads +38K15*Run 65e14 59|4w12 9r31 +42u14*Test_Runner 59|9r35 +X 28 aunit-test_suites.ads +44P9*Access_Test_Suite(43R9) +X 59 test_runner.adb +8U11*Test_Runner 8b11 13l5 13t16 +9U14 Run[23|42] 24|79b14 59|12s4 +10r4 Reporter{22|35R9} 12r9 +X 60 tinyaml_tests.ads +6K9*Tinyaml_Tests 59|6w6 9r48 60|10e18 +8V13*Suite{28|44P9} 59|9r62 + diff --git a/tests/obj/test_runner.bexch b/tests/obj/test_runner.bexch new file mode 100644 index 0000000..c56b228 --- /dev/null +++ b/tests/obj/test_runner.bexch @@ -0,0 +1,35 @@ +[GENERATED OBJECT FILE] +b__test_runner.o +[PROJECT FILES] +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/tinyaml_tests.gpr +20260101214059 fd96543b4c82de96cb5ee18c7cbf43a6 +/var/home/geewiz/.local/share/alire/builds/aunit_26.0.0_b882e96a/78c67a8b011e08e5500962fc633efb7809a9c7391b64fc383bbaebb1096eadc4/lib/gnat/aunit_shared.gpr +20260101213759 41ab5a8efd62f124d037415ee3ae20c7 +/var/home/geewiz/.local/share/alire/builds/aunit_26.0.0_b882e96a/78c67a8b011e08e5500962fc633efb7809a9c7391b64fc383bbaebb1096eadc4/lib/gnat/aunit.gpr +20260101213759 f53422d4a3d8e43997a8fdd15e41c19f +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/config/tinyaml_config.gpr +20260101214131 5386cd48cd19a5f7078359052cc4fe00 +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tinyaml.gpr +20251225150117 d61662c98c8ea8a213f07aefe876f0b2 +[BOUND OBJECT FILES] +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml-lexer_tests.o +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml-parser_tests.o +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml-validation_tests.o +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/tinyaml_tests.o +/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/test_runner.o +[GENERATED SOURCE FILES] +b__test_runner.ads +b__test_runner.adb +b__test_runner.ali +[RESULTING OPTIONS] +-L/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/ +-L/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/tests/obj/ +-L/var/home/geewiz/Projects/src/geewiz/tinyaml_ada/lib/ +-L/var/home/geewiz/.local/share/alire/builds/aunit_26.0.0_b882e96a/78c67a8b011e08e5500962fc633efb7809a9c7391b64fc383bbaebb1096eadc4/lib/aunit/native-full/ +-L/var/home/geewiz/.local/share/alire/toolchains/gnat_native_15.2.1_4640d4b3/lib/gcc/x86_64-pc-linux-gnu/15.2.0/adalib/ +-static +/var/home/geewiz/.local/share/alire/toolchains/gnat_native_15.2.1_4640d4b3/lib/gcc/x86_64-pc-linux-gnu/15.2.0/adalib/libgnarl.a +/var/home/geewiz/.local/share/alire/toolchains/gnat_native_15.2.1_4640d4b3/lib/gcc/x86_64-pc-linux-gnu/15.2.0/adalib/libgnat.a +-lrt +-lpthread +-ldl diff --git a/tests/obj/test_runner.cswi b/tests/obj/test_runner.cswi new file mode 100644 index 0000000..b72a32a --- /dev/null +++ b/tests/obj/test_runner.cswi @@ -0,0 +1,9 @@ +20260101214132 +-c +-x +ada +-gnatA +-gnat2022 +-gnata +-g +-gnatwa diff --git a/tests/obj/test_runner.o b/tests/obj/test_runner.o new file mode 100644 index 0000000..59997d7 Binary files /dev/null and b/tests/obj/test_runner.o differ diff --git a/tests/obj/tinyaml-lexer_tests.adb.stderr b/tests/obj/tinyaml-lexer_tests.adb.stderr new file mode 100644 index 0000000..21b0035 --- /dev/null +++ b/tests/obj/tinyaml-lexer_tests.adb.stderr @@ -0,0 +1 @@ +tinyaml-lexer_tests.adb:217:24: warning: use of an anonymous access type allocator [-gnatw_a] diff --git a/tests/obj/tinyaml-lexer_tests.adb.stdout b/tests/obj/tinyaml-lexer_tests.adb.stdout new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/tinyaml-lexer_tests.ali b/tests/obj/tinyaml-lexer_tests.ali new file mode 100644 index 0000000..d5cbc5a --- /dev/null +++ b/tests/obj/tinyaml-lexer_tests.ali @@ -0,0 +1,379 @@ +V "GNAT Lib v15" +A -gnatA +A -gnat2022 +A -gnata +A -g +A -gnatwa +A -mtune=generic +A -march=x86-64 +P SS ZX + +RN +RV NO_ACCESS_PARAMETER_ALLOCATORS +RV NO_ALLOCATORS +RV NO_ANONYMOUS_ALLOCATORS +RV NO_DIRECT_BOOLEAN_OPERATORS +RV NO_DISPATCH +RV NO_DISPATCHING_CALLS +RV NO_EXCEPTION_HANDLERS +RV NO_EXCEPTION_PROPAGATION +RV NO_EXCEPTIONS +RV NO_LOCAL_ALLOCATORS +RV NO_NESTED_FINALIZATION +RV NO_SECONDARY_STACK +RV NO_STANDARD_STORAGE_POOLS +RV NO_DEFAULT_INITIALIZATION +RV NO_IMPLEMENTATION_PRAGMAS +RV NO_ELABORATION_CODE +RV NO_OBSOLESCENT_FEATURES + +U tinyaml.lexer_tests%b tinyaml-lexer_tests.adb a24f61e2 OO PF PK +W ada%s ada.ads ada.ali +Z ada.exceptions%s a-except.adb a-except.ali +W ada.strings%s a-string.ads a-string.ali +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +W ada.strings.unbounded%s a-strunb.adb a-strunb.ali +W aunit%s aunit.adb aunit.ali +W aunit.assertions%s aunit-assertions.adb aunit-assertions.ali +Z system%s system.ads system.ali +Z system.finalization_primitives%s s-finpri.adb s-finpri.ali +Z system.pool_global%s s-pooglo.adb s-pooglo.ali +Z system.secondary_stack%s s-secsta.adb s-secsta.ali +Z system.soft_links%s s-soflin.adb s-soflin.ali +Z system.standard_library%s s-stalib.adb s-stalib.ali +Z system.storage_elements%s s-stoele.ads s-stoele.ali +Z system.storage_pools%s s-stopoo.adb s-stopoo.ali +Z system.storage_pools.subpools%s s-stposu.adb s-stposu.ali +W tinyaml%s tinyaml.adb tinyaml.ali +W tinyaml.lexer%s tinyaml-lexer.adb tinyaml-lexer.ali + +U tinyaml.lexer_tests%s tinyaml-lexer_tests.ads 925e1f4f EE OO PF PK +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +Z ada.tags%s a-tags.adb a-tags.ali +W aunit%s aunit.adb aunit.ali +W aunit.test_cases%s aunit-test_cases.adb aunit-test_cases.ali +W aunit.test_suites%s aunit-test_suites.adb aunit-test_suites.ali +Z system%s system.ads system.ali +Z system.soft_links%s s-soflin.adb s-soflin.ali +W tinyaml%s tinyaml.adb tinyaml.ali + +D ada.ads 20250808065140 76789da1 ada%s +D a-calend.ads 20250808065140 bf7f3cc9 ada.calendar%s +D a-charac.ads 20250808065140 2d3ec45b ada.characters%s +D a-chlat1.ads 20250808065140 e0d72e76 ada.characters.latin_1%s +D a-except.ads 20250808065140 e7970cd9 ada.exceptions%s +D a-finali.ads 20250808065140 bf4f806b ada.finalization%s +D a-inteio.ads 20250808065140 f64b89a4 ada.integer_text_io%s +D a-ioexce.ads 20250808065140 40018c65 ada.io_exceptions%s +D a-stream.ads 20250808065140 17477cbd ada.streams%s +D a-string.ads 20250808065140 90ac6797 ada.strings%s +D a-strmap.ads 20250808065140 1f91ebb6 ada.strings.maps%s +D a-strsea.ads 20250808065140 18c3c634 ada.strings.search%s +D a-sttebu.ads 20250808065140 f1ad67a2 ada.strings.text_buffers%s +D a-strunb.ads 20250808065140 b10770ab ada.strings.unbounded%s +D a-stuten.ads 20250808065140 c6ced0ae ada.strings.utf_encoding%s +D a-tags.ads 20250808065140 fbca0ad5 ada.tags%s +D a-textio.ads 20250808065140 34ef47de ada.text_io%s +D a-tiinio.ads 20250808065140 76699c8f ada.text_io.integer_io%s +D a-unccon.ads 20250808065140 0e9b276f ada.unchecked_conversion%s +D ada_containers.ads 20260101213759 11329e00 ada_containers%s +D ada_containers-aunit_lists.ads 20260101213759 d9ebc89a ada_containers.aunit_lists%s +D aunit.ads 20260101213759 76cdf7c6 aunit%s +D aunit-assertions.ads 20260101213759 b7f9ecd6 aunit.assertions%s +D aunit-io.ads 20260101213759 fb5ed18b aunit.io%s +D aunit-options.ads 20260101213759 6e5a02a6 aunit.options%s +D aunit-simple_test_cases.ads 20260101213759 4111c32f aunit.simple_test_cases%s +D aunit-test_cases.ads 20260101213759 3fb77584 aunit.test_cases%s +D aunit-test_filters.ads 20260101213759 f10b2127 aunit.test_filters%s +D aunit-test_results.ads 20260101213759 b44de7dc aunit.test_results%s +D aunit-test_suites.ads 20260101213759 6821dc24 aunit.test_suites%s +D aunit-tests.ads 20260101213759 1da11d49 aunit.tests%s +D aunit-time_measure.ads 20260101213759 d9c247b0 aunit.time_measure%s +D gnat.ads 20250808065140 b5988c27 gnat%s +D g-souinf.ads 20250808065140 470146ee gnat.source_info%s +D interfac.ads 20250808065140 9111f9c1 interfaces%s +D i-c.ads 20250808065140 e94c966a interfaces.c%s +D i-cstrea.ads 20250808065140 ffd01b9d interfaces.c_streams%s +D system.ads 20250808065140 14286b0f system%s +D s-atocou.ads 20250808065140 dc18efc3 system.atomic_counters%s +D s-crtl.ads 20250808065140 beb39b9e system.crtl%s +D s-exctab.ads 20250808065140 91bef6ef system.exception_table%s +D s-ficobl.ads 20250808065140 dc5161d4 system.file_control_block%s +D s-finpri.ads 20250808065140 5970d55a system.finalization_primitives%s +D s-finroo.ads 20250808065140 0a7c3ed4 system.finalization_root%s +D s-memory.ads 20250808065140 18949c1a system.memory%s +D s-oscons.ads 20250827122531 068e1a91 system.os_constants%s +D s-oslock.ads 20250808065140 13fa6b78 system.os_locks%s +D s-parame.ads 20250808065140 3597fc11 system.parameters%s +D s-pooglo.ads 20250808065140 91708d21 system.pool_global%s +D s-putima.ads 20250808065140 17291fe4 system.put_images%s +D s-retsta.ads 20250808065140 0f6b06cb system.return_stack%s +D s-secsta.ads 20250808065140 578279f5 system.secondary_stack%s +D s-soflin.ads 20250808065140 5d88fdea system.soft_links%s +D s-stache.ads 20250808065140 0b81c1fe system.stack_checking%s +D s-stalib.ads 20250808065140 1c9580f6 system.standard_library%s +D s-stalib.adb 20250808065140 eb464a47 system.standard_library%b +D s-stoele.ads 20250808065140 ccded4e8 system.storage_elements%s +D s-stopoo.ads 20250808065140 e9fa2dd8 system.storage_pools%s +D s-stposu.ads 20250808065140 e0b9fefd system.storage_pools.subpools%s +D s-stratt.ads 20250808065140 516607ae system.stream_attributes%s +D s-traent.ads 20250808065140 c81cbf8c system.traceback_entries%s +D s-unstyp.ads 20250808065140 fa2a7f59 system.unsigned_types%s +D s-wchcon.ads 20250808065140 d9032363 system.wch_con%s +D tinyaml.ads 20251229202535 94e37d85 tinyaml%s +D tinyaml-lexer.ads 20251225150117 1b7ff98c tinyaml.lexer%s +D tinyaml-lexer_tests.ads 20260101221409 512bcb6a tinyaml.lexer_tests%s +D tinyaml-lexer_tests.adb 20260101221958 eee5cf79 tinyaml.lexer_tests%b +G a e +G c Z s b [name tinyaml__lexer_tests 8 24 none] +G c Z s b [register_tests tinyaml__lexer_tests 9 25 none] +G c Z s b [suite tinyaml__lexer_tests 11 13 none] +G c Z s b [test_empty_input tinyaml__lexer_tests 15 14 none] +G c Z s b [test_simple_scalar tinyaml__lexer_tests 16 14 none] +G c Z s b [test_quoted_string_double tinyaml__lexer_tests 17 14 none] +G c Z s b [test_quoted_string_single tinyaml__lexer_tests 18 14 none] +G c Z s b [test_escape_sequences tinyaml__lexer_tests 19 14 none] +G c Z s b [test_colon tinyaml__lexer_tests 20 14 none] +G c Z s b [test_dash tinyaml__lexer_tests 21 14 none] +G c Z s b [test_indentation tinyaml__lexer_tests 22 14 none] +G c Z s b [test_dedent tinyaml__lexer_tests 23 14 none] +G c Z s b [test_comment tinyaml__lexer_tests 24 14 none] +G c Z s b [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] +G c Z s b [test_anchor_rejected tinyaml__lexer_tests 26 14 none] +G c Z s b [test_tag_rejected tinyaml__lexer_tests 27 14 none] +G c Z s s [testDF tinyaml__lexer_tests 6 9 none] +G c Z s s [testIP tinyaml__lexer_tests 6 9 none] +G r c none [name tinyaml__lexer_tests 8 24 none] [format aunit 44 13 none] +G r c none [register_tests tinyaml__lexer_tests 9 25 none] [register_routine aunit__test_cases__registration 65 17 none] +G r c none [suite tinyaml__lexer_tests 11 13 none] [new_suite aunit__test_suites 58 13 none] +G r s test_case [suite tinyaml__lexer_tests 11 13 none] [test_caseIP aunit__test_cases 116 9 none] +G r c none [suite tinyaml__lexer_tests 11 13 none] [add_test aunit__test_suites 48 14 none] +G r c none [test_empty_input tinyaml__lexer_tests 15 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_empty_input tinyaml__lexer_tests 15 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_empty_input tinyaml__lexer_tests 15 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_empty_input tinyaml__lexer_tests 15 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_empty_input tinyaml__lexer_tests 15 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_empty_input tinyaml__lexer_tests 15 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_simple_scalar tinyaml__lexer_tests 16 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_simple_scalar tinyaml__lexer_tests 16 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_simple_scalar tinyaml__lexer_tests 16 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_simple_scalar tinyaml__lexer_tests 16 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_simple_scalar tinyaml__lexer_tests 16 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_simple_scalar tinyaml__lexer_tests 16 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_quoted_string_double tinyaml__lexer_tests 17 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_quoted_string_double tinyaml__lexer_tests 17 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_quoted_string_double tinyaml__lexer_tests 17 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_quoted_string_double tinyaml__lexer_tests 17 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_quoted_string_double tinyaml__lexer_tests 17 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_quoted_string_double tinyaml__lexer_tests 17 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_quoted_string_single tinyaml__lexer_tests 18 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_quoted_string_single tinyaml__lexer_tests 18 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_quoted_string_single tinyaml__lexer_tests 18 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_quoted_string_single tinyaml__lexer_tests 18 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_quoted_string_single tinyaml__lexer_tests 18 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_quoted_string_single tinyaml__lexer_tests 18 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_escape_sequences tinyaml__lexer_tests 19 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_escape_sequences tinyaml__lexer_tests 19 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_escape_sequences tinyaml__lexer_tests 19 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_escape_sequences tinyaml__lexer_tests 19 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_escape_sequences tinyaml__lexer_tests 19 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_escape_sequences tinyaml__lexer_tests 19 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_colon tinyaml__lexer_tests 20 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_colon tinyaml__lexer_tests 20 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_colon tinyaml__lexer_tests 20 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_colon tinyaml__lexer_tests 20 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_colon tinyaml__lexer_tests 20 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_colon tinyaml__lexer_tests 20 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_dash tinyaml__lexer_tests 21 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_dash tinyaml__lexer_tests 21 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_dash tinyaml__lexer_tests 21 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_dash tinyaml__lexer_tests 21 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_dash tinyaml__lexer_tests 21 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_dash tinyaml__lexer_tests 21 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_indentation tinyaml__lexer_tests 22 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_indentation tinyaml__lexer_tests 22 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_indentation tinyaml__lexer_tests 22 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_indentation tinyaml__lexer_tests 22 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_indentation tinyaml__lexer_tests 22 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_indentation tinyaml__lexer_tests 22 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_dedent tinyaml__lexer_tests 23 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_dedent tinyaml__lexer_tests 23 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_dedent tinyaml__lexer_tests 23 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_dedent tinyaml__lexer_tests 23 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_dedent tinyaml__lexer_tests 23 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_dedent tinyaml__lexer_tests 23 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_comment tinyaml__lexer_tests 24 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_comment tinyaml__lexer_tests 24 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_comment tinyaml__lexer_tests 24 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_comment tinyaml__lexer_tests 24 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_comment tinyaml__lexer_tests 24 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_comment tinyaml__lexer_tests 24 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_flow_style_rejected tinyaml__lexer_tests 25 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_anchor_rejected tinyaml__lexer_tests 26 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_anchor_rejected tinyaml__lexer_tests 26 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_anchor_rejected tinyaml__lexer_tests 26 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_anchor_rejected tinyaml__lexer_tests 26 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_anchor_rejected tinyaml__lexer_tests 26 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_anchor_rejected tinyaml__lexer_tests 26 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_tag_rejected tinyaml__lexer_tests 27 14 none] [create tinyaml__lexer 32 13 none] +G r s token [test_tag_rejected tinyaml__lexer_tests 27 14 none] [tokenIP tinyaml__lexer 21 9 none] +G r l token [test_tag_rejected tinyaml__lexer_tests 27 14 none] [tokenDI tinyaml__lexer 21 9 none] +G r k token [test_tag_rejected tinyaml__lexer_tests 27 14 none] [tokenDF tinyaml__lexer 21 9 none] +G r c none [test_tag_rejected tinyaml__lexer_tests 27 14 none] [next_token tinyaml__lexer 37 14 none] +G r c none [test_tag_rejected tinyaml__lexer_tests 27 14 none] [assert aunit__assertions 48 14 none] +G r s test_case [testIP tinyaml__lexer_tests 6 9 none] [test_caseIP aunit__test_cases 116 9 none] +X 1 ada.ads +18K9*Ada 22e8 67|1r6 9r8 +X 10 a-string.ads +16K13*Strings 35e16 67|1r10 9r12 +X 14 a-strunb.ads +91K21*Unbounded 1641e26 67|1w18 9r20 +135V13*To_String{string} 67|57s15 69s15 79s15 91s15 101s15 106s15 118s15 +. 128s15 137s15 154s15 164s15 +X 21 ada_containers-aunit_lists.ads +53R9*Cursor +X 22 aunit.ads +34K9*AUnit 48e10 66|1r6 1r28 2r6 8r47 11r26 67|3r6 3r28 10r8 12r47 15r14 +. 213r26 214r25 215r9 +36P9*Message_String(string) 66|8r53 67|12r53 +44V13*Format{36P9} 67|15s20 +X 23 aunit-assertions.ads +44K15*Assertions 155e21 67|3w12 3r34 +48U14*Assert 67|47s7 56s7 57s7 59s7 68s7 69s7 78s7 79s7 90s7 91s7 100s7 101s7 +. 103s7 105s7 106s7 115s7 117s7 118s7 127s7 128s7 130s7 132s7 134s7 136s7 +. 137s7 151s7 153s7 154s7 163s7 164s7 166s7 178s10 192s10 206s10 +101U14*Init_Test +104U14*Clear_Failures +107V13*Has_Failures{boolean} +110R9*Failure_Iter<21|53R9[145]> +113V13*First_Failure{110R9} +X 26 aunit-simple_test_cases.ads +57U14*Set_Up +60U14*Tear_Down +X 27 aunit-test_cases.ads +39K15*Test_Cases 121e21 66|1w12 1r34 67|10r14 +41H9*Test_Case<26|44R9> 119e14 66|6r21 15r43 16r45 17r52 18r52 19r48 20r37 +. 21r36 22r43 23r38 24r39 25r51 26r47 27r44 67|41r43 50r45 62r52 72r52 82r48 +. 94r37 109r36 121r43 140r38 157r39 171r51 185r47 199r44 +57U14*Set_Up_Case +60U14*Tear_Down_Case +63K12*Registration 74e20 67|10r25 +65U17*Register_Routine 67|20s7 21s7 22s7 24s7 26s7 29s7 30s7 31s7 32s7 33s7 +. 34s7 36s7 38s7 +91U14*Run<26|67p14> +98U14*Run_Test<26|53p14> +101V13*Routine_Name{22|36P9}<26|50p13> +X 30 aunit-test_suites.ads +41K15*Test_Suites 86e22 66|2w12 11r32 67|213r32 214r31 215r15 +44P9*Access_Test_Suite(43R9) 66|11r44 67|213r44 214r43 +48U14*Add_Test 67|217s14 +58V13*New_Suite{44P9} 67|215s27 +X 38 system.ads +67M9*Address +X 45 s-memory.ads +51V13*Alloc{38|67M9} 101i22 +66U14*Free 102i22 +74V13*Realloc{38|67M9} 103i22 +X 56 s-stalib.adb +87U14 Break_Start 88i22 +X 64 tinyaml.ads +4K9*Tinyaml 64e12 66|4r9 29r5 67|5r6 5r25 7r14 180r15 194r15 208r15 221r5 +15X4*Parse_Error 67|180r23 194r23 208r23 +X 65 tinyaml-lexer.ads +6K17*Lexer 81e18 67|5w14 5r33 +10n7*Token_EOF{9E9} 67|47r26 59r26 149r58 167r49 +11n7*Token_Newline{9E9} 67|132r26 167r21 +12n7*Token_Indent{9E9} 67|134r26 +13n7*Token_Dedent{9E9} 67|149r31 151r26 +14n7*Token_Colon{9E9} 67|103r26 130r26 +15n7*Token_Dash{9E9} 67|115r26 +18n7*Token_Scalar{9E9} 67|56r26 68r26 78r26 90r26 100r26 105r26 117r26 127r26 +. 136r26 153r26 163r26 +21R9*Token 25e14 67|44r13 53r13 65r13 75r13 85r18 97r13 112r13 124r13 145r13 +. 160r13 174r13 188r13 202r13 +22e7*Kind{9E9} 67|47r19 56r19 59r19 68r19 78r19 90r19 100r19 103r19 105r19 +. 115r19 117r19 127r19 130r19 132r19 134r19 136r19 149r24 149r51 151r19 153r19 +. 163r19 167r14 167r42 +23r7*Value{14|105R9} 67|57r30 69r30 79r30 91r30 101r30 106r30 118r30 128r30 +. 137r30 154r30 164r30 +28R9*Lexer_State 79e14 67|43r13 52r13 64r13 74r13 84r18 96r13 111r13 123r13 +. 144r13 159r13 173r13 187r13 201r13 +32V13*Create{28R9} 67|43s28 52s28 64s28 74s28 84s33 96s28 111s28 123s28 144s28 +. 159s28 173s28 187s28 201s28 +37U14*Next_Token 67|46s7 55s7 58s7 67s7 77s7 89s7 99s7 102s7 104s7 114s7 +. 116s7 126s7 129s7 131s7 133s7 135s7 148s10 152s7 162s7 165s7 177s10 191s10 +. 205s10 +X 66 tinyaml-lexer_tests.ads +4K17*Lexer_Tests 64|4k9 66|15E14 29l13 29e24 67|7b22 221l13 221t24 +6R9*Test<27|41R9> 23|101p14 104p14 107p13 113p13 26|57p14 60p14 27|57p14 +. 60p14 91P14 98P14 101P13 66|6e47 8P24 8r34 9P25 9r52 67|12r34 18r52 217r28 +8V24*Name{22|36P9}<26|47p13> 8>30 67|12b24 16l8 16t12 +8r30 T{6R9} 67|12b30 13r28 +9U25*Register_Tests<27|54p14> 9=41 67|18b25 39l8 39t22 +9r41 T{6R9} 67|18b41 20m25 21m25 23m10 25m10 27m10 29m25 30m25 31m25 32m25 +. 33m25 35m10 37m10 38m25 +11V13*Suite{30|44P9} 67|213b13 219l8 219t13 +15U14 Test_Empty_Input 15=32 67|20r28 41b14 48l8 48t24 +15c32 T<27|41R9> 67|41b32 42r28 +16U14 Test_Simple_Scalar 16=34 67|21r28 50b14 60l8 60t26 +16c34 T<27|41R9> 67|50b34 51r28 +17U14 Test_Quoted_String_Double 17=41 67|23r13 62b14 70l8 70t33 +17c41 T<27|41R9> 67|62b41 63r28 +18U14 Test_Quoted_String_Single 18=41 67|25r13 72b14 80l8 80t33 +18c41 T<27|41R9> 67|72b41 73r28 +19U14 Test_Escape_Sequences 19=37 67|27r13 82b14 92l8 92t29 +19c37 T<27|41R9> 67|82b37 83r28 +20U14 Test_Colon 20=26 67|29r28 94b14 107l8 107t18 +20c26 T<27|41R9> 67|94b26 95r28 +21U14 Test_Dash 21=25 67|30r28 109b14 119l8 119t17 +21c25 T<27|41R9> 67|109b25 110r28 +22U14 Test_Indentation 22=32 67|31r28 121b14 138l8 138t24 +22c32 T<27|41R9> 67|121b32 122r28 +23U14 Test_Dedent 23=27 67|32r28 140b14 155l8 155t19 +23c27 T<27|41R9> 67|140b27 141r28 +24U14 Test_Comment 24=28 67|33r28 157b14 169l8 169t20 +24c28 T<27|41R9> 67|157b28 158r28 +25U14 Test_Flow_Style_Rejected 25=40 67|35r13 171b14 183l8 183t32 +25c40 T<27|41R9> 67|171b40 172r28 +26U14 Test_Anchor_Rejected 26=36 67|37r13 185b14 197l8 197t28 +26c36 T<27|41R9> 67|185b36 186r28 +27U14 Test_Tag_Rejected 27=33 67|38r28 199b14 211l8 211t25 +27c33 T<27|41R9> 67|199b33 200r28 +X 67 tinyaml-lexer_tests.adb +43r7 L{65|28R9} 46m19 46r19 +44r7 Tok{65|21R9} 46m22 47r15 +52r7 L{65|28R9} 55m19 55r19 58m19 58r19 +53r7 Tok{65|21R9} 55m22 56r15 57r26 58m22 59r15 +64r7 L{65|28R9} 67m19 67r19 +65r7 Tok{65|21R9} 67m22 68r15 69r26 +74r7 L{65|28R9} 77m19 77r19 +75r7 Tok{65|21R9} 77m22 78r15 79r26 +84r7 L{65|28R9} 89m19 89r19 +85r7 Tok{65|21R9} 89m22 90r15 91r26 +86a7 Expected{string} 91r39 +96r7 L{65|28R9} 99m19 99r19 102m19 102r19 104m19 104r19 +97r7 Tok{65|21R9} 99m22 100r15 101r26 102m22 103r15 104m22 105r15 106r26 +111r7 L{65|28R9} 114m19 114r19 116m19 116r19 +112r7 Tok{65|21R9} 114m22 115r15 116m22 117r15 118r26 +123r7 L{65|28R9} 126m19 126r19 129m19 129r19 131m19 131r19 133m19 133r19 +. 135m19 135r19 +124r7 Tok{65|21R9} 126m22 127r15 128r26 129m22 130r15 131m22 132r15 133m22 +. 134r15 135m22 136r15 137r26 +142a7 Input{string} 144r36 +144r7 L{65|28R9} 148m22 148r22 152m19 152r19 +145r7 Tok{65|21R9} 148m25 149r20 149r47 151r15 152m22 153r15 154r26 +159r7 L{65|28R9} 162m19 162r19 165m19 165r19 +160r7 Tok{65|21R9} 162m22 163r15 164r26 165m22 167r10 167r38 +173r7 L{65|28R9} 177m22 177r22 +174r7 Tok{65|21R9} 177m25 +187r7 L{65|28R9} 191m22 191r22 +188r7 Tok{65|21R9} 191m25 +201r7 L{65|28R9} 205m22 205r22 +202r7 Tok{65|21R9} 205m25 +214p7 Result{30|44P9} 217r7 218r14 + diff --git a/tests/obj/tinyaml-lexer_tests.cswi b/tests/obj/tinyaml-lexer_tests.cswi new file mode 100644 index 0000000..230ca10 --- /dev/null +++ b/tests/obj/tinyaml-lexer_tests.cswi @@ -0,0 +1,9 @@ +20260101222044 +-c +-x +ada +-gnatA +-gnat2022 +-gnata +-g +-gnatwa diff --git a/tests/obj/tinyaml-lexer_tests.o b/tests/obj/tinyaml-lexer_tests.o new file mode 100644 index 0000000..c1f6a2b Binary files /dev/null and b/tests/obj/tinyaml-lexer_tests.o differ diff --git a/tests/obj/tinyaml-parser_tests.adb.stderr b/tests/obj/tinyaml-parser_tests.adb.stderr new file mode 100644 index 0000000..4726b6c --- /dev/null +++ b/tests/obj/tinyaml-parser_tests.adb.stderr @@ -0,0 +1 @@ +tinyaml-parser_tests.adb:258:24: warning: use of an anonymous access type allocator [-gnatw_a] diff --git a/tests/obj/tinyaml-parser_tests.adb.stdout b/tests/obj/tinyaml-parser_tests.adb.stdout new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/tinyaml-parser_tests.ali b/tests/obj/tinyaml-parser_tests.ali new file mode 100644 index 0000000..0ebcd78 --- /dev/null +++ b/tests/obj/tinyaml-parser_tests.ali @@ -0,0 +1,424 @@ +V "GNAT Lib v15" +A -gnatA +A -gnat2022 +A -gnata +A -g +A -gnatwa +A -mtune=generic +A -march=x86-64 +P SS ZX + +RN +RV NO_ACCESS_PARAMETER_ALLOCATORS +RV NO_ALLOCATORS +RV NO_ANONYMOUS_ALLOCATORS +RV NO_DISPATCH +RV NO_DISPATCHING_CALLS +RV NO_EXCEPTION_HANDLERS +RV NO_EXCEPTION_PROPAGATION +RV NO_EXCEPTIONS +RV NO_LOCAL_ALLOCATORS +RV NO_NESTED_FINALIZATION +RV NO_SECONDARY_STACK +RV NO_STANDARD_STORAGE_POOLS +RV NO_DEFAULT_INITIALIZATION +RV NO_IMPLEMENTATION_PRAGMAS +RV NO_ELABORATION_CODE +RV NO_OBSOLESCENT_FEATURES + +U tinyaml.parser_tests%b tinyaml-parser_tests.adb 25bcafd3 OO PF PK +Z ada.exceptions%s a-except.adb a-except.ali +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +Z ada.tags%s a-tags.adb a-tags.ali +W aunit%s aunit.adb aunit.ali +W aunit.assertions%s aunit-assertions.adb aunit-assertions.ali +Z system%s system.ads system.ali +Z system.finalization_primitives%s s-finpri.adb s-finpri.ali +Z system.pool_global%s s-pooglo.adb s-pooglo.ali +Z system.secondary_stack%s s-secsta.adb s-secsta.ali +Z system.soft_links%s s-soflin.adb s-soflin.ali +Z system.standard_library%s s-stalib.adb s-stalib.ali +Z system.storage_elements%s s-stoele.ads s-stoele.ali +Z system.storage_pools%s s-stopoo.adb s-stopoo.ali +Z system.storage_pools.subpools%s s-stposu.adb s-stposu.ali +W tinyaml%s tinyaml.adb tinyaml.ali +W tinyaml.documents%s tinyaml-documents.adb tinyaml-documents.ali +W tinyaml.nodes%s tinyaml-nodes.adb tinyaml-nodes.ali +W tinyaml.nodes.map%s tinyaml-nodes-map.adb tinyaml-nodes-map.ali +W tinyaml.nodes.navigation%s tinyaml-nodes-navigation.adb tinyaml-nodes-navigation.ali +W tinyaml.nodes.scalar%s tinyaml-nodes-scalar.adb tinyaml-nodes-scalar.ali +W tinyaml.nodes.sequence%s tinyaml-nodes-sequence.adb tinyaml-nodes-sequence.ali +W tinyaml.parser%s tinyaml-parser.adb tinyaml-parser.ali + +U tinyaml.parser_tests%s tinyaml-parser_tests.ads aeae59ab EE OO PF PK +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +Z ada.tags%s a-tags.adb a-tags.ali +W aunit%s aunit.adb aunit.ali +W aunit.test_cases%s aunit-test_cases.adb aunit-test_cases.ali +W aunit.test_suites%s aunit-test_suites.adb aunit-test_suites.ali +Z system%s system.ads system.ali +Z system.soft_links%s s-soflin.adb s-soflin.ali +W tinyaml%s tinyaml.adb tinyaml.ali + +D ada.ads 20250808065140 76789da1 ada%s +D a-calend.ads 20250808065140 bf7f3cc9 ada.calendar%s +D a-charac.ads 20250808065140 2d3ec45b ada.characters%s +D a-chlat1.ads 20250808065140 e0d72e76 ada.characters.latin_1%s +D a-contai.ads 20250808065140 61e5e089 ada.containers%s +D a-conhel.ads 20250808065140 46fe1ce3 ada.containers.helpers%s +D a-ciorma.ads 20250808065140 1fd25f9a ada.containers.indefinite_ordered_maps%s +D a-coinve.ads 20250808065140 b20d0098 ada.containers.indefinite_vectors%s +D a-crbltr.ads 20250808065140 d3d16ba4 ada.containers.red_black_trees%s +D a-except.ads 20250808065140 e7970cd9 ada.exceptions%s +D a-finali.ads 20250808065140 bf4f806b ada.finalization%s +D a-inteio.ads 20250808065140 f64b89a4 ada.integer_text_io%s +D a-ioexce.ads 20250808065140 40018c65 ada.io_exceptions%s +D a-iteint.ads 20250808065140 49a8bee2 ada.iterator_interfaces%s +D a-stream.ads 20250808065140 17477cbd ada.streams%s +D a-string.ads 20250808065140 90ac6797 ada.strings%s +D a-strmap.ads 20250808065140 1f91ebb6 ada.strings.maps%s +D a-strsea.ads 20250808065140 18c3c634 ada.strings.search%s +D a-sttebu.ads 20250808065140 f1ad67a2 ada.strings.text_buffers%s +D a-strunb.ads 20250808065140 b10770ab ada.strings.unbounded%s +D a-stuten.ads 20250808065140 c6ced0ae ada.strings.utf_encoding%s +D a-tags.ads 20250808065140 fbca0ad5 ada.tags%s +D a-textio.ads 20250808065140 34ef47de ada.text_io%s +D a-tiinio.ads 20250808065140 76699c8f ada.text_io.integer_io%s +D a-unccon.ads 20250808065140 0e9b276f ada.unchecked_conversion%s +D a-uncdea.ads 20250808065140 c3a8ac65 ada.unchecked_deallocation%s +D ada_containers.ads 20260101213759 11329e00 ada_containers%s +D ada_containers-aunit_lists.ads 20260101213759 d9ebc89a ada_containers.aunit_lists%s +D aunit.ads 20260101213759 76cdf7c6 aunit%s +D aunit-assertions.ads 20260101213759 b7f9ecd6 aunit.assertions%s +D aunit-io.ads 20260101213759 fb5ed18b aunit.io%s +D aunit-options.ads 20260101213759 6e5a02a6 aunit.options%s +D aunit-simple_test_cases.ads 20260101213759 4111c32f aunit.simple_test_cases%s +D aunit-test_cases.ads 20260101213759 3fb77584 aunit.test_cases%s +D aunit-test_filters.ads 20260101213759 f10b2127 aunit.test_filters%s +D aunit-test_results.ads 20260101213759 b44de7dc aunit.test_results%s +D aunit-test_suites.ads 20260101213759 6821dc24 aunit.test_suites%s +D aunit-tests.ads 20260101213759 1da11d49 aunit.tests%s +D aunit-time_measure.ads 20260101213759 d9c247b0 aunit.time_measure%s +D gnat.ads 20250808065140 b5988c27 gnat%s +D g-souinf.ads 20250808065140 470146ee gnat.source_info%s +D interfac.ads 20250808065140 9111f9c1 interfaces%s +D i-c.ads 20250808065140 e94c966a interfaces.c%s +D i-cstrea.ads 20250808065140 ffd01b9d interfaces.c_streams%s +D system.ads 20250808065140 14286b0f system%s +D s-atacco.ads 20250808065140 5868e3ba system.address_to_access_conversions%s +D s-atocou.ads 20250808065140 dc18efc3 system.atomic_counters%s +D s-crtl.ads 20250808065140 beb39b9e system.crtl%s +D s-exctab.ads 20250808065140 91bef6ef system.exception_table%s +D s-ficobl.ads 20250808065140 dc5161d4 system.file_control_block%s +D s-finpri.ads 20250808065140 5970d55a system.finalization_primitives%s +D s-finroo.ads 20250808065140 0a7c3ed4 system.finalization_root%s +D s-linux.ads 20250808065140 34850a8c system.linux%s +D s-memory.ads 20250808065140 18949c1a system.memory%s +D s-multip.ads 20250808065140 38ac9f73 system.multiprocessors%s +D s-oscons.ads 20250827122531 068e1a91 system.os_constants%s +D s-osinte.ads 20250808065140 89e0af7e system.os_interface%s +D s-oslock.ads 20250808065140 13fa6b78 system.os_locks%s +D s-parame.ads 20250808065140 3597fc11 system.parameters%s +D s-pooglo.ads 20250808065140 91708d21 system.pool_global%s +D s-putima.ads 20250808065140 17291fe4 system.put_images%s +D s-retsta.ads 20250808065140 0f6b06cb system.return_stack%s +D s-secsta.ads 20250808065140 578279f5 system.secondary_stack%s +D s-soflin.ads 20250808065140 5d88fdea system.soft_links%s +D s-stache.ads 20250808065140 0b81c1fe system.stack_checking%s +D s-stausa.ads 20250808065140 5be75682 system.stack_usage%s +D s-stalib.ads 20250808065140 1c9580f6 system.standard_library%s +D s-stalib.adb 20250808065140 eb464a47 system.standard_library%b +D s-stoele.ads 20250808065140 ccded4e8 system.storage_elements%s +D s-stopoo.ads 20250808065140 e9fa2dd8 system.storage_pools%s +D s-stposu.ads 20250808065140 e0b9fefd system.storage_pools.subpools%s +D s-stratt.ads 20250808065140 516607ae system.stream_attributes%s +D s-string.ads 20250808065140 582aac7d system.strings%s +D s-ststop.ads 20250808065140 c569db7c system.strings.stream_ops%s +D s-tasinf.ads 20250808065140 528dde74 system.task_info%s +D s-taspri.ads 20250808065140 1e109e82 system.task_primitives%s +D s-taskin.ads 20250808065140 38289021 system.tasking%s +D s-traent.ads 20250808065140 c81cbf8c system.traceback_entries%s +D s-unstyp.ads 20250808065140 fa2a7f59 system.unsigned_types%s +D s-wchcon.ads 20250808065140 d9032363 system.wch_con%s +D tinyaml.ads 20251229202535 94e37d85 tinyaml%s +D tinyaml-documents.ads 20251229202232 aa3817f9 tinyaml.documents%s +D tinyaml-nodes.ads 20251229202232 db7385c5 tinyaml.nodes%s +D tinyaml-nodes-map.ads 20251225150117 0cd36f20 tinyaml.nodes.map%s +D tinyaml-nodes-navigation.ads 20251225150117 4291f400 tinyaml.nodes.navigation%s +D tinyaml-nodes-scalar.ads 20251225150117 7f5ce3b7 tinyaml.nodes.scalar%s +D tinyaml-nodes-sequence.ads 20251225150117 bac1f71a tinyaml.nodes.sequence%s +D tinyaml-parser.ads 20251229202232 6a4d2cd3 tinyaml.parser%s +D tinyaml-parser_tests.ads 20260101221554 6ddb8d8e tinyaml.parser_tests%s +D tinyaml-parser_tests.adb 20260101222014 6f47ffe9 tinyaml.parser_tests%b +G a e +G c Z s b [name tinyaml__parser_tests 8 24 none] +G c Z s b [register_tests tinyaml__parser_tests 9 25 none] +G c Z s b [suite tinyaml__parser_tests 11 13 none] +G c Z s b [test_empty_input tinyaml__parser_tests 15 14 none] +G c Z s b [test_simple_scalar tinyaml__parser_tests 16 14 none] +G c Z s b [test_simple_mapping tinyaml__parser_tests 17 14 none] +G c Z s b [test_nested_mapping tinyaml__parser_tests 18 14 none] +G c Z s b [test_simple_sequence tinyaml__parser_tests 19 14 none] +G c Z s b [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] +G c Z s b [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] +G c Z s b [test_duplicate_key_rejected tinyaml__parser_tests 22 14 none] +G c Z s b [test_navigate_path tinyaml__parser_tests 23 14 none] +G c Z s b [test_get_string tinyaml__parser_tests 24 14 none] +G c Z s b [test_parse_document tinyaml__parser_tests 25 14 none] +G c Z s b [test_free_node tinyaml__parser_tests 26 14 none] +G c Z s s [testDF tinyaml__parser_tests 6 9 none] +G c Z s s [testIP tinyaml__parser_tests 6 9 none] +G r c none [name tinyaml__parser_tests 8 24 none] [format aunit 44 13 none] +G r c none [register_tests tinyaml__parser_tests 9 25 none] [register_routine aunit__test_cases__registration 65 17 none] +G r c none [suite tinyaml__parser_tests 11 13 none] [new_suite aunit__test_suites 58 13 none] +G r s test_case [suite tinyaml__parser_tests 11 13 none] [test_caseIP aunit__test_cases 116 9 none] +G r c none [suite tinyaml__parser_tests 11 13 none] [add_test aunit__test_suites 48 14 none] +G r c none [test_empty_input tinyaml__parser_tests 15 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_empty_input tinyaml__parser_tests 15 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_empty_input tinyaml__parser_tests 15 14 none] [is_scalar tinyaml__nodes 27 13 none] +G r c none [test_empty_input tinyaml__parser_tests 15 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r c none [test_simple_scalar tinyaml__parser_tests 16 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_simple_scalar tinyaml__parser_tests 16 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_simple_scalar tinyaml__parser_tests 16 14 none] [is_scalar tinyaml__nodes 27 13 none] +G r c none [test_simple_scalar tinyaml__parser_tests 16 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s map_node [test_simple_mapping tinyaml__parser_tests 17 14 none] [map_nodeIP tinyaml__nodes__map 33 9 none] +G r l map_node [test_simple_mapping tinyaml__parser_tests 17 14 none] [map_nodeDI tinyaml__nodes__map 33 9 none] +G r k map_node [test_simple_mapping tinyaml__parser_tests 17 14 none] [map_nodeDF tinyaml__nodes__map 33 9 none] +G r c none [test_simple_mapping tinyaml__parser_tests 17 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_simple_mapping tinyaml__parser_tests 17 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_simple_mapping tinyaml__parser_tests 17 14 none] [is_map tinyaml__nodes 29 13 none] +G r c none [test_simple_mapping tinyaml__parser_tests 17 14 none] [contains tinyaml__nodes__map 11 13 none] +G r c none [test_simple_mapping tinyaml__parser_tests 17 14 none] [get tinyaml__nodes__map 14 13 none] +G r c none [test_simple_mapping tinyaml__parser_tests 17 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s map_node [test_nested_mapping tinyaml__parser_tests 18 14 none] [map_nodeIP tinyaml__nodes__map 33 9 none] +G r l map_node [test_nested_mapping tinyaml__parser_tests 18 14 none] [map_nodeDI tinyaml__nodes__map 33 9 none] +G r k map_node [test_nested_mapping tinyaml__parser_tests 18 14 none] [map_nodeDF tinyaml__nodes__map 33 9 none] +G r c none [test_nested_mapping tinyaml__parser_tests 18 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_nested_mapping tinyaml__parser_tests 18 14 none] [is_map tinyaml__nodes 29 13 none] +G r c none [test_nested_mapping tinyaml__parser_tests 18 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_nested_mapping tinyaml__parser_tests 18 14 none] [contains tinyaml__nodes__map 11 13 none] +G r c none [test_nested_mapping tinyaml__parser_tests 18 14 none] [get tinyaml__nodes__map 14 13 none] +G r c none [test_nested_mapping tinyaml__parser_tests 18 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s sequence_node [test_simple_sequence tinyaml__parser_tests 19 14 none] [sequence_nodeIP tinyaml__nodes__sequence 26 9 none] +G r l sequence_node [test_simple_sequence tinyaml__parser_tests 19 14 none] [sequence_nodeDI tinyaml__nodes__sequence 26 9 none] +G r k sequence_node [test_simple_sequence tinyaml__parser_tests 19 14 none] [sequence_nodeDF tinyaml__nodes__sequence 26 9 none] +G r c none [test_simple_sequence tinyaml__parser_tests 19 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_simple_sequence tinyaml__parser_tests 19 14 none] [is_sequence tinyaml__nodes 28 13 none] +G r c none [test_simple_sequence tinyaml__parser_tests 19 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_simple_sequence tinyaml__parser_tests 19 14 none] [length tinyaml__nodes__sequence 11 13 none] +G r c none [test_simple_sequence tinyaml__parser_tests 19 14 none] [element tinyaml__nodes__sequence 14 13 none] +G r c none [test_simple_sequence tinyaml__parser_tests 19 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s sequence_node [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [sequence_nodeIP tinyaml__nodes__sequence 26 9 none] +G r l sequence_node [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [sequence_nodeDI tinyaml__nodes__sequence 26 9 none] +G r k sequence_node [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [sequence_nodeDF tinyaml__nodes__sequence 26 9 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [is_sequence tinyaml__nodes 28 13 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [length tinyaml__nodes__sequence 11 13 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [element tinyaml__nodes__sequence 14 13 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [is_map tinyaml__nodes 29 13 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [get tinyaml__nodes__map 14 13 none] +G r c none [test_sequence_of_mappings tinyaml__parser_tests 20 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s map_node [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [map_nodeIP tinyaml__nodes__map 33 9 none] +G r l map_node [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [map_nodeDI tinyaml__nodes__map 33 9 none] +G r k map_node [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [map_nodeDF tinyaml__nodes__map 33 9 none] +G r s sequence_node [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [sequence_nodeIP tinyaml__nodes__sequence 26 9 none] +G r l sequence_node [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [sequence_nodeDI tinyaml__nodes__sequence 26 9 none] +G r k sequence_node [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [sequence_nodeDF tinyaml__nodes__sequence 26 9 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [is_map tinyaml__nodes 29 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [contains tinyaml__nodes__map 11 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [get tinyaml__nodes__map 14 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [is_sequence tinyaml__nodes 28 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [length tinyaml__nodes__sequence 11 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [element tinyaml__nodes__sequence 14 13 none] +G r c none [test_mapping_with_sequence tinyaml__parser_tests 21 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r c none [test_duplicate_key_rejected tinyaml__parser_tests 22 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_duplicate_key_rejected tinyaml__parser_tests 22 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_navigate_path tinyaml__parser_tests 23 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_navigate_path tinyaml__parser_tests 23 14 none] [navigate tinyaml__nodes__navigation 12 13 none] +G r c none [test_navigate_path tinyaml__parser_tests 23 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_navigate_path tinyaml__parser_tests 23 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r c none [test_get_string tinyaml__parser_tests 24 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_get_string tinyaml__parser_tests 24 14 none] [get_string tinyaml__nodes__navigation 19 13 none] +G r c none [test_get_string tinyaml__parser_tests 24 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_parse_document tinyaml__parser_tests 25 14 none] [parse_document tinyaml__parser 19 13 none] +G r c none [test_parse_document tinyaml__parser_tests 25 14 none] [is_empty tinyaml__documents 19 13 none] +G r c none [test_parse_document tinyaml__parser_tests 25 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_parse_document tinyaml__parser_tests 25 14 none] [root tinyaml__documents 22 13 none] +G r c none [test_parse_document tinyaml__parser_tests 25 14 none] [is_map tinyaml__nodes 29 13 none] +G r c none [test_parse_document tinyaml__parser_tests 25 14 none] [get_string tinyaml__nodes__navigation 19 13 none] +G r c none [test_free_node tinyaml__parser_tests 26 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_free_node tinyaml__parser_tests 26 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_free_node tinyaml__parser_tests 26 14 none] [is_map tinyaml__nodes 29 13 none] +G r c none [test_free_node tinyaml__parser_tests 26 14 none] [free_node tinyaml__nodes 32 14 none] +G r s test_case [testIP tinyaml__parser_tests 6 9 none] [test_caseIP aunit__test_cases 116 9 none] +X 14 a-iteint.ads +24h9 Forward_Iterator +32h9 Reversible_Iterator<24R9[7|78]> +X 22 a-tags.ads +653V13 CW_Membership{boolean} 90|50s15 61s10 73s12 76s10 92s12 97s10 97s23 +. 100s10 100s23 115s12 118s10 121s10 124s10 138s12 142s10 142s23 159s12 162s12 +. 165s10 201s10 +X 28 ada_containers-aunit_lists.ads +53R9*Cursor +X 29 aunit.ads +34K9*AUnit 48e10 89|1r6 1r28 2r6 8r47 11r26 90|1r6 1r28 13r8 15r47 18r14 +. 254r26 255r25 256r9 +36P9*Message_String(string) 89|8r53 90|15r53 +44V13*Format{36P9} 90|18s20 +X 30 aunit-assertions.ads +44K15*Assertions 155e21 90|1w12 1r34 +48U14*Assert 90|48s7 49s7 50s7 58s7 59s7 60s7 71s7 72s7 74s7 75s7 91s7 93s7 +. 95s7 96s7 99s7 114s7 116s7 117s7 120s7 123s7 137s7 139s7 140s7 141s7 158s7 +. 160s7 161s7 163s7 164s7 180s13 199s7 200s7 213s7 226s10 227s10 228s10 229s10 +. 232s10 248s7 249s7 251s7 +101U14*Init_Test +104U14*Clear_Failures +107V13*Has_Failures{boolean} +110R9*Failure_Iter<28|53R9[145]> +113V13*First_Failure{110R9} +X 33 aunit-simple_test_cases.ads +57U14*Set_Up +60U14*Tear_Down +X 34 aunit-test_cases.ads +39K15*Test_Cases 121e21 89|1w12 1r34 90|13r14 +41H9*Test_Case<33|44R9> 119e14 89|6r21 15r43 16r45 17r46 18r46 19r47 20r52 +. 21r53 22r54 23r45 24r42 25r46 26r41 90|43r43 53r45 65r46 80r46 104r47 128r52 +. 147r53 169r54 188r45 205r42 216r46 238r41 +57U14*Set_Up_Case +60U14*Tear_Down_Case +63K12*Registration 74e20 90|13r25 +65U17*Register_Routine 90|23s7 24s7 25s7 26s7 27s7 28s7 30s7 32s7 34s7 35s7 +. 37s7 40s7 +91U14*Run<33|67p14> +98U14*Run_Test<33|53p14> +101V13*Routine_Name{29|36P9}<33|50p13> +X 37 aunit-test_suites.ads +41K15*Test_Suites 86e22 89|2w12 11r32 90|254r32 255r31 256r15 +44P9*Access_Test_Suite(43R9) 89|11r44 90|254r44 255r43 +48U14*Add_Test 90|258s14 +58V13*New_Suite{44P9} 90|256s27 +X 45 system.ads +67M9*Address +X 54 s-memory.ads +51V13*Alloc{45|67M9} 101i22 +66U14*Free 102i22 +74V13*Realloc{45|67M9} 103i22 +X 66 s-stausa.ads +207U14*Initialize 208i22 +272U14*Output_Results 276i22 +X 68 s-stalib.adb +87U14 Break_Start 88i22 +X 81 tinyaml.ads +4K9*Tinyaml 64e12 89|4r9 28r5 90|3r6 3r30 4r6 5r6 5r30 6r6 6r30 7r6 7r36 +. 8r6 8r36 9r6 9r36 11r14 47r14 57r14 70r14 90r14 113r14 136r14 157r14 177r43 +. 183r15 197r14 212r14 224r37 247r14 262r5 +15X4*Parse_Error 90|183r23 +X 82 tinyaml-documents.ads +10K17*Documents 39e22 90|3w14 3r38 +16R9*Document<11|50R9> 34e14 90|224r25 +19V13*Is_Empty{boolean} 90|226s22 +22V13*Root{83|16P9} 90|227s18 228s26 230s25 233s25 +X 83 tinyaml-nodes.ads +9K17*Nodes 64e18 90|5w14 5r38 6r14 6r38 7r14 7r44 8r14 8r44 9r14 9r44 +16P9*Node_Access(15R9) 90|45r13 55r13 67r13 86r13 88r13 110r13 133r13 153r13 +. 177r28 194r14 195r14 210r13 245r13 +27V13*Is_Scalar{boolean} 90|49s15 59s15 +28V13*Is_Sequence{boolean} 90|114s15 137s15 161s15 +29V13*Is_Map{boolean} 90|72s15 91s15 95s15 140s15 158s15 228s18 249s15 +32U14*Free_Node 90|250s7 +X 84 tinyaml-nodes-map.ads +3K23*Map 38e22 90|6w20 6r44 +5R9*Map_Node<83|15R9> 36e14 90|68r13 73r12 87r13 92r12 97r23 100r23 142r23 +. 154r13 159r12 +11V13*Contains{boolean} 90|74s17 93s17 160s17 +14V13*Get{83|16P9} 90|76s25 94s15 97s41 100s41 142s52 161s30 162s29 +X 85 tinyaml-nodes-navigation.ads +3K23*Navigation 21e29 90|7w20 7r50 +12V13*Navigate{83|16P9} 90|198s15 +19V13*Get_String{string} 90|213s15 230s13 233s13 +X 86 tinyaml-nodes-scalar.ads +5K23*Scalar 31e25 90|8w20 8r50 +7R9*Scalar_Node<83|15R9> 29e14 90|50r15 61r10 76r10 97r10 100r10 118r10 121r10 +. 124r10 142r10 165r10 201r10 +15V13*Value{string} 90|50s37 61s32 76s42 97s59 100s59 118s42 121s42 124s42 +. 142s70 165s42 201s33 +X 87 tinyaml-nodes-sequence.ads +3K23*Sequence 30e27 90|9w20 9r50 +5R9*Sequence_Node<83|15R9> 28e14 90|111r13 115r12 134r13 138r12 155r13 162r12 +11V13*Length{natural} 90|116s17 139s17 163s17 +14V13*Element{83|16P9} 90|118s25 121s25 124s25 140s25 142s35 165s25 +X 88 tinyaml-parser.ads +7K17*Parser 21e19 90|4w14 47r22 57r22 70r22 90r22 113r22 136r22 157r22 177r51 +. 197r22 212r22 224r45 247r22 +14V13*Parse{83|16P9} 90|47s29 57s29 70s29 90s29 113s29 136s29 157s29 177s58 +. 197s29 212s29 247s29 +19V13*Parse_Document{82|16R9} 90|224s52 +X 89 tinyaml-parser_tests.ads +4K17*Parser_Tests 81|4k9 89|15E14 28l13 28e25 90|11b22 262l13 262t25 +6R9*Test<34|41R9> 30|101p14 104p14 107p13 113p13 33|57p14 60p14 34|57p14 +. 60p14 91P14 98P14 101P13 89|6e47 8P24 8r34 9P25 9r52 90|15r34 21r52 258r28 +8V24*Name{29|36P9}<33|47p13> 8>30 90|15b24 19l8 19t12 +8r30 T{6R9} 90|15b30 16r28 +9U25*Register_Tests<34|54p14> 9=41 90|21b25 41l8 41t22 +9r41 T{6R9} 90|21b41 23m25 24m25 25m25 26m25 27m25 29m10 31m10 33m10 34m25 +. 36m10 38m10 40m25 +11V13*Suite{37|44P9} 90|254b13 260l8 260t13 +15U14 Test_Empty_Input 15=32 90|23r28 43b14 51l8 51t24 +15c32 T<34|41R9> 90|43b32 44r28 +16U14 Test_Simple_Scalar 16=34 90|24r28 53b14 63l8 63t26 +16c34 T<34|41R9> 90|53b34 54r28 +17U14 Test_Simple_Mapping 17=35 90|25r28 65b14 78l8 78t27 +17c35 T<34|41R9> 90|65b35 66r28 +18U14 Test_Nested_Mapping 18=35 90|26r28 80b14 102l8 102t27 +18c35 T<34|41R9> 90|80b35 81r28 +19U14 Test_Simple_Sequence 19=36 90|27r28 104b14 126l8 126t28 +19c36 T<34|41R9> 90|104b36 105r28 +20U14 Test_Sequence_Of_Mappings 20=41 90|29r13 128b14 145l8 145t33 +20c41 T<34|41R9> 90|128b41 129r28 +21U14 Test_Mapping_With_Sequence 21=42 90|31r13 147b14 167l8 167t34 +21c42 T<34|41R9> 90|147b42 148r28 +22U14 Test_Duplicate_Key_Rejected 22=43 90|33r13 169b14 186l8 186t35 +22c43 T<34|41R9> 90|169b43 170r28 +23U14 Test_Navigate_Path 23=34 90|34r28 188b14 203l8 203t26 +23c34 T<34|41R9> 90|188b34 189r28 +24U14 Test_Get_String 24=31 90|36r13 205b14 214l8 214t23 +24c31 T<34|41R9> 90|205b31 206r28 +25U14 Test_Parse_Document 25=35 90|38r13 216b14 236l8 236t27 +25c35 T<34|41R9> 90|216b35 217r28 +26U14 Test_Free_Node 26=30 90|40r28 238b14 252l8 252t22 +26c30 T<34|41R9> 90|238b30 239r28 +X 90 tinyaml-parser_tests.adb +45p7 Doc{83|16P9} 47m7 48r15 49r26 50r28 +55p7 Doc{83|16P9} 57m7 58r15 59r26 61r23 +67p7 Doc{83|16P9} 70m7 71r15 72r23 73r22 +68r7 M{84|5R9} 73m7 74r15 76r23 +82a7 Input{string} 90r36 +86p7 Doc{83|16P9} 90m7 91r23 92r22 +87r7 M{84|5R9} 92m7 93r15 94r13 +88p7 Db{83|16P9} 94m7 95r23 97r33 100r33 +106a7 Input{string} 113r36 +110p7 Doc{83|16P9} 113m7 114r28 115r27 +111r7 S{87|5R9} 115m7 116r15 118r23 121r23 124r23 +130a7 Input{string} 136r36 +133p7 Doc{83|16P9} 136m7 137r28 138r27 +134r7 S{87|5R9} 138m7 139r15 140r23 142r33 +149a7 Input{string} 157r36 +153p7 Doc{83|16P9} 157m7 158r23 159r22 +154r7 M{84|5R9} 159m7 160r15 161r28 162r27 +155r7 S{87|5R9} 162m7 163r15 165r23 +171a7 Input{string} 177r65 +177p13 Doc{83|16P9} 178r34 +190a7 Input{string} 197r36 +194p7 Doc{83|16P9} 197m7 198r25 +195p7 Host{83|16P9} 198m7 199r15 201r23 +207a7 Input{string} 212r36 +210p7 Doc{83|16P9} 212m7 213r27 +218a7 Input{string} 224r68 +224r10 Doc{82|16R9} 226r32 227r24 228r32 230r31 233r31 +240a7 Input{string} 247r36 +245p7 Doc{83|16P9} 247m7 248r15 249r23 250m18 250r18 251r15 +255p7 Result{37|44P9} 258r7 259r14 + diff --git a/tests/obj/tinyaml-parser_tests.cswi b/tests/obj/tinyaml-parser_tests.cswi new file mode 100644 index 0000000..230ca10 --- /dev/null +++ b/tests/obj/tinyaml-parser_tests.cswi @@ -0,0 +1,9 @@ +20260101222044 +-c +-x +ada +-gnatA +-gnat2022 +-gnata +-g +-gnatwa diff --git a/tests/obj/tinyaml-parser_tests.o b/tests/obj/tinyaml-parser_tests.o new file mode 100644 index 0000000..09956b4 Binary files /dev/null and b/tests/obj/tinyaml-parser_tests.o differ diff --git a/tests/obj/tinyaml-validation_tests.adb.stderr b/tests/obj/tinyaml-validation_tests.adb.stderr new file mode 100644 index 0000000..5b9604a --- /dev/null +++ b/tests/obj/tinyaml-validation_tests.adb.stderr @@ -0,0 +1 @@ +tinyaml-validation_tests.adb:311:24: warning: use of an anonymous access type allocator [-gnatw_a] diff --git a/tests/obj/tinyaml-validation_tests.adb.stdout b/tests/obj/tinyaml-validation_tests.adb.stdout new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/tinyaml-validation_tests.ali b/tests/obj/tinyaml-validation_tests.ali new file mode 100644 index 0000000..ed1bd44 --- /dev/null +++ b/tests/obj/tinyaml-validation_tests.ali @@ -0,0 +1,550 @@ +V "GNAT Lib v15" +A -gnatA +A -gnat2022 +A -gnata +A -g +A -gnatwa +A -mtune=generic +A -march=x86-64 +P SS ZX + +RN +RV NO_ACCESS_PARAMETER_ALLOCATORS +RV NO_ALLOCATORS +RV NO_ANONYMOUS_ALLOCATORS +RV NO_DISPATCH +RV NO_DISPATCHING_CALLS +RV NO_EXCEPTION_HANDLERS +RV NO_EXCEPTION_PROPAGATION +RV NO_EXCEPTIONS +RV NO_LOCAL_ALLOCATORS +RV NO_NESTED_FINALIZATION +RV NO_SECONDARY_STACK +RV NO_STANDARD_STORAGE_POOLS +RV NO_DEFAULT_INITIALIZATION +RV NO_IMPLEMENTATION_PRAGMAS +RV NO_ELABORATION_CODE +RV NO_OBSOLESCENT_FEATURES + +U tinyaml.validation_tests%b tinyaml-validation_tests.adb 1bb69cc0 OO PF PK +Z ada.exceptions%s a-except.adb a-except.ali +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +Z ada.tags%s a-tags.adb a-tags.ali +W aunit%s aunit.adb aunit.ali +W aunit.assertions%s aunit-assertions.adb aunit-assertions.ali +Z system%s system.ads system.ali +Z system.finalization_primitives%s s-finpri.adb s-finpri.ali +Z system.pool_global%s s-pooglo.adb s-pooglo.ali +Z system.secondary_stack%s s-secsta.adb s-secsta.ali +Z system.soft_links%s s-soflin.adb s-soflin.ali +Z system.standard_library%s s-stalib.adb s-stalib.ali +Z system.storage_elements%s s-stoele.ads s-stoele.ali +Z system.storage_pools%s s-stopoo.adb s-stopoo.ali +Z system.storage_pools.subpools%s s-stposu.adb s-stposu.ali +W tinyaml%s tinyaml.adb tinyaml.ali +W tinyaml.nodes%s tinyaml-nodes.adb tinyaml-nodes.ali +W tinyaml.nodes.scalar%s tinyaml-nodes-scalar.adb tinyaml-nodes-scalar.ali +W tinyaml.parser%s tinyaml-parser.adb tinyaml-parser.ali +W tinyaml.schemas%s tinyaml-schemas.adb tinyaml-schemas.ali +W tinyaml.schemas.prelude%s tinyaml-schemas-prelude.ads tinyaml-schemas-prelude.ali +W tinyaml.validation%s tinyaml-validation.adb tinyaml-validation.ali + +U tinyaml.validation_tests%s tinyaml-validation_tests.ads 68a97def EE OO PF PK +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +Z ada.tags%s a-tags.adb a-tags.ali +W aunit%s aunit.adb aunit.ali +W aunit.test_cases%s aunit-test_cases.adb aunit-test_cases.ali +W aunit.test_suites%s aunit-test_suites.adb aunit-test_suites.ali +Z system%s system.ads system.ali +Z system.soft_links%s s-soflin.adb s-soflin.ali +W tinyaml%s tinyaml.adb tinyaml.ali + +D ada.ads 20250808065140 76789da1 ada%s +D a-calend.ads 20250808065140 bf7f3cc9 ada.calendar%s +D a-charac.ads 20250808065140 2d3ec45b ada.characters%s +D a-chlat1.ads 20250808065140 e0d72e76 ada.characters.latin_1%s +D a-contai.ads 20250808065140 61e5e089 ada.containers%s +D a-conhel.ads 20250808065140 46fe1ce3 ada.containers.helpers%s +D a-ciorma.ads 20250808065140 1fd25f9a ada.containers.indefinite_ordered_maps%s +D a-coinve.ads 20250808065140 b20d0098 ada.containers.indefinite_vectors%s +D a-crbltr.ads 20250808065140 d3d16ba4 ada.containers.red_black_trees%s +D a-except.ads 20250808065140 e7970cd9 ada.exceptions%s +D a-finali.ads 20250808065140 bf4f806b ada.finalization%s +D a-inteio.ads 20250808065140 f64b89a4 ada.integer_text_io%s +D a-ioexce.ads 20250808065140 40018c65 ada.io_exceptions%s +D a-iteint.ads 20250808065140 49a8bee2 ada.iterator_interfaces%s +D a-stream.ads 20250808065140 17477cbd ada.streams%s +D a-string.ads 20250808065140 90ac6797 ada.strings%s +D a-strmap.ads 20250808065140 1f91ebb6 ada.strings.maps%s +D a-strsea.ads 20250808065140 18c3c634 ada.strings.search%s +D a-sttebu.ads 20250808065140 f1ad67a2 ada.strings.text_buffers%s +D a-strunb.ads 20250808065140 b10770ab ada.strings.unbounded%s +D a-stuten.ads 20250808065140 c6ced0ae ada.strings.utf_encoding%s +D a-tags.ads 20250808065140 fbca0ad5 ada.tags%s +D a-textio.ads 20250808065140 34ef47de ada.text_io%s +D a-tiinio.ads 20250808065140 76699c8f ada.text_io.integer_io%s +D a-unccon.ads 20250808065140 0e9b276f ada.unchecked_conversion%s +D a-uncdea.ads 20250808065140 c3a8ac65 ada.unchecked_deallocation%s +D ada_containers.ads 20260101213759 11329e00 ada_containers%s +D ada_containers-aunit_lists.ads 20260101213759 d9ebc89a ada_containers.aunit_lists%s +D aunit.ads 20260101213759 76cdf7c6 aunit%s +D aunit-assertions.ads 20260101213759 b7f9ecd6 aunit.assertions%s +D aunit-io.ads 20260101213759 fb5ed18b aunit.io%s +D aunit-options.ads 20260101213759 6e5a02a6 aunit.options%s +D aunit-simple_test_cases.ads 20260101213759 4111c32f aunit.simple_test_cases%s +D aunit-test_cases.ads 20260101213759 3fb77584 aunit.test_cases%s +D aunit-test_filters.ads 20260101213759 f10b2127 aunit.test_filters%s +D aunit-test_results.ads 20260101213759 b44de7dc aunit.test_results%s +D aunit-test_suites.ads 20260101213759 6821dc24 aunit.test_suites%s +D aunit-tests.ads 20260101213759 1da11d49 aunit.tests%s +D aunit-time_measure.ads 20260101213759 d9c247b0 aunit.time_measure%s +D gnat.ads 20250808065140 b5988c27 gnat%s +D g-souinf.ads 20250808065140 470146ee gnat.source_info%s +D interfac.ads 20250808065140 9111f9c1 interfaces%s +D i-c.ads 20250808065140 e94c966a interfaces.c%s +D i-cstrea.ads 20250808065140 ffd01b9d interfaces.c_streams%s +D system.ads 20250808065140 14286b0f system%s +D s-atacco.ads 20250808065140 5868e3ba system.address_to_access_conversions%s +D s-atocou.ads 20250808065140 dc18efc3 system.atomic_counters%s +D s-crtl.ads 20250808065140 beb39b9e system.crtl%s +D s-exctab.ads 20250808065140 91bef6ef system.exception_table%s +D s-ficobl.ads 20250808065140 dc5161d4 system.file_control_block%s +D s-finpri.ads 20250808065140 5970d55a system.finalization_primitives%s +D s-finroo.ads 20250808065140 0a7c3ed4 system.finalization_root%s +D s-linux.ads 20250808065140 34850a8c system.linux%s +D s-memory.ads 20250808065140 18949c1a system.memory%s +D s-multip.ads 20250808065140 38ac9f73 system.multiprocessors%s +D s-oscons.ads 20250827122531 068e1a91 system.os_constants%s +D s-osinte.ads 20250808065140 89e0af7e system.os_interface%s +D s-oslock.ads 20250808065140 13fa6b78 system.os_locks%s +D s-parame.ads 20250808065140 3597fc11 system.parameters%s +D s-pooglo.ads 20250808065140 91708d21 system.pool_global%s +D s-putima.ads 20250808065140 17291fe4 system.put_images%s +D s-retsta.ads 20250808065140 0f6b06cb system.return_stack%s +D s-secsta.ads 20250808065140 578279f5 system.secondary_stack%s +D s-soflin.ads 20250808065140 5d88fdea system.soft_links%s +D s-stache.ads 20250808065140 0b81c1fe system.stack_checking%s +D s-stausa.ads 20250808065140 5be75682 system.stack_usage%s +D s-stalib.ads 20250808065140 1c9580f6 system.standard_library%s +D s-stalib.adb 20250808065140 eb464a47 system.standard_library%b +D s-stoele.ads 20250808065140 ccded4e8 system.storage_elements%s +D s-stopoo.ads 20250808065140 e9fa2dd8 system.storage_pools%s +D s-stposu.ads 20250808065140 e0b9fefd system.storage_pools.subpools%s +D s-stratt.ads 20250808065140 516607ae system.stream_attributes%s +D s-string.ads 20250808065140 582aac7d system.strings%s +D s-ststop.ads 20250808065140 c569db7c system.strings.stream_ops%s +D s-tasinf.ads 20250808065140 528dde74 system.task_info%s +D s-taspri.ads 20250808065140 1e109e82 system.task_primitives%s +D s-taskin.ads 20250808065140 38289021 system.tasking%s +D s-traent.ads 20250808065140 c81cbf8c system.traceback_entries%s +D s-unstyp.ads 20250808065140 fa2a7f59 system.unsigned_types%s +D s-wchcon.ads 20250808065140 d9032363 system.wch_con%s +D s-wchstw.ads 20250808065140 2d112c01 system.wch_stw%s +D tinyaml.ads 20251229202535 94e37d85 tinyaml%s +D tinyaml-documents.ads 20251229202232 aa3817f9 tinyaml.documents%s +D tinyaml-nodes.ads 20251229202232 db7385c5 tinyaml.nodes%s +D tinyaml-nodes-map.ads 20251225150117 0cd36f20 tinyaml.nodes.map%s +D tinyaml-nodes-scalar.ads 20251225150117 7f5ce3b7 tinyaml.nodes.scalar%s +D tinyaml-nodes-sequence.ads 20251225150117 bac1f71a tinyaml.nodes.sequence%s +D tinyaml-parser.ads 20251229202232 6a4d2cd3 tinyaml.parser%s +D tinyaml-schemas.ads 20251229202232 9caf3e20 tinyaml.schemas%s +D tinyaml-schemas-any.ads 20251225150117 728f0523 tinyaml.schemas.any%s +D tinyaml-schemas-bool.ads 20251225150117 288c72dc tinyaml.schemas.bool%s +D tinyaml-schemas-constraints.ads 20251225150117 6b52a577 tinyaml.schemas.constraints%s +D tinyaml-schemas-constraints-range_constraint.ads 20251225150117 51213fbb tinyaml.schemas.constraints.range_constraint%s +D tinyaml-schemas-enum.ads 20251225150117 645825e1 tinyaml.schemas.enum%s +D tinyaml-schemas-flt.ads 20251225150117 36045e03 tinyaml.schemas.flt%s +D tinyaml-schemas-int.ads 20251225150117 b1dc4cce tinyaml.schemas.int%s +D tinyaml-schemas-map.ads 20251229202232 57b6f7cc tinyaml.schemas.map%s +D tinyaml-schemas-prelude.ads 20251225150117 bb092a08 tinyaml.schemas.prelude%s +D tinyaml-schemas-seq.ads 20251229202232 c66af91c tinyaml.schemas.seq%s +D tinyaml-schemas-str.ads 20251225150117 b4a30fab tinyaml.schemas.str%s +D tinyaml-validation.ads 20251225150117 703db2e1 tinyaml.validation%s +D tinyaml-validation_tests.ads 20260101221554 abdca9ca tinyaml.validation_tests%s +D tinyaml-validation_tests.adb 20260101222037 02c50b94 tinyaml.validation_tests%b +G a e +G c Z s b [name tinyaml__validation_tests 8 24 none] +G c Z s b [register_tests tinyaml__validation_tests 9 25 none] +G c Z s b [suite tinyaml__validation_tests 11 13 none] +G c Z s b [test_str_schema tinyaml__validation_tests 15 14 none] +G c Z s b [test_int_schema tinyaml__validation_tests 16 14 none] +G c Z s b [test_int_schema_range tinyaml__validation_tests 17 14 none] +G c Z s b [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] +G c Z s b [test_bool_schema tinyaml__validation_tests 19 14 none] +G c Z s b [test_seq_schema tinyaml__validation_tests 20 14 none] +G c Z s b [test_map_schema tinyaml__validation_tests 21 14 none] +G c Z s b [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] +G c Z s b [test_optional_schema tinyaml__validation_tests 23 14 none] +G c Z s b [test_validated_as_integer tinyaml__validation_tests 24 14 none] +G c Z s b [test_validated_as_boolean tinyaml__validation_tests 25 14 none] +G c Z s b [test_parse_and_validate tinyaml__validation_tests 26 14 none] +G c Z s b [test_error_message_for_range tinyaml__validation_tests 27 14 none] +G c Z s b [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] +G c Z s b [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] +G c Z s b [test_nested_map_schema tinyaml__validation_tests 30 14 none] +G c Z s s [testDF tinyaml__validation_tests 6 9 none] +G c Z s s [testIP tinyaml__validation_tests 6 9 none] +G r c none [name tinyaml__validation_tests 8 24 none] [format aunit 44 13 none] +G r c none [register_tests tinyaml__validation_tests 9 25 none] [register_routine aunit__test_cases__registration 65 17 none] +G r c none [suite tinyaml__validation_tests 11 13 none] [new_suite aunit__test_suites 58 13 none] +G r s test_case [suite tinyaml__validation_tests 11 13 none] [test_caseIP aunit__test_cases 116 9 none] +G r c none [suite tinyaml__validation_tests 11 13 none] [add_test aunit__test_suites 48 14 none] +G r s str_schema [test_str_schema tinyaml__validation_tests 15 14 none] [str_schemaIP tinyaml__schemas__str 7 9 none] +G r s validation_result [test_str_schema tinyaml__validation_tests 15 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_str_schema tinyaml__validation_tests 15 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_str_schema tinyaml__validation_tests 15 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_str_schema tinyaml__validation_tests 15 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_str_schema tinyaml__validation_tests 15 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_str_schema tinyaml__validation_tests 15 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_str_schema tinyaml__validation_tests 15 14 none] [assert aunit__assertions 48 14 none] +G r s int_schema [test_int_schema tinyaml__validation_tests 16 14 none] [int_schemaIP tinyaml__schemas__int 13 9 none] +G r s validation_result [test_int_schema tinyaml__validation_tests 16 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_int_schema tinyaml__validation_tests 16 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_int_schema tinyaml__validation_tests 16 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_int_schema tinyaml__validation_tests 16 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_int_schema tinyaml__validation_tests 16 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_int_schema tinyaml__validation_tests 16 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_int_schema tinyaml__validation_tests 16 14 none] [assert aunit__assertions 48 14 none] +G r s validation_result [test_int_schema_range tinyaml__validation_tests 17 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_int_schema_range tinyaml__validation_tests 17 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_int_schema_range tinyaml__validation_tests 17 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_int_schema_range tinyaml__validation_tests 17 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_int_schema_range tinyaml__validation_tests 17 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_int_schema_range tinyaml__validation_tests 17 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_int_schema_range tinyaml__validation_tests 17 14 none] [assert aunit__assertions 48 14 none] +G r s int_schema [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [int_schemaIP tinyaml__schemas__int 13 9 none] +G r s validation_result [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_int_schema_rejects_string tinyaml__validation_tests 18 14 none] [assert aunit__assertions 48 14 none] +G r s bool_schema [test_bool_schema tinyaml__validation_tests 19 14 none] [bool_schemaIP tinyaml__schemas__bool 7 9 none] +G r c none [test_bool_schema tinyaml__validation_tests 19 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_bool_schema tinyaml__validation_tests 19 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_bool_schema tinyaml__validation_tests 19 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_bool_schema tinyaml__validation_tests 19 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_seq_schema tinyaml__validation_tests 20 14 none] [to_seq_item tinyaml__schemas__seq 10 13 none] +G r s validation_result [test_seq_schema tinyaml__validation_tests 20 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_seq_schema tinyaml__validation_tests 20 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_seq_schema tinyaml__validation_tests 20 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_seq_schema tinyaml__validation_tests 20 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_seq_schema tinyaml__validation_tests 20 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_seq_schema tinyaml__validation_tests 20 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_seq_schema tinyaml__validation_tests 20 14 none] [assert aunit__assertions 48 14 none] +G r s map_schema [test_map_schema tinyaml__validation_tests 21 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_map_schema tinyaml__validation_tests 21 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_map_schema tinyaml__validation_tests 21 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_map_schema tinyaml__validation_tests 21 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_map_schema tinyaml__validation_tests 21 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_map_schema tinyaml__validation_tests 21 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_map_schema tinyaml__validation_tests 21 14 none] [str tinyaml__schemas__map 28 14 none] +G r c none [test_map_schema tinyaml__validation_tests 21 14 none] [int tinyaml__schemas__map 33 14 none] +G r c none [test_map_schema tinyaml__validation_tests 21 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_map_schema tinyaml__validation_tests 21 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_map_schema tinyaml__validation_tests 21 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_map_schema tinyaml__validation_tests 21 14 none] [assert aunit__assertions 48 14 none] +G r s map_schema [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [str tinyaml__schemas__map 28 14 none] +G r c none [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [int tinyaml__schemas__map 33 14 none] +G r c none [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_map_schema_missing_field tinyaml__validation_tests 22 14 none] [assert aunit__assertions 48 14 none] +G r s map_schema [test_optional_schema tinyaml__validation_tests 23 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_optional_schema tinyaml__validation_tests 23 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_optional_schema tinyaml__validation_tests 23 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_optional_schema tinyaml__validation_tests 23 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_optional_schema tinyaml__validation_tests 23 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_optional_schema tinyaml__validation_tests 23 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_optional_schema tinyaml__validation_tests 23 14 none] [str tinyaml__schemas__map 28 14 none] +G r c none [test_optional_schema tinyaml__validation_tests 23 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_optional_schema tinyaml__validation_tests 23 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_optional_schema tinyaml__validation_tests 23 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_optional_schema tinyaml__validation_tests 23 14 none] [assert aunit__assertions 48 14 none] +G r s int_schema [test_validated_as_integer tinyaml__validation_tests 24 14 none] [int_schemaIP tinyaml__schemas__int 13 9 none] +G r s validation_result [test_validated_as_integer tinyaml__validation_tests 24 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_validated_as_integer tinyaml__validation_tests 24 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_validated_as_integer tinyaml__validation_tests 24 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_validated_as_integer tinyaml__validation_tests 24 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_validated_as_integer tinyaml__validation_tests 24 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_validated_as_integer tinyaml__validation_tests 24 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_validated_as_integer tinyaml__validation_tests 24 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_validated_as_integer tinyaml__validation_tests 24 14 none] [root tinyaml__validation 51 13 none] +G r c none [test_validated_as_integer tinyaml__validation_tests 24 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s bool_schema [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [bool_schemaIP tinyaml__schemas__bool 7 9 none] +G r s validation_result [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [parse tinyaml__parser 14 13 none] +G r c none [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [validate tinyaml__validation 68 13 none] +G r c none [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [root tinyaml__validation 51 13 none] +G r c none [test_validated_as_boolean tinyaml__validation_tests 25 14 none] [value tinyaml__nodes__scalar 15 13 none] +G r s map_schema [test_parse_and_validate tinyaml__validation_tests 26 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_parse_and_validate tinyaml__validation_tests 26 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_parse_and_validate tinyaml__validation_tests 26 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_parse_and_validate tinyaml__validation_tests 26 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_parse_and_validate tinyaml__validation_tests 26 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_parse_and_validate tinyaml__validation_tests 26 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_parse_and_validate tinyaml__validation_tests 26 14 none] [str tinyaml__schemas__map 28 14 none] +G r c none [test_parse_and_validate tinyaml__validation_tests 26 14 none] [int tinyaml__schemas__map 38 14 none] +G r c none [test_parse_and_validate tinyaml__validation_tests 26 14 none] [parse_and_validate tinyaml__validation 83 13 none] +G r c none [test_parse_and_validate tinyaml__validation_tests 26 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_parse_and_validate tinyaml__validation_tests 26 14 none] [assert aunit__assertions 48 14 none] +G r s map_schema [test_error_message_for_range tinyaml__validation_tests 27 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_error_message_for_range tinyaml__validation_tests 27 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_error_message_for_range tinyaml__validation_tests 27 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_error_message_for_range tinyaml__validation_tests 27 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_error_message_for_range tinyaml__validation_tests 27 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_error_message_for_range tinyaml__validation_tests 27 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_error_message_for_range tinyaml__validation_tests 27 14 none] [int tinyaml__schemas__map 38 14 none] +G r c none [test_error_message_for_range tinyaml__validation_tests 27 14 none] [parse_and_validate tinyaml__validation 83 13 none] +G r c none [test_error_message_for_range tinyaml__validation_tests 27 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_error_message_for_range tinyaml__validation_tests 27 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_error_message_for_range tinyaml__validation_tests 27 14 none] [error_path tinyaml__validation 57 13 none] +G r c none [test_error_message_for_range tinyaml__validation_tests 27 14 none] [error_message tinyaml__validation 54 13 none] +G r s map_schema [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [str tinyaml__schemas__map 28 14 none] +G r c none [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [parse_and_validate tinyaml__validation 83 13 none] +G r c none [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_error_message_for_missing_field tinyaml__validation_tests 28 14 none] [error_message tinyaml__validation 54 13 none] +G r c none [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [to_seq_item tinyaml__schemas__seq 10 13 none] +G r s validation_result [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [parse_and_validate tinyaml__validation 83 13 none] +G r c none [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_error_path_for_sequence tinyaml__validation_tests 29 14 none] [error_path tinyaml__validation 57 13 none] +G r s map_schema [test_nested_map_schema tinyaml__validation_tests 30 14 none] [map_schemaIP tinyaml__schemas__map 94 9 none] +G r l map_schema [test_nested_map_schema tinyaml__validation_tests 30 14 none] [map_schemaDI tinyaml__schemas__map 94 9 none] +G r k map_schema [test_nested_map_schema tinyaml__validation_tests 30 14 none] [map_schemaDF tinyaml__schemas__map 94 9 none] +G r s validation_result [test_nested_map_schema tinyaml__validation_tests 30 14 none] [validation_resultIP tinyaml__validation 98 9 none] +G r l validation_result [test_nested_map_schema tinyaml__validation_tests 30 14 none] [validation_resultDI tinyaml__validation 98 9 none] +G r k validation_result [test_nested_map_schema tinyaml__validation_tests 30 14 none] [validation_resultDF tinyaml__validation 98 9 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [str tinyaml__schemas__map 28 14 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [int tinyaml__schemas__map 38 14 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [map tinyaml__schemas__map 73 14 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [parse_and_validate tinyaml__validation 83 13 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [is_valid tinyaml__validation 48 13 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [assert aunit__assertions 48 14 none] +G r c none [test_nested_map_schema tinyaml__validation_tests 30 14 none] [error_path tinyaml__validation 57 13 none] +G r s test_case [testIP tinyaml__validation_tests 6 9 none] [test_caseIP aunit__test_cases 116 9 none] +X 14 a-iteint.ads +24h9 Forward_Iterator +32h9 Reversible_Iterator<24R9[8|84]> +X 22 a-tags.ads +653V13 CW_Membership{boolean} 103|207s15 219s15 +X 28 ada_containers-aunit_lists.ads +53R9*Cursor +X 29 aunit.ads +34K9*AUnit 48e10 102|1r6 1r28 2r6 8r47 11r26 103|1r6 1r28 11r8 13r47 16r14 +. 307r26 308r25 309r9 +36P9*Message_String(string) 102|8r53 103|13r53 +44V13*Format{36P9} 103|16s20 +X 30 aunit-assertions.ads +44K15*Assertions 155e21 103|1w12 1r34 +48U14*Assert 103|66s7 77s7 87s7 90s7 93s7 104s7 111s7 114s7 117s7 120s7 123s7 +. 126s7 129s7 146s7 162s7 176s7 188s7 195s7 206s7 207s7 218s7 219s7 232s7 +. 242s7 243s7 244s7 257s7 258s7 271s7 272s7 294s7 303s7 304s7 +101U14*Init_Test +104U14*Clear_Failures +107V13*Has_Failures{boolean} +110R9*Failure_Iter<28|53R9[145]> +113V13*First_Failure{110R9} +X 33 aunit-simple_test_cases.ads +57U14*Set_Up +60U14*Tear_Down +X 34 aunit-test_cases.ads +39K15*Test_Cases 121e21 102|1w12 1r34 103|11r14 +41H9*Test_Case<33|44R9> 119e14 102|6r21 15r42 16r42 17r48 18r57 19r43 20r42 +. 21r42 22r56 23r47 24r52 25r52 26r50 27r55 28r63 29r55 30r49 103|58r42 69r42 +. 80r48 96r57 107r43 134r42 149r42 165r56 179r47 198r52 210r52 222r50 235r55 +. 248r18 261r55 275r49 +57U14*Set_Up_Case +60U14*Tear_Down_Case +63K12*Registration 74e20 103|11r25 +65U17*Register_Routine 103|21s7 22s7 23s7 24s7 27s7 29s7 31s7 33s7 36s7 38s7 +. 40s7 42s7 45s7 48s7 51s7 54s7 +91U14*Run<33|67p14> +98U14*Run_Test<33|53p14> +101V13*Routine_Name{29|36P9}<33|50p13> +X 37 aunit-test_suites.ads +41K15*Test_Suites 86e22 102|2w12 11r32 103|307r32 308r31 309r15 +44P9*Access_Test_Suite(43R9) 102|11r44 103|307r44 308r43 +48U14*Add_Test 103|311s14 +58V13*New_Suite{44P9} 103|309s27 +X 45 system.ads +67M9*Address +X 54 s-memory.ads +51V13*Alloc{45|67M9} 101i22 +66U14*Free 102i22 +74V13*Realloc{45|67M9} 103i22 +X 66 s-stausa.ads +207U14*Initialize 208i22 +272U14*Output_Results 276i22 +X 68 s-stalib.adb +87U14 Break_Start 88i22 +X 82 tinyaml.ads +4K9*Tinyaml 64e12 102|4r9 32r5 103|3r6 4r6 4r32 5r6 5r32 6r6 6r35 7r6 7r32 +. 9r14 64r14 75r14 86r23 89r23 92r23 102r14 112r20 115r20 118r20 121r20 124r20 +. 127r20 130r24 144r14 160r14 174r14 187r23 192r12 204r14 216r14 315r5 +X 84 tinyaml-nodes.ads +9K17*Nodes 64e18 103|4w14 4r40 5r14 5r40 +16P9*Node_Access(15R9) 103|60r16 71r16 98r16 139r16 154r16 168r16 200r16 +. 212r16 +X 86 tinyaml-nodes-scalar.ads +5K23*Scalar 31e25 103|5w20 5r46 +7R9*Scalar_Node<84|15R9> 29e14 103|207r15 219r15 +15V13*Value{string} 103|207s45 219s45 +X 88 tinyaml-parser.ads +7K17*Parser 21e19 103|3w14 64r22 75r22 86r31 89r31 92r31 102r22 112r28 115r28 +. 118r28 121r28 124r28 127r28 130r32 144r22 160r22 174r22 187r31 192r20 204r22 +. 216r22 +14V13*Parse{84|16P9} 103|64s29 75s29 86s38 89s38 92s38 102s29 112s35 115s35 +. 118s35 121s35 124s35 127s35 130s39 144s29 160s29 174s29 187s38 192s27 204s29 +. 216s29 +X 89 tinyaml-schemas.ads +8K17*Schemas 48e20 103|6r14 6r43 +X 93 tinyaml-schemas-constraints-range_constraint.ads +6i7*Min{integer} 103|83m25 228m42 240m42 265m52 282m45 +7i7*Max{integer} 103|83m35 228m52 240m52 265m62 282m55 +X 96 tinyaml-schemas-int.ads +14r7*Constraint{9R12} 103|83m10 265m37 +X 97 tinyaml-schemas-map.ads +28U14*Str 103|158s14 172s14 184s14 185s14 227s14 254s14 255s14 281s17 284s21 +31b7 Optional{boolean} 103|185r31 +33U14*Int 103|159s14 173s14 +38U14*Int 103|228s14 240s14 282s17 +41r7 Constraint{93|5R9} 103|228r27 240r27 282r30 +73U14*Map 103|285s21 +X 98 tinyaml-schemas-prelude.ads +20K25*Prelude 58e28 103|6w22 6r51 +27R12*Str_Schema{100|7R9} 103|61r16 141r31 +30R12*Int_Schema{96|13R9} 103|72r16 82r29 99r16 201r16 265r25 +36R12*Bool_Schema{91|7R9} 103|109r16 213r16 +45R12*Seq_Schema{99|17R9} 103|140r25 263r25 +47V13*To_Seq_Item=48:34{99|8R9} 103|141s18 265s12 +53R12*Map_Schema{97|14R9} 103|155r16 169r16 181r16 224r16 237r16 251r16 277r23 +. 278r23 +X 99 tinyaml-schemas-seq.ads +18r7*Item{8R9} 103|141m10 264m10 +X 101 tinyaml-validation.ads +12K17*Validation 106e23 103|7w14 7r40 +45R9*Validation_Result 104e14 103|62r16 73r16 84r20 100r16 142r16 156r16 +. 170r16 182r16 202r16 214r16 225r16 238r16 252r16 266r16 279r23 +48V13*Is_Valid{boolean} 103|66s22 77s22 87s18 90s22 93s22 104s26 112s59 115s60 +. 118s58 121s57 124s57 127s58 130s64 146s22 162s22 176s26 188s18 195s18 206s22 +. 218s22 232s22 242s26 257s26 271s26 294s22 303s26 +51V13*Root{84|16P9} 103|207s35 219s35 +54V13*Error_Message{string} 103|244s22 258s22 +57V13*Error_Path{string} 103|243s22 272s22 304s22 +68V13*Validate{45R9} 103|65s17 76s17 86s13 89s13 92s13 103s17 112s10 115s10 +. 118s10 121s10 124s10 127s10 130s14 145s17 161s17 175s17 187s13 191s9 205s17 +. 217s17 +83V13*Parse_And_Validate{45R9} 103|230s9 241s17 256s17 269s9 288s9 297s9 +X 102 tinyaml-validation_tests.ads +4K17*Validation_Tests 82|4k9 102|15E14 32l13 32e29 103|9b22 315l13 315t29 +6R9*Test<34|41R9> 30|101p14 104p14 107p13 113p13 33|57p14 60p14 34|57p14 +. 60p14 91P14 98P14 101P13 102|6e47 8P24 8r34 9P25 9r52 103|13r34 19r52 311r28 +8V24*Name{29|36P9}<33|47p13> 8>30 103|13b24 17l8 17t12 +8r30 T{6R9} 103|13b30 14r28 +9U25*Register_Tests<34|54p14> 9=41 103|19b25 56l8 56t22 +9r41 T{6R9} 103|19b41 21m25 22m25 23m25 25m10 28m10 30m10 32m10 34m10 37m10 +. 39m10 41m10 43m10 46m10 49m10 52m10 55m10 +11V13*Suite{37|44P9} 103|307b13 313l8 313t13 +15U14 Test_Str_Schema 15=31 103|21r28 58b14 67l8 67t23 +15c31 T<34|41R9> 103|58b31 59r28 +16U14 Test_Int_Schema 16=31 103|22r28 69b14 78l8 78t23 +16c31 T<34|41R9> 103|69b31 70r28 +17U14 Test_Int_Schema_Range 17=37 103|23r28 80b14 94l8 94t29 +17c37 T<34|41R9> 103|80b37 81r28 +18U14 Test_Int_Schema_Rejects_String 18=46 103|25r13 96b14 105l8 105t38 +18c46 T<34|41R9> 103|96b46 97r28 +19U14 Test_Bool_Schema 19=32 103|28r13 107b14 132l8 132t24 +19c32 T<34|41R9> 103|107b32 108r28 +20U14 Test_Seq_Schema 20=31 103|30r13 134b14 147l8 147t23 +20c31 T<34|41R9> 103|134b31 135r28 +21U14 Test_Map_Schema 21=31 103|32r13 149b14 163l8 163t23 +21c31 T<34|41R9> 103|149b31 150r28 +22U14 Test_Map_Schema_Missing_Field 22=45 103|34r13 165b14 177l8 177t37 +22c45 T<34|41R9> 103|165b45 166r28 +23U14 Test_Optional_Schema 23=36 103|37r13 179b14 196l8 196t28 +23c36 T<34|41R9> 103|179b36 180r28 +24U14 Test_Validated_As_Integer 24=41 103|39r13 198b14 208l8 208t33 +24c41 T<34|41R9> 103|198b41 199r28 +25U14 Test_Validated_As_Boolean 25=41 103|41r13 210b14 220l8 220t33 +25c41 T<34|41R9> 103|210b41 211r28 +26U14 Test_Parse_And_Validate 26=39 103|43r13 222b14 233l8 233t31 +26c39 T<34|41R9> 103|222b39 223r28 +27U14 Test_Error_Message_For_Range 27=44 103|46r13 235b14 245l8 245t36 +27c44 T<34|41R9> 103|235b44 236r28 +28U14 Test_Error_Message_For_Missing_Field 28=52 103|49r13 247b14 259l8 259t44 +28c52 T<34|41R9> 103|248b7 250r28 +29U14 Test_Error_Path_For_Sequence 29=44 103|52r13 261b14 273l8 273t36 +29c44 T<34|41R9> 103|261b44 262r28 +30U14 Test_Nested_Map_Schema 30=38 103|55r13 275b14 305l8 305t30 +30c38 T<34|41R9> 103|275b38 276r28 +X 103 tinyaml-validation_tests.adb +60p7 Doc{84|16P9} 64m7 65r27 +61r7 Schema{98|27R12} 65r32 +62r7 Result{101|45R9} 65m7 66r15 +71p7 Doc{84|16P9} 75m7 76r27 +72r7 Schema{98|30R12} 76r32 +73r7 Result{101|45R9} 76m7 77r15 +82r7 Schema{98|30R12} 86r52 89r51 92r53 +84r7 R1{101|45R9} 86m7 87r15 +84r11 R2{101|45R9} 89m7 90r19 +84r15 R3{101|45R9} 92m7 93r19 +98p7 Doc{84|16P9} 102m7 103r27 +99r7 Schema{98|30R12} 103r32 +100r7 Result{101|45R9} 103m7 104r19 +109r7 Schema{98|36R12} 112r51 115r52 118r50 121r49 124r49 127r50 130r56 +136a7 Input{string} 144r36 +139p7 Doc{84|16P9} 144m7 145r27 +140r7 Schema{98|45R12} 145r32 +142r7 Result{101|45R9} 145m7 146r15 +151a7 Input{string} 160r36 +154p7 Doc{84|16P9} 160m7 161r27 +155r7 Schema{98|53R12} 158m7 158r7 159m7 159r7 161r32 +156r7 Result{101|45R9} 161m7 162r15 +167a7 Input{string} 174r36 +168p7 Doc{84|16P9} 174m7 175r27 +169r7 Schema{98|53R12} 172m7 172r7 173m7 173r7 175r32 +170r7 Result{101|45R9} 175m7 176r19 +181r7 Schema{98|53R12} 184m7 184r7 185m7 185r7 187r61 194r12 +182r7 R1{101|45R9} 187m7 188r15 +182r11 R2{101|45R9} 190m7 195r15 +200p7 Doc{84|16P9} 204m7 205r27 +201r7 Schema{98|30R12} 205r32 +202r7 Result{101|45R9} 205m7 206r15 207r28 +212p7 Doc{84|16P9} 216m7 217r27 +213r7 Schema{98|36R12} 217r32 +214r7 Result{101|45R9} 217m7 218r15 219r28 +224r7 Schema{98|53R12} 227m7 227r7 228m7 228r7 231r57 +225r7 Result{101|45R9} 229m7 232r15 +237r7 Schema{98|53R12} 240m7 240r7 241r52 +238r7 Result{101|45R9} 241m7 242r19 243r15 244r15 +251r7 Schema{98|53R12} 254m7 254r7 255m7 255r7 256r52 +252r7 Result{101|45R9} 256m7 257r19 258r15 +263r7 Schema{98|45R12} 270r58 +266r7 Result{101|45R9} 268m7 271r19 272r15 +277r7 Db_Schema{98|53R12} 281m7 281r7 282m7 282r7 285r38 +278r7 Server_Schema{98|53R12} 284m7 284r7 285m7 285r7 293r12 302r12 +279r7 Result{101|45R9} 287m7 294r15 296m7 303r19 304r15 +308p7 Result{37|44P9} 311r7 312r14 + diff --git a/tests/obj/tinyaml-validation_tests.cswi b/tests/obj/tinyaml-validation_tests.cswi new file mode 100644 index 0000000..5487583 --- /dev/null +++ b/tests/obj/tinyaml-validation_tests.cswi @@ -0,0 +1,9 @@ +20260101222045 +-c +-x +ada +-gnatA +-gnat2022 +-gnata +-g +-gnatwa diff --git a/tests/obj/tinyaml-validation_tests.o b/tests/obj/tinyaml-validation_tests.o new file mode 100644 index 0000000..7fbbad8 Binary files /dev/null and b/tests/obj/tinyaml-validation_tests.o differ diff --git a/tests/obj/tinyaml_tests.adb.stderr b/tests/obj/tinyaml_tests.adb.stderr new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/tinyaml_tests.adb.stdout b/tests/obj/tinyaml_tests.adb.stdout new file mode 100644 index 0000000..e69de29 diff --git a/tests/obj/tinyaml_tests.ali b/tests/obj/tinyaml_tests.ali new file mode 100644 index 0000000..6923dbe --- /dev/null +++ b/tests/obj/tinyaml_tests.ali @@ -0,0 +1,121 @@ +V "GNAT Lib v15" +A -gnatA +A -gnat2022 +A -gnata +A -g +A -gnatwa +A -mtune=generic +A -march=x86-64 +P SS ZX + +RN +RV NO_IMPLEMENTATION_PRAGMAS + +U tinyaml_tests%b tinyaml_tests.adb 4007cd01 NE OO PK +Z ada.strings.text_buffers%s a-sttebu.adb a-sttebu.ali +W tinyaml%s tinyaml.adb tinyaml.ali +W tinyaml.lexer_tests%s tinyaml-lexer_tests.adb tinyaml-lexer_tests.ali +W tinyaml.parser_tests%s tinyaml-parser_tests.adb tinyaml-parser_tests.ali +W tinyaml.validation_tests%s tinyaml-validation_tests.adb tinyaml-validation_tests.ali + +U tinyaml_tests%s tinyaml_tests.ads 64d90a3d EE NE OO PK +W aunit%s aunit.adb aunit.ali +W aunit.test_suites%s aunit-test_suites.adb aunit-test_suites.ali + +D ada.ads 20250808065140 76789da1 ada%s +D a-calend.ads 20250808065140 bf7f3cc9 ada.calendar%s +D a-charac.ads 20250808065140 2d3ec45b ada.characters%s +D a-chlat1.ads 20250808065140 e0d72e76 ada.characters.latin_1%s +D a-except.ads 20250808065140 e7970cd9 ada.exceptions%s +D a-finali.ads 20250808065140 bf4f806b ada.finalization%s +D a-inteio.ads 20250808065140 f64b89a4 ada.integer_text_io%s +D a-ioexce.ads 20250808065140 40018c65 ada.io_exceptions%s +D a-stream.ads 20250808065140 17477cbd ada.streams%s +D a-string.ads 20250808065140 90ac6797 ada.strings%s +D a-strmap.ads 20250808065140 1f91ebb6 ada.strings.maps%s +D a-strsea.ads 20250808065140 18c3c634 ada.strings.search%s +D a-sttebu.ads 20250808065140 f1ad67a2 ada.strings.text_buffers%s +D a-strunb.ads 20250808065140 b10770ab ada.strings.unbounded%s +D a-stuten.ads 20250808065140 c6ced0ae ada.strings.utf_encoding%s +D a-tags.ads 20250808065140 fbca0ad5 ada.tags%s +D a-textio.ads 20250808065140 34ef47de ada.text_io%s +D a-tiinio.ads 20250808065140 76699c8f ada.text_io.integer_io%s +D a-unccon.ads 20250808065140 0e9b276f ada.unchecked_conversion%s +D ada_containers.ads 20260101213759 11329e00 ada_containers%s +D ada_containers-aunit_lists.ads 20260101213759 d9ebc89a ada_containers.aunit_lists%s +D aunit.ads 20260101213759 76cdf7c6 aunit%s +D aunit-assertions.ads 20260101213759 b7f9ecd6 aunit.assertions%s +D aunit-io.ads 20260101213759 fb5ed18b aunit.io%s +D aunit-options.ads 20260101213759 6e5a02a6 aunit.options%s +D aunit-simple_test_cases.ads 20260101213759 4111c32f aunit.simple_test_cases%s +D aunit-test_cases.ads 20260101213759 3fb77584 aunit.test_cases%s +D aunit-test_filters.ads 20260101213759 f10b2127 aunit.test_filters%s +D aunit-test_results.ads 20260101213759 b44de7dc aunit.test_results%s +D aunit-test_suites.ads 20260101213759 6821dc24 aunit.test_suites%s +D aunit-tests.ads 20260101213759 1da11d49 aunit.tests%s +D aunit-time_measure.ads 20260101213759 d9c247b0 aunit.time_measure%s +D gnat.ads 20250808065140 b5988c27 gnat%s +D g-souinf.ads 20250808065140 470146ee gnat.source_info%s +D interfac.ads 20250808065140 9111f9c1 interfaces%s +D i-c.ads 20250808065140 e94c966a interfaces.c%s +D i-cstrea.ads 20250808065140 ffd01b9d interfaces.c_streams%s +D system.ads 20250808065140 14286b0f system%s +D s-atocou.ads 20250808065140 dc18efc3 system.atomic_counters%s +D s-crtl.ads 20250808065140 beb39b9e system.crtl%s +D s-exctab.ads 20250808065140 91bef6ef system.exception_table%s +D s-ficobl.ads 20250808065140 dc5161d4 system.file_control_block%s +D s-finpri.ads 20250808065140 5970d55a system.finalization_primitives%s +D s-finroo.ads 20250808065140 0a7c3ed4 system.finalization_root%s +D s-oscons.ads 20250827122531 068e1a91 system.os_constants%s +D s-oslock.ads 20250808065140 13fa6b78 system.os_locks%s +D s-parame.ads 20250808065140 3597fc11 system.parameters%s +D s-pooglo.ads 20250808065140 91708d21 system.pool_global%s +D s-putima.ads 20250808065140 17291fe4 system.put_images%s +D s-retsta.ads 20250808065140 0f6b06cb system.return_stack%s +D s-secsta.ads 20250808065140 578279f5 system.secondary_stack%s +D s-soflin.ads 20250808065140 5d88fdea system.soft_links%s +D s-stache.ads 20250808065140 0b81c1fe system.stack_checking%s +D s-stalib.ads 20250808065140 1c9580f6 system.standard_library%s +D s-stoele.ads 20250808065140 ccded4e8 system.storage_elements%s +D s-stopoo.ads 20250808065140 e9fa2dd8 system.storage_pools%s +D s-stratt.ads 20250808065140 516607ae system.stream_attributes%s +D s-traent.ads 20250808065140 c81cbf8c system.traceback_entries%s +D s-unstyp.ads 20250808065140 fa2a7f59 system.unsigned_types%s +D s-wchcon.ads 20250808065140 d9032363 system.wch_con%s +D tinyaml.ads 20251229202535 94e37d85 tinyaml%s +D tinyaml-lexer_tests.ads 20260101221409 512bcb6a tinyaml.lexer_tests%s +D tinyaml-parser_tests.ads 20260101221554 6ddb8d8e tinyaml.parser_tests%s +D tinyaml-validation_tests.ads 20260101221554 abdca9ca tinyaml.validation_tests%s +D tinyaml_tests.ads 20260101213037 0cf8d619 tinyaml_tests%s +D tinyaml_tests.adb 20260101213419 dbd3f436 tinyaml_tests%b +G a e +G c Z s b [suite tinyaml_tests 8 13 none] +G r c none [suite tinyaml_tests 8 13 none] [new_suite aunit__test_suites 58 13 none] +G r c none [suite tinyaml_tests 8 13 none] [suite tinyaml__lexer_tests 11 13 none] +G r c none [suite tinyaml_tests 8 13 none] [add_test aunit__test_suites 46 14 none] +G r c none [suite tinyaml_tests 8 13 none] [suite tinyaml__parser_tests 11 13 none] +G r c none [suite tinyaml_tests 8 13 none] [suite tinyaml__validation_tests 11 13 none] +X 22 aunit.ads +34K9*AUnit 48e10 65|4r6 8r26 66|7r26 8r25 9r9 +X 30 aunit-test_suites.ads +41K15*Test_Suites 86e22 65|4w12 8r32 66|7r32 8r31 9r15 +44P9*Access_Test_Suite(43R9) 65|8r44 66|7r44 8r43 +46U14*Add_Test 66|11s14 12s14 13s14 +58V13*New_Suite{44P9} 66|9s27 +X 61 tinyaml.ads +4K9*Tinyaml 64e12 66|1r6 2r6 3r6 11r24 12r24 13r24 +X 62 tinyaml-lexer_tests.ads +4K17*Lexer_Tests 29e24 66|1w14 11r32 +11V13*Suite{30|44P9} 66|11s44 +X 63 tinyaml-parser_tests.ads +4K17*Parser_Tests 28e25 66|2w14 12r32 +11V13*Suite{30|44P9} 66|12s45 +X 64 tinyaml-validation_tests.ads +4K17*Validation_Tests 32e29 66|3w14 13r32 +11V13*Suite{30|44P9} 66|13s49 +X 65 tinyaml_tests.ads +6K9*Tinyaml_Tests 10l5 10e18 66|5b14 17l5 17t18 +8V13*Suite{30|44P9} 66|7b13 15l8 15t13 +X 66 tinyaml_tests.adb +8p7 Result{30|44P9} 11r7 12r7 13r7 14r14 + diff --git a/tests/obj/tinyaml_tests.cswi b/tests/obj/tinyaml_tests.cswi new file mode 100644 index 0000000..9ec5b0f --- /dev/null +++ b/tests/obj/tinyaml_tests.cswi @@ -0,0 +1,9 @@ +20260101221705 +-c +-x +ada +-gnatA +-gnat2022 +-gnata +-g +-gnatwa diff --git a/tests/obj/tinyaml_tests.o b/tests/obj/tinyaml_tests.o new file mode 100644 index 0000000..6138ebd Binary files /dev/null and b/tests/obj/tinyaml_tests.o differ diff --git a/tests/test_harness.adb b/tests/test_harness.adb deleted file mode 100644 index 695ce34..0000000 --- a/tests/test_harness.adb +++ /dev/null @@ -1,156 +0,0 @@ -with Ada.Text_IO; -with Ada.Strings.Unbounded; - -package body Test_Harness is - - use Ada.Text_IO; - use Ada.Strings.Unbounded; - - -- Test state - Current_Suite : Unbounded_String; - Current_Test : Unbounded_String; - Test_Passed : Boolean := True; - Total_Tests : Natural := 0; - Passed_Tests : Natural := 0; - Failed_Tests : Natural := 0; - In_Test : Boolean := False; - - ---------------- - -- Initialize -- - ---------------- - - procedure Initialize (Suite_Name : String) is - begin - Current_Suite := To_Unbounded_String (Suite_Name); - Total_Tests := 0; - Passed_Tests := 0; - Failed_Tests := 0; - In_Test := False; - - Put_Line ("========================================"); - Put_Line ("Test Suite: " & Suite_Name); - Put_Line ("========================================"); - New_Line; - end Initialize; - - ---------------- - -- Start_Test -- - ---------------- - - procedure Start_Test (Name : String) is - begin - -- Finish previous test if any - if In_Test then - if Test_Passed then - Passed_Tests := Passed_Tests + 1; - end if; - end if; - - Current_Test := To_Unbounded_String (Name); - Test_Passed := True; - In_Test := True; - Total_Tests := Total_Tests + 1; - - Put (" [ ] " & Name); - end Start_Test; - - ------------ - -- Assert -- - ------------ - - procedure Assert (Condition : Boolean; Message : String := "") is - begin - if not Condition then - Fail (if Message = "" then "Assertion failed" else Message); - end if; - end Assert; - - ------------------ - -- Assert_Equal -- - ------------------ - - procedure Assert_Equal (Expected, Actual : String; Message : String := "") - is - begin - if Expected /= Actual then - Fail ((if Message = "" then "" else Message & ": ") & - "expected '" & Expected & "', got '" & Actual & "'"); - end if; - end Assert_Equal; - - ------------------ - -- Assert_Equal -- - ------------------ - - procedure Assert_Equal (Expected, Actual : Integer; Message : String := "") - is - begin - if Expected /= Actual then - Fail ((if Message = "" then "" else Message & ": ") & - "expected" & Expected'Image & ", got" & Actual'Image); - end if; - end Assert_Equal; - - ---------- - -- Fail -- - ---------- - - procedure Fail (Message : String) is - begin - if Test_Passed then - -- First failure for this test - Test_Passed := False; - Failed_Tests := Failed_Tests + 1; - -- Overwrite the [ ] with [FAIL] - Put (ASCII.CR & " [FAIL] " & To_String (Current_Test)); - New_Line; - end if; - Put_Line (" " & Message); - end Fail; - - ---------- - -- Pass -- - ---------- - - procedure Pass is - begin - if Test_Passed and In_Test then - -- Overwrite the [ ] with [ OK ] - Put (ASCII.CR & " [ OK ] " & To_String (Current_Test)); - New_Line; - end if; - end Pass; - - ------------- - -- Summary -- - ------------- - - procedure Summary is - begin - -- Finish final test if any - if In_Test then - if Test_Passed then - Passed_Tests := Passed_Tests + 1; - Pass; - end if; - In_Test := False; - end if; - - New_Line; - Put_Line ("========================================"); - Put_Line ("Results:" & Total_Tests'Image & " tests," & - Passed_Tests'Image & " passed," & - Failed_Tests'Image & " failed"); - Put_Line ("========================================"); - end Summary; - - ---------------- - -- All_Passed -- - ---------------- - - function All_Passed return Boolean is - begin - return Failed_Tests = 0; - end All_Passed; - -end Test_Harness; diff --git a/tests/test_harness.ads b/tests/test_harness.ads deleted file mode 100644 index 5929e30..0000000 --- a/tests/test_harness.ads +++ /dev/null @@ -1,32 +0,0 @@ --- Simple test harness for TinyAML tests - -package Test_Harness is - - -- Initialize the test harness - procedure Initialize (Suite_Name : String); - - -- Start a new test - procedure Start_Test (Name : String); - - -- Assert that a condition is true - procedure Assert (Condition : Boolean; Message : String := ""); - - -- Assert that two strings are equal - procedure Assert_Equal (Expected, Actual : String; Message : String := ""); - - -- Assert that two integers are equal - procedure Assert_Equal (Expected, Actual : Integer; Message : String := ""); - - -- Mark current test as failed with a message - procedure Fail (Message : String); - - -- Mark current test as passed (optional, auto-passed if no failures) - procedure Pass; - - -- Print summary - procedure Summary; - - -- Check if all tests passed - function All_Passed return Boolean; - -end Test_Harness; diff --git a/tests/test_lexer.adb b/tests/test_lexer.adb deleted file mode 100644 index 2e2d4dc..0000000 --- a/tests/test_lexer.adb +++ /dev/null @@ -1,220 +0,0 @@ -with Ada.Strings.Unbounded; - -with Test_Harness; -with Tinyaml; -with Tinyaml.Lexer; - -package body Test_Lexer is - - use Ada.Strings.Unbounded; - use Test_Harness; - use Tinyaml.Lexer; - - procedure Test_Empty_Input is - L : Lexer_State := Create (""); - T : Token; - begin - Start_Test ("Empty input returns EOF"); - Next_Token (L, T); - Assert (T.Kind = Token_EOF, "Expected EOF token"); - Pass; - end Test_Empty_Input; - - procedure Test_Simple_Scalar is - L : Lexer_State := Create ("hello"); - T : Token; - begin - Start_Test ("Simple unquoted scalar"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected Scalar token"); - Assert_Equal ("hello", To_String (T.Value)); - Next_Token (L, T); - Assert (T.Kind = Token_EOF, "Expected EOF after scalar"); - Pass; - end Test_Simple_Scalar; - - procedure Test_Quoted_String_Double is - L : Lexer_State := Create ("""hello world"""); - T : Token; - begin - Start_Test ("Double-quoted string"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected Scalar token"); - Assert_Equal ("hello world", To_String (T.Value)); - Pass; - end Test_Quoted_String_Double; - - procedure Test_Quoted_String_Single is - L : Lexer_State := Create ("'hello world'"); - T : Token; - begin - Start_Test ("Single-quoted string"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected Scalar token"); - Assert_Equal ("hello world", To_String (T.Value)); - Pass; - end Test_Quoted_String_Single; - - procedure Test_Escape_Sequences is - L : Lexer_State := Create ("""line1\nline2\ttab"""); - T : Token; - begin - Start_Test ("Escape sequences in double-quoted string"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected Scalar token"); - Assert_Equal ("line1" & ASCII.LF & "line2" & ASCII.HT & "tab", - To_String (T.Value)); - Pass; - end Test_Escape_Sequences; - - procedure Test_Colon is - L : Lexer_State := Create ("key: value"); - T : Token; - begin - Start_Test ("Colon token"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected key scalar"); - Assert_Equal ("key", To_String (T.Value)); - Next_Token (L, T); - Assert (T.Kind = Token_Colon, "Expected Colon token"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected value scalar"); - Assert_Equal ("value", To_String (T.Value)); - Pass; - end Test_Colon; - - procedure Test_Dash is - L : Lexer_State := Create ("- item"); - T : Token; - begin - Start_Test ("Dash token (sequence item)"); - Next_Token (L, T); - Assert (T.Kind = Token_Dash, "Expected Dash token"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected item scalar"); - Assert_Equal ("item", To_String (T.Value)); - Pass; - end Test_Dash; - - procedure Test_Indentation is - L : Lexer_State := Create ("parent:" & ASCII.LF & " child: value"); - T : Token; - begin - Start_Test ("Indentation tracking"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected parent scalar"); - Assert_Equal ("parent", To_String (T.Value)); - Next_Token (L, T); - Assert (T.Kind = Token_Colon, "Expected Colon"); - Next_Token (L, T); - Assert (T.Kind = Token_Newline, "Expected Newline"); - Next_Token (L, T); - Assert (T.Kind = Token_Indent, "Expected Indent token"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected child scalar"); - Assert_Equal ("child", To_String (T.Value)); - Pass; - end Test_Indentation; - - procedure Test_Dedent is - Input : constant String := - "parent:" & ASCII.LF & - " child: value" & ASCII.LF & - "sibling: other"; - L : Lexer_State := Create (Input); - T : Token; - begin - Start_Test ("Dedent tracking"); - -- Skip to the dedent - loop - Next_Token (L, T); - exit when T.Kind = Token_Dedent or T.Kind = Token_EOF; - end loop; - Assert (T.Kind = Token_Dedent, "Expected Dedent token"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected sibling scalar"); - Assert_Equal ("sibling", To_String (T.Value)); - Pass; - end Test_Dedent; - - procedure Test_Comment is - L : Lexer_State := Create ("value # this is a comment"); - T : Token; - begin - Start_Test ("Comment handling"); - Next_Token (L, T); - Assert (T.Kind = Token_Scalar, "Expected scalar"); - Assert_Equal ("value", To_String (T.Value)); - -- Comment should be skipped, next is newline or EOF - Next_Token (L, T); - Assert (T.Kind = Token_Newline or T.Kind = Token_EOF, - "Expected Newline or EOF after comment"); - Pass; - end Test_Comment; - - procedure Test_Flow_Style_Rejected is - L : Lexer_State := Create ("[a, b, c]"); - T : Token; - begin - Start_Test ("Flow style syntax rejected"); - begin - Next_Token (L, T); - Fail ("Should have raised Parse_Error for flow style"); - exception - when Tinyaml.Parse_Error => - Pass; - end; - end Test_Flow_Style_Rejected; - - procedure Test_Anchor_Rejected is - L : Lexer_State := Create ("&anchor value"); - T : Token; - begin - Start_Test ("Anchor syntax rejected"); - begin - Next_Token (L, T); - Fail ("Should have raised Parse_Error for anchor"); - exception - when Tinyaml.Parse_Error => - Pass; - end; - end Test_Anchor_Rejected; - - procedure Test_Tag_Rejected is - L : Lexer_State := Create ("!tag value"); - T : Token; - begin - Start_Test ("Tag syntax rejected"); - begin - Next_Token (L, T); - Fail ("Should have raised Parse_Error for tag"); - exception - when Tinyaml.Parse_Error => - Pass; - end; - end Test_Tag_Rejected; - - --------------- - -- Run_Tests -- - --------------- - - procedure Run_Tests is - begin - Initialize ("Lexer Tests"); - - Test_Empty_Input; - Test_Simple_Scalar; - Test_Quoted_String_Double; - Test_Quoted_String_Single; - Test_Escape_Sequences; - Test_Colon; - Test_Dash; - Test_Indentation; - Test_Dedent; - Test_Comment; - Test_Flow_Style_Rejected; - Test_Anchor_Rejected; - Test_Tag_Rejected; - end Run_Tests; - -end Test_Lexer; diff --git a/tests/test_lexer.ads b/tests/test_lexer.ads deleted file mode 100644 index 64dec3e..0000000 --- a/tests/test_lexer.ads +++ /dev/null @@ -1,7 +0,0 @@ --- Lexer tests for TinyAML - -package Test_Lexer is - - procedure Run_Tests; - -end Test_Lexer; diff --git a/tests/test_parser.adb b/tests/test_parser.adb deleted file mode 100644 index a3c791d..0000000 --- a/tests/test_parser.adb +++ /dev/null @@ -1,245 +0,0 @@ -with Test_Harness; -with Tinyaml; -with Tinyaml.Documents; -with Tinyaml.Parser; -with Tinyaml.Nodes; -with Tinyaml.Nodes.Map; -with Tinyaml.Nodes.Navigation; -with Tinyaml.Nodes.Scalar; -with Tinyaml.Nodes.Sequence; - -package body Test_Parser is - - use Test_Harness; - use Tinyaml.Documents; - use Tinyaml.Nodes; - use Tinyaml.Nodes.Map; - use Tinyaml.Nodes.Navigation; - use Tinyaml.Nodes.Scalar; - use Tinyaml.Nodes.Sequence; - - procedure Test_Empty_Input is - Doc : Node_Access; - begin - Start_Test ("Empty input"); - Doc := Tinyaml.Parser.Parse (""); - Assert (Doc /= null, "Should return a node"); - Assert (Is_Scalar (Doc.all), "Empty input should be scalar"); - Assert_Equal ("", Scalar_Node (Doc.all).Value); - Pass; - end Test_Empty_Input; - - procedure Test_Simple_Scalar is - Doc : Node_Access; - begin - Start_Test ("Simple scalar document"); - Doc := Tinyaml.Parser.Parse ("hello world"); - Assert (Doc /= null, "Should return a node"); - Assert (Is_Scalar (Doc.all), "Should be a scalar"); - Assert_Equal ("hello world", Scalar_Node (Doc.all).Value); - Pass; - end Test_Simple_Scalar; - - procedure Test_Simple_Mapping is - Doc : Node_Access; - M : Map_Node; - begin - Start_Test ("Simple mapping"); - Doc := Tinyaml.Parser.Parse ("key: value"); - Assert (Doc /= null, "Should return a node"); - Assert (Is_Map (Doc.all), "Should be a map"); - M := Map_Node (Doc.all); - Assert (M.Contains ("key"), "Should contain 'key'"); - Assert_Equal ("value", Scalar_Node (M.Get ("key").all).Value); - Pass; - end Test_Simple_Mapping; - - procedure Test_Nested_Mapping is - Input : constant String := - "database:" & ASCII.LF & - " host: localhost" & ASCII.LF & - " port: 5432"; - Doc : Node_Access; - M : Map_Node; - Db : Node_Access; - begin - Start_Test ("Nested mapping"); - Doc := Tinyaml.Parser.Parse (Input); - Assert (Is_Map (Doc.all), "Should be a map"); - M := Map_Node (Doc.all); - Assert (M.Contains ("database"), "Should contain 'database'"); - Db := M.Get ("database"); - Assert (Is_Map (Db.all), "database should be a map"); - Assert_Equal ("localhost", - Scalar_Node (Map_Node (Db.all).Get ("host").all).Value); - Assert_Equal ("5432", - Scalar_Node (Map_Node (Db.all).Get ("port").all).Value); - Pass; - end Test_Nested_Mapping; - - procedure Test_Simple_Sequence is - Input : constant String := - "- apple" & ASCII.LF & - "- banana" & ASCII.LF & - "- cherry"; - Doc : Node_Access; - S : Sequence_Node; - begin - Start_Test ("Simple sequence"); - Doc := Tinyaml.Parser.Parse (Input); - Assert (Is_Sequence (Doc.all), "Should be a sequence"); - S := Sequence_Node (Doc.all); - Assert_Equal (3, S.Length, "Should have 3 items"); - Assert_Equal ("apple", Scalar_Node (S.Element (1).all).Value); - Assert_Equal ("banana", Scalar_Node (S.Element (2).all).Value); - Assert_Equal ("cherry", Scalar_Node (S.Element (3).all).Value); - Pass; - end Test_Simple_Sequence; - - procedure Test_Sequence_Of_Mappings is - Input : constant String := - "- name: Alice" & ASCII.LF & - "- name: Bob"; - Doc : Node_Access; - S : Sequence_Node; - begin - Start_Test ("Sequence of mappings"); - Doc := Tinyaml.Parser.Parse (Input); - Assert (Is_Sequence (Doc.all), "Should be a sequence"); - S := Sequence_Node (Doc.all); - Assert_Equal (2, S.Length, "Should have 2 items"); - Assert (Is_Map (S.Element (1).all), "First item should be a map"); - Assert_Equal ("Alice", - Scalar_Node (Map_Node (S.Element (1).all).Get ("name").all).Value); - Pass; - end Test_Sequence_Of_Mappings; - - procedure Test_Mapping_With_Sequence is - Input : constant String := - "fruits:" & ASCII.LF & - " - apple" & ASCII.LF & - " - banana"; - Doc : Node_Access; - M : Map_Node; - S : Sequence_Node; - begin - Start_Test ("Mapping containing sequence"); - Doc := Tinyaml.Parser.Parse (Input); - Assert (Is_Map (Doc.all), "Should be a map"); - M := Map_Node (Doc.all); - Assert (M.Contains ("fruits"), "Should contain 'fruits'"); - Assert (Is_Sequence (M.Get ("fruits").all), "fruits should be sequence"); - S := Sequence_Node (M.Get ("fruits").all); - Assert_Equal (2, S.Length, "Should have 2 items"); - Assert_Equal ("apple", Scalar_Node (S.Element (1).all).Value); - Pass; - end Test_Mapping_With_Sequence; - - procedure Test_Duplicate_Key_Rejected is - Input : constant String := - "key: value1" & ASCII.LF & - "key: value2"; - begin - Start_Test ("Duplicate key rejected"); - begin - declare - Doc : constant Node_Access := Tinyaml.Parser.Parse (Input); - pragma Unreferenced (Doc); - begin - Fail ("Should have raised Parse_Error for duplicate key"); - end; - exception - when Tinyaml.Parse_Error => - Pass; - end; - end Test_Duplicate_Key_Rejected; - - procedure Test_Navigate_Path is - Input : constant String := - "database:" & ASCII.LF & - " connection:" & ASCII.LF & - " host: localhost"; - Doc : Node_Access; - Host : Node_Access; - begin - Start_Test ("Navigate with path"); - Doc := Tinyaml.Parser.Parse (Input); - Host := Navigate (Doc, "database.connection.host"); - Assert (Host /= null, "Should find host"); - Assert_Equal ("localhost", Scalar_Node (Host.all).Value); - Pass; - end Test_Navigate_Path; - - procedure Test_Get_String is - Input : constant String := - "config:" & ASCII.LF & - " name: myapp"; - Doc : Node_Access; - begin - Start_Test ("Get_String convenience function"); - Doc := Tinyaml.Parser.Parse (Input); - Assert_Equal ("myapp", Get_String (Doc, "config.name")); - Pass; - end Test_Get_String; - - procedure Test_Parse_Document is - Input : constant String := - "database:" & ASCII.LF & - " host: localhost" & ASCII.LF & - " port: 5432"; - begin - Start_Test ("Parse_Document with automatic memory management"); - declare - Doc : constant Document := Tinyaml.Parser.Parse_Document (Input); - begin - Assert (not Is_Empty (Doc), "Document should not be empty"); - Assert (Root (Doc) /= null, "Root should not be null"); - Assert (Is_Map (Root (Doc).all), "Root should be a map"); - Assert_Equal ("localhost", Get_String (Root (Doc), "database.host")); - Assert_Equal ("5432", Get_String (Root (Doc), "database.port")); - end; - -- Document goes out of scope here, memory is automatically freed - Pass; - end Test_Parse_Document; - - procedure Test_Free_Node is - Input : constant String := - "items:" & ASCII.LF & - " - one" & ASCII.LF & - " - two" & ASCII.LF & - " - three"; - Doc : Node_Access; - begin - Start_Test ("Free_Node deallocates tree"); - Doc := Tinyaml.Parser.Parse (Input); - Assert (Doc /= null, "Parse should return non-null"); - Assert (Is_Map (Doc.all), "Root should be a map"); - -- Manually free the tree - Free_Node (Doc); - Assert (Doc = null, "After Free_Node, access should be null"); - Pass; - end Test_Free_Node; - - --------------- - -- Run_Tests -- - --------------- - - procedure Run_Tests is - begin - Initialize ("Parser Tests"); - - Test_Empty_Input; - Test_Simple_Scalar; - Test_Simple_Mapping; - Test_Nested_Mapping; - Test_Simple_Sequence; - Test_Sequence_Of_Mappings; - Test_Mapping_With_Sequence; - Test_Duplicate_Key_Rejected; - Test_Navigate_Path; - Test_Get_String; - Test_Parse_Document; - Test_Free_Node; - end Run_Tests; - -end Test_Parser; diff --git a/tests/test_parser.ads b/tests/test_parser.ads deleted file mode 100644 index 2a6d01e..0000000 --- a/tests/test_parser.ads +++ /dev/null @@ -1,7 +0,0 @@ --- Parser tests for TinyAML - -package Test_Parser is - - procedure Run_Tests; - -end Test_Parser; diff --git a/tests/test_runner.adb b/tests/test_runner.adb index ce06b23..33d5475 100644 --- a/tests/test_runner.adb +++ b/tests/test_runner.adb @@ -1,25 +1,13 @@ -- Main test runner for TinyAML tests -with Test_Harness; -with Test_Lexer; -with Test_Parser; -with Test_Validation; +with AUnit.Reporter.Text; +with AUnit.Run; -with Ada.Command_Line; +with Tinyaml_Tests; procedure Test_Runner is + procedure Run is new AUnit.Run.Test_Runner (Tinyaml_Tests.Suite); + Reporter : AUnit.Reporter.Text.Text_Reporter; begin - -- Run all test suites - Test_Lexer.Run_Tests; - Test_Parser.Run_Tests; - Test_Validation.Run_Tests; - - -- Print summary and set exit code - Test_Harness.Summary; - - if Test_Harness.All_Passed then - Ada.Command_Line.Set_Exit_Status (Ada.Command_Line.Success); - else - Ada.Command_Line.Set_Exit_Status (Ada.Command_Line.Failure); - end if; + Run (Reporter); end Test_Runner; diff --git a/tests/test_validation.adb b/tests/test_validation.adb deleted file mode 100644 index 475ce4b..0000000 --- a/tests/test_validation.adb +++ /dev/null @@ -1,288 +0,0 @@ -with Test_Harness; -with Tinyaml.Parser; -with Tinyaml.Nodes; -with Tinyaml.Nodes.Scalar; -with Tinyaml.Schemas.Prelude; -with Tinyaml.Validation; - -package body Test_Validation is - - use Test_Harness; - use Tinyaml.Nodes; - use Tinyaml.Nodes.Scalar; - use Tinyaml.Schemas.Prelude; - use Tinyaml.Validation; - - procedure Test_Str_Schema is - Doc : Node_Access; - Schema : Str_Schema; - Result : Validation_Result; - begin - Start_Test ("Str schema accepts string"); - Doc := Tinyaml.Parser.Parse ("hello"); - Result := Validate (Doc, Schema); - Assert (Result.Is_Valid, "String should be valid"); - Pass; - end Test_Str_Schema; - - procedure Test_Int_Schema is - Doc : Node_Access; - Schema : Int_Schema; - Result : Validation_Result; - begin - Start_Test ("Int schema accepts integer"); - Doc := Tinyaml.Parser.Parse ("42"); - Result := Validate (Doc, Schema); - Assert (Result.Is_Valid, "Integer should be valid"); - Pass; - end Test_Int_Schema; - - procedure Test_Int_Schema_Range is - Schema : constant Int_Schema := - (Constraint => (Min => 1, Max => 100)); - R1, R2, R3 : Validation_Result; - begin - Start_Test ("Int schema with range"); - R1 := Validate (Tinyaml.Parser.Parse ("50"), Schema); - Assert (R1.Is_Valid, "50 should be in range 1-100"); - - R2 := Validate (Tinyaml.Parser.Parse ("0"), Schema); - Assert (not R2.Is_Valid, "0 should be out of range"); - - R3 := Validate (Tinyaml.Parser.Parse ("101"), Schema); - Assert (not R3.Is_Valid, "101 should be out of range"); - Pass; - end Test_Int_Schema_Range; - - procedure Test_Int_Schema_Rejects_String is - Doc : Node_Access; - Schema : Int_Schema; - Result : Validation_Result; - begin - Start_Test ("Int schema rejects non-integer"); - Doc := Tinyaml.Parser.Parse ("not a number"); - Result := Validate (Doc, Schema); - Assert (not Result.Is_Valid, "Non-integer should be invalid"); - Pass; - end Test_Int_Schema_Rejects_String; - - procedure Test_Bool_Schema is - Schema : Bool_Schema; - begin - Start_Test ("Bool schema accepts boolean values"); - Assert (Validate (Tinyaml.Parser.Parse ("true"), Schema).Is_Valid); - Assert (Validate (Tinyaml.Parser.Parse ("false"), Schema).Is_Valid); - Assert (Validate (Tinyaml.Parser.Parse ("yes"), Schema).Is_Valid); - Assert (Validate (Tinyaml.Parser.Parse ("no"), Schema).Is_Valid); - Assert (Validate (Tinyaml.Parser.Parse ("on"), Schema).Is_Valid); - Assert (Validate (Tinyaml.Parser.Parse ("off"), Schema).Is_Valid); - Assert (not Validate (Tinyaml.Parser.Parse ("maybe"), Schema).Is_Valid); - Pass; - end Test_Bool_Schema; - - procedure Test_Seq_Schema is - Input : constant String := - "- apple" & ASCII.LF & - "- banana"; - Doc : Node_Access; - Schema : constant Seq_Schema := - (Item => To_Seq_Item (Str_Schema'(null record))); - Result : Validation_Result; - begin - Start_Test ("Seq schema validates sequence items"); - Doc := Tinyaml.Parser.Parse (Input); - Result := Validate (Doc, Schema); - Assert (Result.Is_Valid, "Sequence of strings should be valid"); - Pass; - end Test_Seq_Schema; - - procedure Test_Map_Schema is - Input : constant String := - "name: Alice" & ASCII.LF & - "age: 30"; - Doc : Node_Access; - Schema : Map_Schema; - Result : Validation_Result; - begin - Start_Test ("Map schema validates fields"); - Schema.Str ("name"); - Schema.Int ("age"); - Doc := Tinyaml.Parser.Parse (Input); - Result := Validate (Doc, Schema); - Assert (Result.Is_Valid, "Map with valid fields should be valid"); - Pass; - end Test_Map_Schema; - - procedure Test_Map_Schema_Missing_Field is - Input : constant String := "name: Alice"; - Doc : Node_Access; - Schema : Map_Schema; - Result : Validation_Result; - begin - Start_Test ("Map schema detects missing required field"); - Schema.Str ("name"); - Schema.Int ("age"); - Doc := Tinyaml.Parser.Parse (Input); - Result := Validate (Doc, Schema); - Assert (not Result.Is_Valid, "Missing required field should be invalid"); - Pass; - end Test_Map_Schema_Missing_Field; - - procedure Test_Optional_Schema is - Schema : Map_Schema; - R1, R2 : Validation_Result; - begin - Start_Test ("Optional schema allows missing field"); - Schema.Str ("name"); - Schema.Str ("nickname", Optional => True); - - R1 := Validate (Tinyaml.Parser.Parse ("name: Alice"), Schema); - Assert (R1.Is_Valid, "Missing optional field should be valid"); - - R2 := Validate (Tinyaml.Parser.Parse ( - "name: Alice" & ASCII.LF & "nickname: Ali"), Schema); - Assert (R2.Is_Valid, "Present optional field should be valid"); - Pass; - end Test_Optional_Schema; - - procedure Test_Validated_As_Integer is - Doc : Node_Access; - Schema : Int_Schema; - Result : Validation_Result; - begin - Start_Test ("Validated scalar As_Integer"); - Doc := Tinyaml.Parser.Parse ("42"); - Result := Validate (Doc, Schema); - Assert (Result.Is_Valid, "Should be valid"); - -- Verify the value is correct - Assert_Equal ("42", Scalar_Node (Result.Root.all).Value); - Pass; - end Test_Validated_As_Integer; - - procedure Test_Validated_As_Boolean is - Doc : Node_Access; - Schema : Bool_Schema; - Result : Validation_Result; - begin - Start_Test ("Validated scalar As_Boolean"); - Doc := Tinyaml.Parser.Parse ("yes"); - Result := Validate (Doc, Schema); - Assert (Result.Is_Valid, "Should be valid"); - -- Verify the value is correct (accepted as boolean) - Assert_Equal ("yes", Scalar_Node (Result.Root.all).Value); - Pass; - end Test_Validated_As_Boolean; - - procedure Test_Parse_And_Validate is - Schema : Map_Schema; - Result : Validation_Result; - begin - Start_Test ("Parse_And_Validate convenience function"); - Schema.Str ("host"); - Schema.Int ("port", Constraint => (Min => 1, Max => 65535)); - Result := Parse_And_Validate ( - "host: localhost" & ASCII.LF & "port: 8080", Schema); - Assert (Result.Is_Valid, "Should be valid"); - Pass; - end Test_Parse_And_Validate; - - procedure Test_Error_Message_For_Range is - Schema : Map_Schema; - Result : Validation_Result; - begin - Start_Test ("Error message shows field path and constraint"); - Schema.Int ("port", Constraint => (Min => 1, Max => 65535)); - Result := Parse_And_Validate ("port: 99999", Schema); - Assert (not Result.Is_Valid, "Should be invalid"); - Assert (Result.Error_Path = "port", "Path should be 'port'"); - Assert (Result.Error_Message'Length > 0, "Should have error message"); - Pass; - end Test_Error_Message_For_Range; - - procedure Test_Error_Message_For_Missing_Field is - Schema : Map_Schema; - Result : Validation_Result; - begin - Start_Test ("Error message for missing required field"); - Schema.Str ("name"); - Schema.Str ("email"); - Result := Parse_And_Validate ("name: Alice", Schema); - Assert (not Result.Is_Valid, "Should be invalid"); - Assert (Result.Error_Message'Length > 0, "Should have error message"); - Pass; - end Test_Error_Message_For_Missing_Field; - - procedure Test_Error_Path_For_Sequence is - Schema : constant Seq_Schema := - (Item => To_Seq_Item (Int_Schema'(Constraint => (Min => 1, Max => 10)))); - Result : Validation_Result; - begin - Start_Test ("Error path for sequence item validation"); - Result := Parse_And_Validate ( - "- 5" & ASCII.LF & "- 20" & ASCII.LF & "- 3", Schema); - Assert (not Result.Is_Valid, "Should be invalid"); - -- Path should indicate the sequence index - Assert (Result.Error_Path'Length > 0, "Should have error path"); - Pass; - end Test_Error_Path_For_Sequence; - - procedure Test_Nested_Map_Schema is - Db_Schema : Map_Schema; - Server_Schema : Map_Schema; - Result : Validation_Result; - begin - Start_Test ("Nested map schema validation"); - -- Build nested schema first - Db_Schema.Str ("host"); - Db_Schema.Int ("port", Constraint => (Min => 1, Max => 65535)); - - -- Add it to parent - Server_Schema.Str ("name"); - Server_Schema.Map ("database", Db_Schema); - - -- Valid config - Result := Parse_And_Validate ( - "name: myserver" & ASCII.LF & - "database:" & ASCII.LF & - " host: localhost" & ASCII.LF & - " port: 5432", Server_Schema); - Assert (Result.Is_Valid, "Valid nested config should pass"); - - -- Invalid config (port out of range) - Result := Parse_And_Validate ( - "name: myserver" & ASCII.LF & - "database:" & ASCII.LF & - " host: localhost" & ASCII.LF & - " port: 99999", Server_Schema); - Assert (not Result.Is_Valid, "Invalid port should fail"); - Assert (Result.Error_Path'Length > 0, "Should have error path"); - Pass; - end Test_Nested_Map_Schema; - - --------------- - -- Run_Tests -- - --------------- - - procedure Run_Tests is - begin - Initialize ("Schema and Validation Tests"); - - Test_Str_Schema; - Test_Int_Schema; - Test_Int_Schema_Range; - Test_Int_Schema_Rejects_String; - Test_Bool_Schema; - Test_Seq_Schema; - Test_Map_Schema; - Test_Map_Schema_Missing_Field; - Test_Optional_Schema; - Test_Validated_As_Integer; - Test_Validated_As_Boolean; - Test_Parse_And_Validate; - Test_Error_Message_For_Range; - Test_Error_Message_For_Missing_Field; - Test_Error_Path_For_Sequence; - Test_Nested_Map_Schema; - end Run_Tests; - -end Test_Validation; diff --git a/tests/test_validation.ads b/tests/test_validation.ads deleted file mode 100644 index c5ad4c6..0000000 --- a/tests/test_validation.ads +++ /dev/null @@ -1,7 +0,0 @@ --- Schema and validation tests for TinyAML - -package Test_Validation is - - procedure Run_Tests; - -end Test_Validation; diff --git a/tests/tinyaml-lexer_tests.adb b/tests/tinyaml-lexer_tests.adb new file mode 100644 index 0000000..681162b --- /dev/null +++ b/tests/tinyaml-lexer_tests.adb @@ -0,0 +1,221 @@ +with Ada.Strings.Unbounded; + +with AUnit.Assertions; use AUnit.Assertions; + +with Tinyaml.Lexer; use Tinyaml.Lexer; + +package body Tinyaml.Lexer_Tests is + + use Ada.Strings.Unbounded; + use AUnit.Test_Cases.Registration; + + overriding function Name (T : Test) return AUnit.Message_String is + pragma Unreferenced (T); + begin + return AUnit.Format ("Lexer"); + end Name; + + overriding procedure Register_Tests (T : in out Test) is + begin + Register_Routine (T, Test_Empty_Input'Access, "Empty input returns EOF"); + Register_Routine (T, Test_Simple_Scalar'Access, "Simple unquoted scalar"); + Register_Routine + (T, Test_Quoted_String_Double'Access, "Double-quoted string"); + Register_Routine + (T, Test_Quoted_String_Single'Access, "Single-quoted string"); + Register_Routine + (T, Test_Escape_Sequences'Access, + "Escape sequences in double-quoted string"); + Register_Routine (T, Test_Colon'Access, "Colon token"); + Register_Routine (T, Test_Dash'Access, "Dash token (sequence item)"); + Register_Routine (T, Test_Indentation'Access, "Indentation tracking"); + Register_Routine (T, Test_Dedent'Access, "Dedent tracking"); + Register_Routine (T, Test_Comment'Access, "Comment handling"); + Register_Routine + (T, Test_Flow_Style_Rejected'Access, "Flow style syntax rejected"); + Register_Routine + (T, Test_Anchor_Rejected'Access, "Anchor syntax rejected"); + Register_Routine (T, Test_Tag_Rejected'Access, "Tag syntax rejected"); + end Register_Tests; + + procedure Test_Empty_Input (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create (""); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_EOF, "Expected EOF token"); + end Test_Empty_Input; + + procedure Test_Simple_Scalar (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("hello"); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected Scalar token"); + Assert (To_String (Tok.Value) = "hello", "Expected 'hello'"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_EOF, "Expected EOF after scalar"); + end Test_Simple_Scalar; + + procedure Test_Quoted_String_Double (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("""hello world"""); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected Scalar token"); + Assert (To_String (Tok.Value) = "hello world", "Expected 'hello world'"); + end Test_Quoted_String_Double; + + procedure Test_Quoted_String_Single (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("'hello world'"); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected Scalar token"); + Assert (To_String (Tok.Value) = "hello world", "Expected 'hello world'"); + end Test_Quoted_String_Single; + + procedure Test_Escape_Sequences (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("""line1\nline2\ttab"""); + Tok : Token; + Expected : constant String := + "line1" & ASCII.LF & "line2" & ASCII.HT & "tab"; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected Scalar token"); + Assert (To_String (Tok.Value) = Expected, "Escape sequences mismatch"); + end Test_Escape_Sequences; + + procedure Test_Colon (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("key: value"); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected key scalar"); + Assert (To_String (Tok.Value) = "key", "Expected 'key'"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Colon, "Expected Colon token"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected value scalar"); + Assert (To_String (Tok.Value) = "value", "Expected 'value'"); + end Test_Colon; + + procedure Test_Dash (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("- item"); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Dash, "Expected Dash token"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected item scalar"); + Assert (To_String (Tok.Value) = "item", "Expected 'item'"); + end Test_Dash; + + procedure Test_Indentation (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("parent:" & ASCII.LF & " child: value"); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected parent scalar"); + Assert (To_String (Tok.Value) = "parent", "Expected 'parent'"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Colon, "Expected Colon"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Newline, "Expected Newline"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Indent, "Expected Indent token"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected child scalar"); + Assert (To_String (Tok.Value) = "child", "Expected 'child'"); + end Test_Indentation; + + procedure Test_Dedent (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "parent:" & ASCII.LF & " child: value" & ASCII.LF & "sibling: other"; + L : Lexer_State := Create (Input); + Tok : Token; + begin + loop + Next_Token (L, Tok); + exit when Tok.Kind = Token_Dedent or Tok.Kind = Token_EOF; + end loop; + Assert (Tok.Kind = Token_Dedent, "Expected Dedent token"); + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected sibling scalar"); + Assert (To_String (Tok.Value) = "sibling", "Expected 'sibling'"); + end Test_Dedent; + + procedure Test_Comment (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("value # this is a comment"); + Tok : Token; + begin + Next_Token (L, Tok); + Assert (Tok.Kind = Token_Scalar, "Expected scalar"); + Assert (To_String (Tok.Value) = "value", "Expected 'value'"); + Next_Token (L, Tok); + Assert + (Tok.Kind = Token_Newline or Tok.Kind = Token_EOF, + "Expected Newline or EOF after comment"); + end Test_Comment; + + procedure Test_Flow_Style_Rejected (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("[a, b, c]"); + Tok : Token; + begin + begin + Next_Token (L, Tok); + Assert (False, "Should have raised Parse_Error for flow style"); + exception + when Tinyaml.Parse_Error => + null; + end; + end Test_Flow_Style_Rejected; + + procedure Test_Anchor_Rejected (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("&anchor value"); + Tok : Token; + begin + begin + Next_Token (L, Tok); + Assert (False, "Should have raised Parse_Error for anchor"); + exception + when Tinyaml.Parse_Error => + null; + end; + end Test_Anchor_Rejected; + + procedure Test_Tag_Rejected (T : in out Test_Case'Class) is + pragma Unreferenced (T); + L : Lexer_State := Create ("!tag value"); + Tok : Token; + begin + begin + Next_Token (L, Tok); + Assert (False, "Should have raised Parse_Error for tag"); + exception + when Tinyaml.Parse_Error => + null; + end; + end Test_Tag_Rejected; + + function Suite return AUnit.Test_Suites.Access_Test_Suite is + Result : constant AUnit.Test_Suites.Access_Test_Suite := + AUnit.Test_Suites.New_Suite; + begin + Result.Add_Test (new Test); + return Result; + end Suite; + +end Tinyaml.Lexer_Tests; diff --git a/tests/tinyaml-lexer_tests.ads b/tests/tinyaml-lexer_tests.ads new file mode 100644 index 0000000..5b515e0 --- /dev/null +++ b/tests/tinyaml-lexer_tests.ads @@ -0,0 +1,29 @@ +with AUnit.Test_Cases; use AUnit.Test_Cases; +with AUnit.Test_Suites; + +package Tinyaml.Lexer_Tests is + + type Test is new Test_Case with null record; + + overriding function Name (T : Test) return AUnit.Message_String; + overriding procedure Register_Tests (T : in out Test); + + function Suite return AUnit.Test_Suites.Access_Test_Suite; + +private + + procedure Test_Empty_Input (T : in out Test_Case'Class); + procedure Test_Simple_Scalar (T : in out Test_Case'Class); + procedure Test_Quoted_String_Double (T : in out Test_Case'Class); + procedure Test_Quoted_String_Single (T : in out Test_Case'Class); + procedure Test_Escape_Sequences (T : in out Test_Case'Class); + procedure Test_Colon (T : in out Test_Case'Class); + procedure Test_Dash (T : in out Test_Case'Class); + procedure Test_Indentation (T : in out Test_Case'Class); + procedure Test_Dedent (T : in out Test_Case'Class); + procedure Test_Comment (T : in out Test_Case'Class); + procedure Test_Flow_Style_Rejected (T : in out Test_Case'Class); + procedure Test_Anchor_Rejected (T : in out Test_Case'Class); + procedure Test_Tag_Rejected (T : in out Test_Case'Class); + +end Tinyaml.Lexer_Tests; diff --git a/tests/tinyaml-parser_tests.adb b/tests/tinyaml-parser_tests.adb new file mode 100644 index 0000000..8e4145b --- /dev/null +++ b/tests/tinyaml-parser_tests.adb @@ -0,0 +1,262 @@ +with AUnit.Assertions; use AUnit.Assertions; + +with Tinyaml.Documents; use Tinyaml.Documents; +with Tinyaml.Parser; +with Tinyaml.Nodes; use Tinyaml.Nodes; +with Tinyaml.Nodes.Map; use Tinyaml.Nodes.Map; +with Tinyaml.Nodes.Navigation; use Tinyaml.Nodes.Navigation; +with Tinyaml.Nodes.Scalar; use Tinyaml.Nodes.Scalar; +with Tinyaml.Nodes.Sequence; use Tinyaml.Nodes.Sequence; + +package body Tinyaml.Parser_Tests is + + use AUnit.Test_Cases.Registration; + + overriding function Name (T : Test) return AUnit.Message_String is + pragma Unreferenced (T); + begin + return AUnit.Format ("Parser"); + end Name; + + overriding procedure Register_Tests (T : in out Test) is + begin + Register_Routine (T, Test_Empty_Input'Access, "Empty input"); + Register_Routine (T, Test_Simple_Scalar'Access, "Simple scalar document"); + Register_Routine (T, Test_Simple_Mapping'Access, "Simple mapping"); + Register_Routine (T, Test_Nested_Mapping'Access, "Nested mapping"); + Register_Routine (T, Test_Simple_Sequence'Access, "Simple sequence"); + Register_Routine + (T, Test_Sequence_Of_Mappings'Access, "Sequence of mappings"); + Register_Routine + (T, Test_Mapping_With_Sequence'Access, "Mapping containing sequence"); + Register_Routine + (T, Test_Duplicate_Key_Rejected'Access, "Duplicate key rejected"); + Register_Routine (T, Test_Navigate_Path'Access, "Navigate with path"); + Register_Routine + (T, Test_Get_String'Access, "Get_String convenience function"); + Register_Routine + (T, Test_Parse_Document'Access, + "Parse_Document with automatic memory management"); + Register_Routine (T, Test_Free_Node'Access, "Free_Node deallocates tree"); + end Register_Tests; + + procedure Test_Empty_Input (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + begin + Doc := Tinyaml.Parser.Parse (""); + Assert (Doc /= null, "Should return a node"); + Assert (Is_Scalar (Doc.all), "Empty input should be scalar"); + Assert (Scalar_Node (Doc.all).Value = "", "Should be empty string"); + end Test_Empty_Input; + + procedure Test_Simple_Scalar (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + begin + Doc := Tinyaml.Parser.Parse ("hello world"); + Assert (Doc /= null, "Should return a node"); + Assert (Is_Scalar (Doc.all), "Should be a scalar"); + Assert + (Scalar_Node (Doc.all).Value = "hello world", + "Should be 'hello world'"); + end Test_Simple_Scalar; + + procedure Test_Simple_Mapping (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + M : Map_Node; + begin + Doc := Tinyaml.Parser.Parse ("key: value"); + Assert (Doc /= null, "Should return a node"); + Assert (Is_Map (Doc.all), "Should be a map"); + M := Map_Node (Doc.all); + Assert (M.Contains ("key"), "Should contain 'key'"); + Assert + (Scalar_Node (M.Get ("key").all).Value = "value", + "Value should be 'value'"); + end Test_Simple_Mapping; + + procedure Test_Nested_Mapping (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "database:" & ASCII.LF & + " host: localhost" & ASCII.LF & + " port: 5432"; + Doc : Node_Access; + M : Map_Node; + Db : Node_Access; + begin + Doc := Tinyaml.Parser.Parse (Input); + Assert (Is_Map (Doc.all), "Should be a map"); + M := Map_Node (Doc.all); + Assert (M.Contains ("database"), "Should contain 'database'"); + Db := M.Get ("database"); + Assert (Is_Map (Db.all), "database should be a map"); + Assert + (Scalar_Node (Map_Node (Db.all).Get ("host").all).Value = "localhost", + "host should be 'localhost'"); + Assert + (Scalar_Node (Map_Node (Db.all).Get ("port").all).Value = "5432", + "port should be '5432'"); + end Test_Nested_Mapping; + + procedure Test_Simple_Sequence (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "- apple" & ASCII.LF & + "- banana" & ASCII.LF & + "- cherry"; + Doc : Node_Access; + S : Sequence_Node; + begin + Doc := Tinyaml.Parser.Parse (Input); + Assert (Is_Sequence (Doc.all), "Should be a sequence"); + S := Sequence_Node (Doc.all); + Assert (S.Length = 3, "Should have 3 items"); + Assert + (Scalar_Node (S.Element (1).all).Value = "apple", + "First should be 'apple'"); + Assert + (Scalar_Node (S.Element (2).all).Value = "banana", + "Second should be 'banana'"); + Assert + (Scalar_Node (S.Element (3).all).Value = "cherry", + "Third should be 'cherry'"); + end Test_Simple_Sequence; + + procedure Test_Sequence_Of_Mappings (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "- name: Alice" & ASCII.LF & + "- name: Bob"; + Doc : Node_Access; + S : Sequence_Node; + begin + Doc := Tinyaml.Parser.Parse (Input); + Assert (Is_Sequence (Doc.all), "Should be a sequence"); + S := Sequence_Node (Doc.all); + Assert (S.Length = 2, "Should have 2 items"); + Assert (Is_Map (S.Element (1).all), "First item should be a map"); + Assert + (Scalar_Node (Map_Node (S.Element (1).all).Get ("name").all).Value = + "Alice", + "First name should be 'Alice'"); + end Test_Sequence_Of_Mappings; + + procedure Test_Mapping_With_Sequence (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "fruits:" & ASCII.LF & + " - apple" & ASCII.LF & + " - banana"; + Doc : Node_Access; + M : Map_Node; + S : Sequence_Node; + begin + Doc := Tinyaml.Parser.Parse (Input); + Assert (Is_Map (Doc.all), "Should be a map"); + M := Map_Node (Doc.all); + Assert (M.Contains ("fruits"), "Should contain 'fruits'"); + Assert (Is_Sequence (M.Get ("fruits").all), "fruits should be sequence"); + S := Sequence_Node (M.Get ("fruits").all); + Assert (S.Length = 2, "Should have 2 items"); + Assert + (Scalar_Node (S.Element (1).all).Value = "apple", + "First should be 'apple'"); + end Test_Mapping_With_Sequence; + + procedure Test_Duplicate_Key_Rejected (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "key: value1" & ASCII.LF & + "key: value2"; + begin + begin + declare + Doc : constant Node_Access := Tinyaml.Parser.Parse (Input); + pragma Unreferenced (Doc); + begin + Assert (False, "Should have raised Parse_Error for duplicate key"); + end; + exception + when Tinyaml.Parse_Error => + null; + end; + end Test_Duplicate_Key_Rejected; + + procedure Test_Navigate_Path (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "database:" & ASCII.LF & + " connection:" & ASCII.LF & + " host: localhost"; + Doc : Node_Access; + Host : Node_Access; + begin + Doc := Tinyaml.Parser.Parse (Input); + Host := Navigate (Doc, "database.connection.host"); + Assert (Host /= null, "Should find host"); + Assert + (Scalar_Node (Host.all).Value = "localhost", + "host should be 'localhost'"); + end Test_Navigate_Path; + + procedure Test_Get_String (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "config:" & ASCII.LF & + " name: myapp"; + Doc : Node_Access; + begin + Doc := Tinyaml.Parser.Parse (Input); + Assert (Get_String (Doc, "config.name") = "myapp", "Should be 'myapp'"); + end Test_Get_String; + + procedure Test_Parse_Document (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "database:" & ASCII.LF & + " host: localhost" & ASCII.LF & + " port: 5432"; + begin + declare + Doc : constant Document := Tinyaml.Parser.Parse_Document (Input); + begin + Assert (not Is_Empty (Doc), "Document should not be empty"); + Assert (Root (Doc) /= null, "Root should not be null"); + Assert (Is_Map (Root (Doc).all), "Root should be a map"); + Assert + (Get_String (Root (Doc), "database.host") = "localhost", + "host should be 'localhost'"); + Assert + (Get_String (Root (Doc), "database.port") = "5432", + "port should be '5432'"); + end; + end Test_Parse_Document; + + procedure Test_Free_Node (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "items:" & ASCII.LF & + " - one" & ASCII.LF & + " - two" & ASCII.LF & + " - three"; + Doc : Node_Access; + begin + Doc := Tinyaml.Parser.Parse (Input); + Assert (Doc /= null, "Parse should return non-null"); + Assert (Is_Map (Doc.all), "Root should be a map"); + Free_Node (Doc); + Assert (Doc = null, "After Free_Node, access should be null"); + end Test_Free_Node; + + function Suite return AUnit.Test_Suites.Access_Test_Suite is + Result : constant AUnit.Test_Suites.Access_Test_Suite := + AUnit.Test_Suites.New_Suite; + begin + Result.Add_Test (new Test); + return Result; + end Suite; + +end Tinyaml.Parser_Tests; diff --git a/tests/tinyaml-parser_tests.ads b/tests/tinyaml-parser_tests.ads new file mode 100644 index 0000000..e9cfa8e --- /dev/null +++ b/tests/tinyaml-parser_tests.ads @@ -0,0 +1,28 @@ +with AUnit.Test_Cases; use AUnit.Test_Cases; +with AUnit.Test_Suites; + +package Tinyaml.Parser_Tests is + + type Test is new Test_Case with null record; + + overriding function Name (T : Test) return AUnit.Message_String; + overriding procedure Register_Tests (T : in out Test); + + function Suite return AUnit.Test_Suites.Access_Test_Suite; + +private + + procedure Test_Empty_Input (T : in out Test_Case'Class); + procedure Test_Simple_Scalar (T : in out Test_Case'Class); + procedure Test_Simple_Mapping (T : in out Test_Case'Class); + procedure Test_Nested_Mapping (T : in out Test_Case'Class); + procedure Test_Simple_Sequence (T : in out Test_Case'Class); + procedure Test_Sequence_Of_Mappings (T : in out Test_Case'Class); + procedure Test_Mapping_With_Sequence (T : in out Test_Case'Class); + procedure Test_Duplicate_Key_Rejected (T : in out Test_Case'Class); + procedure Test_Navigate_Path (T : in out Test_Case'Class); + procedure Test_Get_String (T : in out Test_Case'Class); + procedure Test_Parse_Document (T : in out Test_Case'Class); + procedure Test_Free_Node (T : in out Test_Case'Class); + +end Tinyaml.Parser_Tests; diff --git a/tests/tinyaml-validation_tests.adb b/tests/tinyaml-validation_tests.adb new file mode 100644 index 0000000..b81b300 --- /dev/null +++ b/tests/tinyaml-validation_tests.adb @@ -0,0 +1,315 @@ +with AUnit.Assertions; use AUnit.Assertions; + +with Tinyaml.Parser; +with Tinyaml.Nodes; use Tinyaml.Nodes; +with Tinyaml.Nodes.Scalar; use Tinyaml.Nodes.Scalar; +with Tinyaml.Schemas.Prelude; use Tinyaml.Schemas.Prelude; +with Tinyaml.Validation; use Tinyaml.Validation; + +package body Tinyaml.Validation_Tests is + + use AUnit.Test_Cases.Registration; + + overriding function Name (T : Test) return AUnit.Message_String is + pragma Unreferenced (T); + begin + return AUnit.Format ("Validation"); + end Name; + + overriding procedure Register_Tests (T : in out Test) is + begin + Register_Routine (T, Test_Str_Schema'Access, "Str schema accepts string"); + Register_Routine (T, Test_Int_Schema'Access, "Int schema accepts integer"); + Register_Routine (T, Test_Int_Schema_Range'Access, "Int schema with range"); + Register_Routine + (T, Test_Int_Schema_Rejects_String'Access, + "Int schema rejects non-integer"); + Register_Routine + (T, Test_Bool_Schema'Access, "Bool schema accepts boolean values"); + Register_Routine + (T, Test_Seq_Schema'Access, "Seq schema validates sequence items"); + Register_Routine + (T, Test_Map_Schema'Access, "Map schema validates fields"); + Register_Routine + (T, Test_Map_Schema_Missing_Field'Access, + "Map schema detects missing required field"); + Register_Routine + (T, Test_Optional_Schema'Access, "Optional schema allows missing field"); + Register_Routine + (T, Test_Validated_As_Integer'Access, "Validated scalar As_Integer"); + Register_Routine + (T, Test_Validated_As_Boolean'Access, "Validated scalar As_Boolean"); + Register_Routine + (T, Test_Parse_And_Validate'Access, + "Parse_And_Validate convenience function"); + Register_Routine + (T, Test_Error_Message_For_Range'Access, + "Error message shows field path and constraint"); + Register_Routine + (T, Test_Error_Message_For_Missing_Field'Access, + "Error message for missing required field"); + Register_Routine + (T, Test_Error_Path_For_Sequence'Access, + "Error path for sequence item validation"); + Register_Routine + (T, Test_Nested_Map_Schema'Access, "Nested map schema validation"); + end Register_Tests; + + procedure Test_Str_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + Schema : Str_Schema; + Result : Validation_Result; + begin + Doc := Tinyaml.Parser.Parse ("hello"); + Result := Validate (Doc, Schema); + Assert (Result.Is_Valid, "String should be valid"); + end Test_Str_Schema; + + procedure Test_Int_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + Schema : Int_Schema; + Result : Validation_Result; + begin + Doc := Tinyaml.Parser.Parse ("42"); + Result := Validate (Doc, Schema); + Assert (Result.Is_Valid, "Integer should be valid"); + end Test_Int_Schema; + + procedure Test_Int_Schema_Range (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Schema : constant Int_Schema := + (Constraint => (Min => 1, Max => 100)); + R1, R2, R3 : Validation_Result; + begin + R1 := Validate (Tinyaml.Parser.Parse ("50"), Schema); + Assert (R1.Is_Valid, "50 should be in range 1-100"); + + R2 := Validate (Tinyaml.Parser.Parse ("0"), Schema); + Assert (not R2.Is_Valid, "0 should be out of range"); + + R3 := Validate (Tinyaml.Parser.Parse ("101"), Schema); + Assert (not R3.Is_Valid, "101 should be out of range"); + end Test_Int_Schema_Range; + + procedure Test_Int_Schema_Rejects_String (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + Schema : Int_Schema; + Result : Validation_Result; + begin + Doc := Tinyaml.Parser.Parse ("not a number"); + Result := Validate (Doc, Schema); + Assert (not Result.Is_Valid, "Non-integer should be invalid"); + end Test_Int_Schema_Rejects_String; + + procedure Test_Bool_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Schema : Bool_Schema; + begin + Assert + (Validate (Tinyaml.Parser.Parse ("true"), Schema).Is_Valid, + "'true' should be valid"); + Assert + (Validate (Tinyaml.Parser.Parse ("false"), Schema).Is_Valid, + "'false' should be valid"); + Assert + (Validate (Tinyaml.Parser.Parse ("yes"), Schema).Is_Valid, + "'yes' should be valid"); + Assert + (Validate (Tinyaml.Parser.Parse ("no"), Schema).Is_Valid, + "'no' should be valid"); + Assert + (Validate (Tinyaml.Parser.Parse ("on"), Schema).Is_Valid, + "'on' should be valid"); + Assert + (Validate (Tinyaml.Parser.Parse ("off"), Schema).Is_Valid, + "'off' should be valid"); + Assert + (not Validate (Tinyaml.Parser.Parse ("maybe"), Schema).Is_Valid, + "'maybe' should be invalid"); + end Test_Bool_Schema; + + procedure Test_Seq_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "- apple" & ASCII.LF & + "- banana"; + Doc : Node_Access; + Schema : constant Seq_Schema := + (Item => To_Seq_Item (Str_Schema'(null record))); + Result : Validation_Result; + begin + Doc := Tinyaml.Parser.Parse (Input); + Result := Validate (Doc, Schema); + Assert (Result.Is_Valid, "Sequence of strings should be valid"); + end Test_Seq_Schema; + + procedure Test_Map_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := + "name: Alice" & ASCII.LF & + "age: 30"; + Doc : Node_Access; + Schema : Map_Schema; + Result : Validation_Result; + begin + Schema.Str ("name"); + Schema.Int ("age"); + Doc := Tinyaml.Parser.Parse (Input); + Result := Validate (Doc, Schema); + Assert (Result.Is_Valid, "Map with valid fields should be valid"); + end Test_Map_Schema; + + procedure Test_Map_Schema_Missing_Field (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Input : constant String := "name: Alice"; + Doc : Node_Access; + Schema : Map_Schema; + Result : Validation_Result; + begin + Schema.Str ("name"); + Schema.Int ("age"); + Doc := Tinyaml.Parser.Parse (Input); + Result := Validate (Doc, Schema); + Assert (not Result.Is_Valid, "Missing required field should be invalid"); + end Test_Map_Schema_Missing_Field; + + procedure Test_Optional_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Schema : Map_Schema; + R1, R2 : Validation_Result; + begin + Schema.Str ("name"); + Schema.Str ("nickname", Optional => True); + + R1 := Validate (Tinyaml.Parser.Parse ("name: Alice"), Schema); + Assert (R1.Is_Valid, "Missing optional field should be valid"); + + R2 := + Validate + (Tinyaml.Parser.Parse + ("name: Alice" & ASCII.LF & "nickname: Ali"), + Schema); + Assert (R2.Is_Valid, "Present optional field should be valid"); + end Test_Optional_Schema; + + procedure Test_Validated_As_Integer (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + Schema : Int_Schema; + Result : Validation_Result; + begin + Doc := Tinyaml.Parser.Parse ("42"); + Result := Validate (Doc, Schema); + Assert (Result.Is_Valid, "Should be valid"); + Assert (Scalar_Node (Result.Root.all).Value = "42", "Should be '42'"); + end Test_Validated_As_Integer; + + procedure Test_Validated_As_Boolean (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Doc : Node_Access; + Schema : Bool_Schema; + Result : Validation_Result; + begin + Doc := Tinyaml.Parser.Parse ("yes"); + Result := Validate (Doc, Schema); + Assert (Result.Is_Valid, "Should be valid"); + Assert (Scalar_Node (Result.Root.all).Value = "yes", "Should be 'yes'"); + end Test_Validated_As_Boolean; + + procedure Test_Parse_And_Validate (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Schema : Map_Schema; + Result : Validation_Result; + begin + Schema.Str ("host"); + Schema.Int ("port", Constraint => (Min => 1, Max => 65535)); + Result := + Parse_And_Validate + ("host: localhost" & ASCII.LF & "port: 8080", Schema); + Assert (Result.Is_Valid, "Should be valid"); + end Test_Parse_And_Validate; + + procedure Test_Error_Message_For_Range (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Schema : Map_Schema; + Result : Validation_Result; + begin + Schema.Int ("port", Constraint => (Min => 1, Max => 65535)); + Result := Parse_And_Validate ("port: 99999", Schema); + Assert (not Result.Is_Valid, "Should be invalid"); + Assert (Result.Error_Path = "port", "Path should be 'port'"); + Assert (Result.Error_Message'Length > 0, "Should have error message"); + end Test_Error_Message_For_Range; + + procedure Test_Error_Message_For_Missing_Field + (T : in out Test_Case'Class) + is + pragma Unreferenced (T); + Schema : Map_Schema; + Result : Validation_Result; + begin + Schema.Str ("name"); + Schema.Str ("email"); + Result := Parse_And_Validate ("name: Alice", Schema); + Assert (not Result.Is_Valid, "Should be invalid"); + Assert (Result.Error_Message'Length > 0, "Should have error message"); + end Test_Error_Message_For_Missing_Field; + + procedure Test_Error_Path_For_Sequence (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Schema : constant Seq_Schema := + (Item => + To_Seq_Item (Int_Schema'(Constraint => (Min => 1, Max => 10)))); + Result : Validation_Result; + begin + Result := + Parse_And_Validate + ("- 5" & ASCII.LF & "- 20" & ASCII.LF & "- 3", Schema); + Assert (not Result.Is_Valid, "Should be invalid"); + Assert (Result.Error_Path'Length > 0, "Should have error path"); + end Test_Error_Path_For_Sequence; + + procedure Test_Nested_Map_Schema (T : in out Test_Case'Class) is + pragma Unreferenced (T); + Db_Schema : Map_Schema; + Server_Schema : Map_Schema; + Result : Validation_Result; + begin + Db_Schema.Str ("host"); + Db_Schema.Int ("port", Constraint => (Min => 1, Max => 65535)); + + Server_Schema.Str ("name"); + Server_Schema.Map ("database", Db_Schema); + + Result := + Parse_And_Validate + ("name: myserver" & ASCII.LF & + "database:" & ASCII.LF & + " host: localhost" & ASCII.LF & + " port: 5432", + Server_Schema); + Assert (Result.Is_Valid, "Valid nested config should pass"); + + Result := + Parse_And_Validate + ("name: myserver" & ASCII.LF & + "database:" & ASCII.LF & + " host: localhost" & ASCII.LF & + " port: 99999", + Server_Schema); + Assert (not Result.Is_Valid, "Invalid port should fail"); + Assert (Result.Error_Path'Length > 0, "Should have error path"); + end Test_Nested_Map_Schema; + + function Suite return AUnit.Test_Suites.Access_Test_Suite is + Result : constant AUnit.Test_Suites.Access_Test_Suite := + AUnit.Test_Suites.New_Suite; + begin + Result.Add_Test (new Test); + return Result; + end Suite; + +end Tinyaml.Validation_Tests; diff --git a/tests/tinyaml-validation_tests.ads b/tests/tinyaml-validation_tests.ads new file mode 100644 index 0000000..ff2355d --- /dev/null +++ b/tests/tinyaml-validation_tests.ads @@ -0,0 +1,32 @@ +with AUnit.Test_Cases; use AUnit.Test_Cases; +with AUnit.Test_Suites; + +package Tinyaml.Validation_Tests is + + type Test is new Test_Case with null record; + + overriding function Name (T : Test) return AUnit.Message_String; + overriding procedure Register_Tests (T : in out Test); + + function Suite return AUnit.Test_Suites.Access_Test_Suite; + +private + + procedure Test_Str_Schema (T : in out Test_Case'Class); + procedure Test_Int_Schema (T : in out Test_Case'Class); + procedure Test_Int_Schema_Range (T : in out Test_Case'Class); + procedure Test_Int_Schema_Rejects_String (T : in out Test_Case'Class); + procedure Test_Bool_Schema (T : in out Test_Case'Class); + procedure Test_Seq_Schema (T : in out Test_Case'Class); + procedure Test_Map_Schema (T : in out Test_Case'Class); + procedure Test_Map_Schema_Missing_Field (T : in out Test_Case'Class); + procedure Test_Optional_Schema (T : in out Test_Case'Class); + procedure Test_Validated_As_Integer (T : in out Test_Case'Class); + procedure Test_Validated_As_Boolean (T : in out Test_Case'Class); + procedure Test_Parse_And_Validate (T : in out Test_Case'Class); + procedure Test_Error_Message_For_Range (T : in out Test_Case'Class); + procedure Test_Error_Message_For_Missing_Field (T : in out Test_Case'Class); + procedure Test_Error_Path_For_Sequence (T : in out Test_Case'Class); + procedure Test_Nested_Map_Schema (T : in out Test_Case'Class); + +end Tinyaml.Validation_Tests; diff --git a/tests/tinyaml_tests.adb b/tests/tinyaml_tests.adb new file mode 100644 index 0000000..5f47f73 --- /dev/null +++ b/tests/tinyaml_tests.adb @@ -0,0 +1,17 @@ +with Tinyaml.Lexer_Tests; +with Tinyaml.Parser_Tests; +with Tinyaml.Validation_Tests; + +package body Tinyaml_Tests is + + function Suite return AUnit.Test_Suites.Access_Test_Suite is + Result : constant AUnit.Test_Suites.Access_Test_Suite := + AUnit.Test_Suites.New_Suite; + begin + Result.Add_Test (Tinyaml.Lexer_Tests.Suite); + Result.Add_Test (Tinyaml.Parser_Tests.Suite); + Result.Add_Test (Tinyaml.Validation_Tests.Suite); + return Result; + end Suite; + +end Tinyaml_Tests; diff --git a/tests/tinyaml_tests.ads b/tests/tinyaml_tests.ads new file mode 100644 index 0000000..9e72805 --- /dev/null +++ b/tests/tinyaml_tests.ads @@ -0,0 +1,10 @@ +-- Root test package for TinyAML +-- Provides the main test suite that aggregates all sub-suites + +with AUnit.Test_Suites; + +package Tinyaml_Tests is + + function Suite return AUnit.Test_Suites.Access_Test_Suite; + +end Tinyaml_Tests; diff --git a/tests/tinyaml_tests.gpr b/tests/tinyaml_tests.gpr index 46b88ec..caac75d 100644 --- a/tests/tinyaml_tests.gpr +++ b/tests/tinyaml_tests.gpr @@ -1,10 +1,11 @@ -with "../tinyaml.gpr"; +with "tinyaml"; +with "aunit"; project Tinyaml_Tests is for Source_Dirs use ("."); - for Object_Dir use "../obj/tests"; - for Exec_Dir use "../bin"; + for Object_Dir use "obj"; + for Exec_Dir use "bin"; for Create_Missing_Dirs use "True"; for Main use ("test_runner.adb");